oh-my-common 0.1.0__tar.gz

oh_my_common-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: oh-my-common
+Version: 0.1.0
+Summary: Shared runtime for the oh-my-* Flask services: settings DB, Claude CLI gateway, timezone, base-url, scheduler.
+Author-email: Dennis L <dennisl@udel.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/ByteDennis/oh-my-common
+Keywords: oh-my,flask,claude,settings
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: Flask
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: flask
+Requires-Dist: flask>=3.0; extra == "flask"
+Provides-Extra: scheduler
+Requires-Dist: apscheduler>=3.10; extra == "scheduler"
+
+# oh-my-common
+
+Shared runtime for the `oh-my-*` Flask services. Extracted so each split-out
+service (oh-my-rss / oh-my-msg / oh-my-write) shares one implementation instead
+of drifting copies. Per the split design, each service keeps its **own**
+settings DB — this package is the **code** layer, not a shared store.
+
+## Modules
+
+- **`settings`** — SQLite settings client + secret resolution.
+  `get_setting/put_setting/get_all`, the `provider_tokens` cache
+  (`get/set/clear_cached_token`), and `resolve_secret(key, env_key)` with
+  precedence **service-namespace > `global` > env**. Convenience:
+  `resolve_claude_token()`, `resolve_openai_key()`.
+  Config via env: `SETTINGS_DB` (path), `OMI_SERVICE_NS` (this service's
+  namespace, e.g. `clipboard`).
+- **`claude`** — Claude CLI gateway: `resolve_claude_bin`, `claude_text`,
+  `run_claude_capture`, `gate_ai`, `claude_status`, `extract_json`,
+  `estimate_tokens`, `estimate_cost`, `MODEL_PRICING`. Flask-free.
+- **`tz`** — `local_tz()/now_local()/today_local()` from `OMI_TZ_OFFSET` (hours, default +8).
+- **`urls`** — `request_base_url()` (honors `X-Forwarded-Proto/Host`). Imports flask lazily.
+- **`scheduler`** — `make_scheduler(ENABLED_ENV)` → a guarded `BackgroundScheduler`
+  (returns `None` when `ENABLED_ENV=0`, so extra gunicorn workers don't double-run).
+  Imports apscheduler lazily.
+
+## Usage
+
+```python
+import os
+os.environ.setdefault('OMI_SERVICE_NS', 'clipboard')
+from oh_my_common import get_setting, claude_text, resolve_openai_key, now_local
+
+key, src = resolve_openai_key()
+text = claude_text('Summarize: ...', model='sonnet')
+```
+
+## Install
+
+```
+pip install oh-my-common            # core (stdlib only)
+pip install 'oh-my-common[flask,scheduler]'   # + request_base_url + make_scheduler
+```
+
+Distribution into Docker services is TBD — see the migration plan. Options:
+publish to a registry, vendor into each monorepo, or a git dependency.

oh_my_common-0.1.0/README.md

@@ -0,0 +1,45 @@
+# oh-my-common
+
+Shared runtime for the `oh-my-*` Flask services. Extracted so each split-out
+service (oh-my-rss / oh-my-msg / oh-my-write) shares one implementation instead
+of drifting copies. Per the split design, each service keeps its **own**
+settings DB — this package is the **code** layer, not a shared store.
+
+## Modules
+
+- **`settings`** — SQLite settings client + secret resolution.
+  `get_setting/put_setting/get_all`, the `provider_tokens` cache
+  (`get/set/clear_cached_token`), and `resolve_secret(key, env_key)` with
+  precedence **service-namespace > `global` > env**. Convenience:
+  `resolve_claude_token()`, `resolve_openai_key()`.
+  Config via env: `SETTINGS_DB` (path), `OMI_SERVICE_NS` (this service's
+  namespace, e.g. `clipboard`).
+- **`claude`** — Claude CLI gateway: `resolve_claude_bin`, `claude_text`,
+  `run_claude_capture`, `gate_ai`, `claude_status`, `extract_json`,
+  `estimate_tokens`, `estimate_cost`, `MODEL_PRICING`. Flask-free.
+- **`tz`** — `local_tz()/now_local()/today_local()` from `OMI_TZ_OFFSET` (hours, default +8).
+- **`urls`** — `request_base_url()` (honors `X-Forwarded-Proto/Host`). Imports flask lazily.
+- **`scheduler`** — `make_scheduler(ENABLED_ENV)` → a guarded `BackgroundScheduler`
+  (returns `None` when `ENABLED_ENV=0`, so extra gunicorn workers don't double-run).
+  Imports apscheduler lazily.
+
+## Usage
+
+```python
+import os
+os.environ.setdefault('OMI_SERVICE_NS', 'clipboard')
+from oh_my_common import get_setting, claude_text, resolve_openai_key, now_local
+
+key, src = resolve_openai_key()
+text = claude_text('Summarize: ...', model='sonnet')
+```
+
+## Install
+
+```
+pip install oh-my-common            # core (stdlib only)
+pip install 'oh-my-common[flask,scheduler]'   # + request_base_url + make_scheduler
+```
+
+Distribution into Docker services is TBD — see the migration plan. Options:
+publish to a registry, vendor into each monorepo, or a git dependency.

oh_my_common-0.1.0/oh_my_common/__init__.py

@@ -0,0 +1,28 @@
+from .settings import (
+    SETTINGS_DB, SERVICE_NS,
+    init_settings_db, seed_global_settings_from_env,
+    get_setting, put_setting, get_all,
+    init_token_cache, get_cached_token, set_cached_token, clear_cached_token,
+    resolve_secret, resolve_claude_token, resolve_openai_key,
+)
+from .claude import (
+    MODEL_PRICING, resolve_claude_bin, claude_env, claude_status, gate_ai,
+    run_claude_capture, claude_text, extract_json, estimate_tokens, estimate_cost,
+)
+from .tz import local_tz, now_local, today_local
+from .urls import request_base_url
+from .scheduler import make_scheduler
+
+__version__ = '0.1.0'
+
+__all__ = [
+    'SETTINGS_DB', 'SERVICE_NS',
+    'init_settings_db', 'seed_global_settings_from_env',
+    'get_setting', 'put_setting', 'get_all',
+    'init_token_cache', 'get_cached_token', 'set_cached_token', 'clear_cached_token',
+    'resolve_secret', 'resolve_claude_token', 'resolve_openai_key',
+    'MODEL_PRICING', 'resolve_claude_bin', 'claude_env', 'claude_status', 'gate_ai',
+    'run_claude_capture', 'claude_text', 'extract_json', 'estimate_tokens', 'estimate_cost',
+    'local_tz', 'now_local', 'today_local',
+    'request_base_url', 'make_scheduler',
+]

oh_my_common-0.1.0/oh_my_common/claude.py

@@ -0,0 +1,102 @@
+import glob
+import json
+import os
+import shutil
+import subprocess
+
+from .settings import resolve_claude_token
+
+MODEL_PRICING = {
+    'haiku': (1.0, 5.0),
+    'sonnet': (3.0, 15.0),
+    'opus': (15.0, 75.0),
+}
+
+
+# >>> locate the claude binary: $CLAUDE_BIN > PATH > newest /opt/claude/versions/* <<< #
+def resolve_claude_bin() -> str:
+    if os.environ.get('CLAUDE_BIN'):
+        return os.environ['CLAUDE_BIN']
+    on_path = shutil.which('claude')
+    if on_path:
+        return on_path
+    cands = sorted(glob.glob('/opt/claude/versions/*'), key=os.path.getmtime)
+    return cands[-1] if cands else ''
+
+
+# >>> subprocess env carrying the OAuth token <<< #
+def claude_env(token: str) -> dict:
+    env = os.environ.copy()
+    env['HOME'] = '/root'
+    env['CLAUDE_CODE_OAUTH_TOKEN'] = token
+    return env
+
+
+# >>> readiness of the Claude gateway: {configured, has_token, has_binary} <<< #
+def claude_status(service_ns: str = None) -> dict:
+    token, _src = resolve_claude_token(service_ns)
+    claude_bin = resolve_claude_bin()
+    return {'configured': bool(token and claude_bin),
+            'has_token': bool(token), 'has_binary': bool(claude_bin)}
+
+
+# >>> (token, claude_bin) if ready else (None, None) <<< #
+def gate_ai(service_ns: str = None):
+    token, _src = resolve_claude_token(service_ns)
+    claude_bin = resolve_claude_bin()
+    if not token or not claude_bin:
+        return None, None
+    return token, claude_bin
+
+
+# >>> run `claude -p` once, return full stdout (blocking); raises on non-zero <<< #
+def run_claude_capture(claude_bin, token, model, prompt, timeout=180):
+    proc = subprocess.run(
+        [claude_bin, '-p', '--model', model],
+        input=prompt, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        text=True, env=claude_env(token), timeout=timeout,
+    )
+    if proc.returncode != 0:
+        raise RuntimeError(proc.stderr.strip() or 'claude exited non-zero')
+    return proc.stdout
+
+
+# >>> one-shot Claude call; resolves the token if not supplied <<< #
+def claude_text(prompt, model='sonnet', service_ns: str = None, timeout=180):
+    token, claude_bin = gate_ai(service_ns)
+    if not token or not claude_bin:
+        raise RuntimeError('Claude not configured')
+    return run_claude_capture(claude_bin, token, model, prompt, timeout).strip()
+
+
+# >>> pull the first balanced JSON object out of a model reply (tolerates fences/prose) <<< #
+def extract_json(s):
+    s = s.strip()
+    if s.startswith('```'):
+        s = s.split('\n', 1)[-1]
+        if s.endswith('```'):
+            s = s[:-3]
+    start = s.find('{')
+    if start == -1:
+        raise ValueError('no JSON object in reply')
+    depth = 0
+    for i in range(start, len(s)):
+        c = s[i]
+        if c == '{':
+            depth += 1
+        elif c == '}':
+            depth -= 1
+            if depth == 0:
+                return json.loads(s[start:i + 1])
+    raise ValueError('unbalanced JSON in reply')
+
+
+# >>> rough token estimate (~4 chars/token) for cost accounting <<< #
+def estimate_tokens(text) -> int:
+    return max(1, len(text or '') // 4)
+
+
+# >>> USD cost of a call given char/token counts and model pricing <<< #
+def estimate_cost(tok_in, tok_out, model='sonnet') -> float:
+    pin, pout = MODEL_PRICING.get(model, (3.0, 15.0))
+    return tok_in / 1e6 * pin + tok_out / 1e6 * pout

oh_my_common-0.1.0/oh_my_common/scheduler.py

@@ -0,0 +1,11 @@
+import os
+
+
+# >>> BackgroundScheduler guarded by an env flag (set <FLAG>=0 on extra gunicorn workers to avoid duplicate runs); returns None when disabled <<< #
+def make_scheduler(enabled_env: str, timezone_=None):
+    if os.environ.get(enabled_env, '1') == '0':
+        return None
+    from apscheduler.schedulers.background import BackgroundScheduler
+    from .tz import local_tz
+    sched = BackgroundScheduler(timezone=timezone_ or local_tz())
+    return sched

oh_my_common-0.1.0/oh_my_common/settings.py

@@ -0,0 +1,168 @@
+import os
+import sqlite3
+
+SETTINGS_DB = os.environ.get('SETTINGS_DB', '/data/oh-my-clipboard.db')
+SERVICE_NS = os.environ.get('OMI_SERVICE_NS', 'app')
+
+ENV_MAP = {
+    'claude_code_oauth_token': 'CLAUDE_CODE_OAUTH_TOKEN',
+    'openai_api_key': 'OPENAI_API_KEY',
+}
+
+
+# >>> sqlite connection to the settings DB <<< #
+def _conn():
+    conn = sqlite3.connect(SETTINGS_DB)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+# >>> create the settings table if missing <<< #
+def init_settings_db():
+    os.makedirs(os.path.dirname(SETTINGS_DB), exist_ok=True)
+    conn = sqlite3.connect(SETTINGS_DB)
+    conn.execute('CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT)')
+    conn.commit()
+    conn.close()
+
+
+# >>> seed global.* settings from env on first boot (only when unset) <<< #
+def seed_global_settings_from_env():
+    init_settings_db()
+    conn = _conn()
+    for key, env_key in ENV_MAP.items():
+        val = os.environ.get(env_key, '')
+        if not val:
+            continue
+        existing = conn.execute(
+            'SELECT value FROM settings WHERE key = ?', (f'global.{key}',)
+        ).fetchone()
+        if not existing or not existing['value']:
+            conn.execute(
+                'INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)',
+                (f'global.{key}', val),
+            )
+    conn.commit()
+    conn.close()
+
+
+# >>> read one namespaced setting, falling back to default <<< #
+def get_setting(namespace: str, key: str, default: str = '') -> str:
+    try:
+        conn = _conn()
+        row = conn.execute(
+            'SELECT value FROM settings WHERE key = ?', (f'{namespace}.{key}',)
+        ).fetchone()
+        conn.close()
+        if row and row['value']:
+            return row['value']
+    except Exception:
+        pass
+    return default
+
+
+# >>> write one namespaced setting <<< #
+def put_setting(namespace: str, key: str, value: str):
+    init_settings_db()
+    conn = _conn()
+    conn.execute(
+        'INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)',
+        (f'{namespace}.{key}', value or ''),
+    )
+    conn.commit()
+    conn.close()
+
+
+# >>> all settings under a namespace as a {key: value} dict <<< #
+def get_all(namespace: str) -> dict:
+    prefix = namespace + '.'
+    try:
+        conn = _conn()
+        rows = conn.execute(
+            'SELECT key, value FROM settings WHERE key LIKE ?', (prefix + '%',)
+        ).fetchall()
+        conn.close()
+        return {r['key'][len(prefix):]: r['value'] for r in rows}
+    except Exception:
+        return {}
+
+
+# >>> create the short-lived provider-token cache table <<< #
+def init_token_cache():
+    os.makedirs(os.path.dirname(SETTINGS_DB), exist_ok=True)
+    conn = sqlite3.connect(SETTINGS_DB)
+    conn.execute(
+        'CREATE TABLE IF NOT EXISTS provider_tokens ('
+        ' provider TEXT PRIMARY KEY, access_token TEXT NOT NULL,'
+        ' expires_at TEXT NOT NULL, meta_json TEXT)'
+    )
+    conn.commit()
+    conn.close()
+
+
+# >>> cached bearer token for a provider, or None <<< #
+def get_cached_token(provider: str):
+    try:
+        init_token_cache()
+        conn = _conn()
+        row = conn.execute(
+            'SELECT access_token, expires_at, meta_json FROM provider_tokens WHERE provider = ?',
+            (provider,),
+        ).fetchone()
+        conn.close()
+        if row:
+            return {'access_token': row['access_token'], 'expires_at': row['expires_at'],
+                    'meta': row['meta_json'] or ''}
+    except Exception:
+        pass
+    return None
+
+
+# >>> store a provider bearer token <<< #
+def set_cached_token(provider: str, access_token: str, expires_at: str, meta: str = ''):
+    init_token_cache()
+    conn = _conn()
+    conn.execute(
+        'INSERT OR REPLACE INTO provider_tokens (provider, access_token, expires_at, meta_json)'
+        ' VALUES (?, ?, ?, ?)',
+        (provider, access_token, expires_at, meta or ''),
+    )
+    conn.commit()
+    conn.close()
+
+
+# >>> drop a provider's cached token <<< #
+def clear_cached_token(provider: str):
+    try:
+        init_token_cache()
+        conn = _conn()
+        conn.execute('DELETE FROM provider_tokens WHERE provider = ?', (provider,))
+        conn.commit()
+        conn.close()
+    except Exception:
+        pass
+
+
+# >>> resolve a secret: service namespace > global > env > '' ; returns (value, source) <<< #
+def resolve_secret(key: str, env_key: str, service_ns: str = None) -> tuple[str, str]:
+    ns = service_ns or SERVICE_NS
+    val = get_setting(ns, key)
+    if val:
+        return val, 'user'
+    val = get_setting('global', key)
+    if val:
+        return val, 'global'
+    val = os.environ.get(env_key, '')
+    if val:
+        return val, 'env'
+    return '', ''
+
+
+# >>> (token, source) for the Claude OAuth token <<< #
+def resolve_claude_token(service_ns: str = None) -> tuple[str, str]:
+    return resolve_secret('claude_code_oauth_token', 'CLAUDE_CODE_OAUTH_TOKEN', service_ns)
+
+
+# >>> (key, source) for the OpenAI API key <<< #
+def resolve_openai_key(service_ns: str = None) -> tuple[str, str]:
+    return resolve_secret('openai_api_key', 'OPENAI_API_KEY', service_ns)

oh_my_common-0.1.0/oh_my_common/tz.py

@@ -0,0 +1,21 @@
+import os
+from datetime import datetime, timedelta, timezone
+
+
+# >>> fixed-offset tz from OMI_TZ_OFFSET (hours, default +8) for day boundaries / schedulers <<< #
+def local_tz() -> timezone:
+    try:
+        hours = int(os.environ.get('OMI_TZ_OFFSET', '8'))
+    except (ValueError, TypeError):
+        hours = 8
+    return timezone(timedelta(hours=hours))
+
+
+# >>> current local datetime <<< #
+def now_local() -> datetime:
+    return datetime.now(local_tz())
+
+
+# >>> current local date <<< #
+def today_local():
+    return now_local().date()

oh_my_common-0.1.0/oh_my_common/urls.py

@@ -0,0 +1,6 @@
+# >>> base URL from the incoming request, honoring X-Forwarded-Proto/Host (for feed/media links) <<< #
+def request_base_url() -> str:
+    from flask import request
+    scheme = request.headers.get('X-Forwarded-Proto', request.scheme)
+    host = request.headers.get('X-Forwarded-Host', request.host)
+    return f'{scheme}://{host}'

oh_my_common-0.1.0/oh_my_common.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: oh-my-common
+Version: 0.1.0
+Summary: Shared runtime for the oh-my-* Flask services: settings DB, Claude CLI gateway, timezone, base-url, scheduler.
+Author-email: Dennis L <dennisl@udel.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/ByteDennis/oh-my-common
+Keywords: oh-my,flask,claude,settings
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: Flask
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: flask
+Requires-Dist: flask>=3.0; extra == "flask"
+Provides-Extra: scheduler
+Requires-Dist: apscheduler>=3.10; extra == "scheduler"
+
+# oh-my-common
+
+Shared runtime for the `oh-my-*` Flask services. Extracted so each split-out
+service (oh-my-rss / oh-my-msg / oh-my-write) shares one implementation instead
+of drifting copies. Per the split design, each service keeps its **own**
+settings DB — this package is the **code** layer, not a shared store.
+
+## Modules
+
+- **`settings`** — SQLite settings client + secret resolution.
+  `get_setting/put_setting/get_all`, the `provider_tokens` cache
+  (`get/set/clear_cached_token`), and `resolve_secret(key, env_key)` with
+  precedence **service-namespace > `global` > env**. Convenience:
+  `resolve_claude_token()`, `resolve_openai_key()`.
+  Config via env: `SETTINGS_DB` (path), `OMI_SERVICE_NS` (this service's
+  namespace, e.g. `clipboard`).
+- **`claude`** — Claude CLI gateway: `resolve_claude_bin`, `claude_text`,
+  `run_claude_capture`, `gate_ai`, `claude_status`, `extract_json`,
+  `estimate_tokens`, `estimate_cost`, `MODEL_PRICING`. Flask-free.
+- **`tz`** — `local_tz()/now_local()/today_local()` from `OMI_TZ_OFFSET` (hours, default +8).
+- **`urls`** — `request_base_url()` (honors `X-Forwarded-Proto/Host`). Imports flask lazily.
+- **`scheduler`** — `make_scheduler(ENABLED_ENV)` → a guarded `BackgroundScheduler`
+  (returns `None` when `ENABLED_ENV=0`, so extra gunicorn workers don't double-run).
+  Imports apscheduler lazily.
+
+## Usage
+
+```python
+import os
+os.environ.setdefault('OMI_SERVICE_NS', 'clipboard')
+from oh_my_common import get_setting, claude_text, resolve_openai_key, now_local
+
+key, src = resolve_openai_key()
+text = claude_text('Summarize: ...', model='sonnet')
+```
+
+## Install
+
+```
+pip install oh-my-common            # core (stdlib only)
+pip install 'oh-my-common[flask,scheduler]'   # + request_base_url + make_scheduler
+```
+
+Distribution into Docker services is TBD — see the migration plan. Options:
+publish to a registry, vendor into each monorepo, or a git dependency.

oh_my_common-0.1.0/oh_my_common.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+oh_my_common/__init__.py
+oh_my_common/claude.py
+oh_my_common/scheduler.py
+oh_my_common/settings.py
+oh_my_common/tz.py
+oh_my_common/urls.py
+oh_my_common.egg-info/PKG-INFO
+oh_my_common.egg-info/SOURCES.txt
+oh_my_common.egg-info/dependency_links.txt
+oh_my_common.egg-info/requires.txt
+oh_my_common.egg-info/top_level.txt

oh_my_common-0.1.0/oh_my_common.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

oh_my_common-0.1.0/oh_my_common.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[flask]
+flask>=3.0
+
+[scheduler]
+apscheduler>=3.10

oh_my_common-0.1.0/oh_my_common.egg-info/top_level.txt

@@ -0,0 +1 @@
+oh_my_common

oh_my_common-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oh-my-common"
+version = "0.1.0"
+description = "Shared runtime for the oh-my-* Flask services: settings DB, Claude CLI gateway, timezone, base-url, scheduler."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Dennis L", email = "dennisl@udel.edu" }]
+keywords = ["oh-my", "flask", "claude", "settings"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Framework :: Flask",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/ByteDennis/oh-my-common"
+
+[project.optional-dependencies]
+flask = ["flask>=3.0"]
+scheduler = ["apscheduler>=3.10"]
+
+[tool.setuptools]
+packages = ["oh_my_common"]

oh_my_common-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+