## sqlite3 [25-03-17]
```py
import sqlite3, os, json
class SQL:
    def __init__(sql, db='.db'):
        if not os.path.exists(db): os.makedirs(db); SQL(db).con.executescript(
            "PRAGMA journal_mode=WAL; CREATE TABLE kv(k,v,t DEFAULT CURRENT_TIMESTAMP);"
            "CREATE INDEX idx_kv_v ON kv(v); CREATE INDEX idx_kv_k_t ON kv(k,t DESC);")
        (con := sqlite3.connect(f'{db}/sql', check_same_thread=False,
            isolation_level=None)).execute(f"PRAGMA busy_timeout={1e9}")
        sql.con, sql.db = con, db
    def __call__(sql, q, *p): return [*sql.con.execute(q, p)]
    def __setitem__(sql, k, v): return sql("INSERT INTO kv(k,v) VALUES(?,?)",
        k, v if type(v) is bytes else json.dumps(v, ensure_ascii=False))
    def __getitem__(sql, k):
        if (v := sql("SELECT v FROM kv WHERE k=? ORDER BY t DESC LIMIT 1", k)):
            return json.loads(v) if type(v := v[0][0]) is str else v
    def __delitem__(sql, rows):
        for row in rows: sql("DELETE FROM kv WHERE k=? AND v=? AND t=?", *row)
    def __contains__(sql, k): return bool(sql("SELECT 1 FROM kv WHERE k=?", k))
    def __eq__(sql, query): return sql("SELECT * FROM kv WHERE k LIKE ?", query)
    def __ne__(sql, query): return sql("SELECT * FROM kv WHERE k NOT LIKE ?", query)
    def __repr__(sql): return f"SQL(db={sql.db})"
sql = SQL()
```

## tauri + svelte + shadcn
```sh
git clone https://github.com/alysonhower/tauri2-svelte5-shadcn.git
cd tauri2-svelte5-shadcn
bun i
bun run dev -- --host
```

## syncify
```py
def sync(coro):
    import asyncio, functools, nest_asyncio; nest_asyncio.apply()
    return functools.wraps(coro)(lambda *args, **kwargs:
        asyncio.run(coro(*args, **kwargs)))

@sync
async def main(): print('hello'); return 'world'

main()
```

## playwright [25-03-01]
```python
def Page():
    def sync(obj):
        import asyncio, functools
        if asyncio.iscoroutine(coro := obj):
            loop, future = asyncio.get_event_loop(), asyncio.ensure_future(coro)
            while not future.done():
                loop._process_events(loop._selector.select(0))
                if (ready := loop._ready) and not (handle := ready.popleft())._cancelled:
                    task = (tasks := asyncio.tasks._current_tasks).pop(loop, None)
                    handle._run()
                    tasks[loop] = task
            return future.result()
        if asyncio.iscoroutinefunction(func := obj): return functools.wraps(func)(
            lambda *args, **kwargs: sync(func(*args, **kwargs)))
        for attr in dir(obj):
            if asyncio.iscoroutinefunction(method := getattr(obj, attr)):
                setattr(obj, attr, sync(method))
        return obj

    from playwright.async_api import async_playwright
    browser = sync(sync(async_playwright().start()).firefox.launch())
    page = sync(sync(browser.new_page()))
    page._repr_png_ = page.screenshot
    return page

page = Page()
page.goto('https://naver.com')
page
```

# wireguard
```powershell
wg genkey|%{$_;$_|wg pubkey}
```