context manager class for SQLite3 db connection

class SQLite():
    ''' Class is a wrapper for sqlite3 context manager. 
        Returs sqlite3.connection().cursor object ready to execute query
        Usage: with SQLite() as c:
                  c.execute('SELECT * FROM table')
    '''

    def __init__(self, db):
        self.db = db

    def __enter__(self):
        self.conn = sqlite3.connect(self.db)
        return self.conn.cursor()

    def __exit__(self, type, value, traceback):
        self.conn.commit()
        self.conn.close()

def _rgb_to_interior(rgb):
    '''returns value of color for "Interior" property'''
    return (rgb[2] << 16) + (rgb[1] << 8) + rgb[0]

this is base for macro keyboard to intercept Fx keys under Windows 10/11

import psutil
import keyboard
import pygetwindow as gw
import time

def is_teams_open():
    # Check if Microsoft Teams process is running
    for process in psutil.process_iter(['name']):
        if 'Teams' in process.info['name']:
            return True
    return False

def activate_teams():
    # Activate Microsoft Teams if open
    if is_teams_open():
        windows = gw.getWindowsWithTitle("Microsoft Teams")
        if windows:
            teams_window = windows[0]
            if teams_window.isMinimized:
                teams_window.restore()
            teams_window.activate()
            print("Microsoft Teams activated.")
        else:
            print("Teams is running but no window found.")
    else:
        print("Microsoft Teams is not running.")

# Bind F20 key to activate Teams if it is open
keyboard.add_hotkey('f20', activate_teams)

print("Listening for F20 to activate Teams...")
keyboard.wait('esc')  # Press 'Esc' to exit

from PG Hackaton

df = spark.table("userdb_eupscanalytics_im.hackaton_characters")
df_filtered = df.filter(regexp_extract(col("Character_id"), r'^\d+$', 0) != '')
df_filtered = df_filtered.filter(col("Death") == 'nan')
df_filtered[df_filtered['Name'] > 0]

go through API for libs/functions U use the most

compare wti vanilla PANDAS approach

import keyboard
def on_key_event(event):
  if event.event_type == "down":
    print(event.scan_code)
keyboard.hook(on_key_event)

import logging
import pathlib

console_log_formatter = logging.Formatter('%(levelname)s: %(module)s.%(funcName)s() line:%(lineno)s; Message: %(message)s')
file_log_formatter = logging.Formatter('%(levelname)s: %(module)s.%(funcName)s(); line:%(lineno)s; Message: %(message)s')

detailed_formatter = logging.Formatter('%(levelname)s: %(module)s.%(funcName)s() line:%(lineno)s; Message: %(message)s')
simple_formatter = logging.Formatter('%(message)s')

# Custom handler to switch formats based on the log level
class LevelBasedFormatter(logging.StreamHandler):
    def emit(self, record):
        # Set the formatter based on the log level
        if record.levelno == logging.INFO:
            self.setFormatter(simple_formatter)  # Use simple format for INFO level
        else:
            self.setFormatter(detailed_formatter)  # Use detailed format for all other levels
        super().emit(record)

# ----- Logging setup ---------------------------------------------------------
logc  = logging.getLogger("console logger")
logf  = logging.getLogger("file logger")

logc.setLevel(logging.DEBUG)
logf.setLevel(logging.DEBUG)

console_log_handler = logging.StreamHandler()
log_fname = pathlib.Path(__file__).parent.parent.joinpath(pathlib.Path(__file__).stem).with_suffix(".log")
file_log_handler = logging.FileHandler(filename=log_fname,mode="w")


# console_log_handler.setFormatter(console_log_formatter)
file_log_handler.setFormatter(file_log_formatter)
console_log_handler = LevelBasedFormatter()

logc.addHandler(console_log_handler)
logf.addHandler(file_log_handler)
# -----------------------------------------------------------------------------

import json
import pathlib, os
from types import SimpleNamespace

class Config:
    CONFIG_PATH = pathlib.Path(os.path.dirname(os.path.realpath(__file__)))
    CONFIG_FILE = 'config.json'
    CONFIG_FILEPATH  = CONFIG_PATH.joinpath(CONFIG_FILE)
    # def __init__(self, config_file='config.json'):
    def __init__(self, config_file=CONFIG_FILEPATH):

        with open(file=config_file, mode='r', encoding='utf-8') as f:
            self.config = json.load(f, object_hook=lambda d: SimpleNamespace(**d))

import argparse
from random import randint
from pyautogui import press, hold, countdown, size, moveTo

parser = argparse.ArgumentParser(description='Make songbook')
parser.add_argument('duration', type=int, nargs='?', default=40, help='how many cycle to loop')
parser.add_argument('-m', '--method', type=int, default=1, choices=[1, 2],help='1 - keyboard\n2 - mouse')
parser.add_argument('-f', '--frequency', type=int, default=59,help='how ofter action is triggered [s]')
args = parser.parse_args()

print(args)

def _action(method):
    if method == 1:
        with hold('alt'):
            press('tab')
    elif method == 2:
        rx,ry = 600, 300 
        w,h = size()
        cx, cy = w // 2 - rx // 2, h // 2 - ry // 2
        ox, oy = randint(0, rx), randint(0, ry)
        moveTo(cx + ox, cy + oy)

if __name__ == "__main__":
    i = 0
    cnt = args.duration
    print(f'{int(cnt*args.frequency/60)}mins counter')
    while True:
        countdown(args.frequency)
        _action(args.method)

        i = i+1
        if i > cnt:
            exit(0)
            break

        print(f"{'-'*79}\nleft: {int((cnt-i)*args.frequency/60)}m\n{'-'*79}")

def remove_polish_chars(text):
    trans_table = str.maketrans(
        "ąćęłńóśźżĄĆĘŁŃÓŚŹŻ",
        "acelnoszzACELNOSZZ"
    )
    return text.translate(trans_table)

if above does not work, eg in micropython

def remove_polish_chars(text):
    polish_map = {
        'ą': 'a', 'ć': 'c', 'ę': 'e', 'ł': 'l',
        'ń': 'n', 'ó': 'o', 'ś': 's', 'ź': 'z', 'ż': 'z',
        'Ą': 'A', 'Ć': 'C', 'Ę': 'E', 'Ł': 'L',
        'Ń': 'N', 'Ó': 'O', 'Ś': 'S', 'Ź': 'Z', 'Ż': 'Z'
    }
    return ''.join(polish_map.get(c, c) for c in text)

from pathlib import Path

def convert_size(size_bytes):
    """Convert bytes to human readable format."""
    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
        if size_bytes < 1024:
            return f"{size_bytes:.2f} {unit}"
        size_bytes /= 1024
    return f"{size_bytes:.2f} PB"

# Usage
file_path = Path("large_file.zip")
file_size = file_path.stat().st_size
print(convert_size(file_size))  # Output: "1.23 MB"

df.dropna(axis=1, how='all', inplace=True)