bc7ac32de3
- Campaigns: new table, CRUD API, React context + provider
- Sessions: scoped to campaigns, paths under campaigns/{id}/
- File browser: scoped per campaign, removed copy/paste/autoPlay
- Sidebar: campaign selector dropdown at top
- Transcribe: GPU model cached/released via job counter
- Jobs: status text updates dynamically in real-time
- Auto-redirect: blocked when summarize job is active
207 lines
7.2 KiB
Python
207 lines
7.2 KiB
Python
import json
|
|
import sqlite3
|
|
import threading
|
|
import time
|
|
import uuid
|
|
from contextlib import contextmanager
|
|
|
|
from . import config
|
|
|
|
_local = threading.local()
|
|
|
|
|
|
def get_conn():
|
|
if not hasattr(_local, "conn"):
|
|
_local.conn = sqlite3.connect(config.DB_PATH, check_same_thread=False)
|
|
_local.conn.row_factory = sqlite3.Row
|
|
_local.conn.execute("PRAGMA foreign_keys = ON")
|
|
return _local.conn
|
|
|
|
|
|
@contextmanager
|
|
def tx():
|
|
conn = get_conn()
|
|
try:
|
|
yield conn
|
|
conn.commit()
|
|
except Exception:
|
|
conn.rollback()
|
|
raise
|
|
|
|
|
|
def init_db():
|
|
with tx() as conn:
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS settings (
|
|
key TEXT PRIMARY KEY,
|
|
value TEXT NOT NULL
|
|
)
|
|
""")
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS sessions (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
original_filename TEXT NOT NULL,
|
|
video_path TEXT,
|
|
audio_path TEXT,
|
|
transcript_path TEXT,
|
|
status TEXT NOT NULL DEFAULT 'uploaded',
|
|
created_at REAL NOT NULL
|
|
)
|
|
""")
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS speakers (
|
|
id TEXT PRIMARY KEY,
|
|
session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
|
raw_label TEXT NOT NULL,
|
|
display_name TEXT,
|
|
UNIQUE(session_id, raw_label)
|
|
)
|
|
""")
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS notes (
|
|
session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
|
|
dm_notes TEXT,
|
|
player_recap TEXT,
|
|
player_recap_prompt TEXT,
|
|
generated_at REAL
|
|
)
|
|
""")
|
|
# migrate older databases that lack the prompt column
|
|
try:
|
|
conn.execute("ALTER TABLE notes ADD COLUMN player_recap_prompt TEXT")
|
|
except Exception:
|
|
pass
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS jobs (
|
|
id TEXT PRIMARY KEY,
|
|
session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
|
job_type TEXT NOT NULL, -- 'transcribe' | 'summarize'
|
|
status TEXT NOT NULL DEFAULT 'queued', -- queued|running|done|error
|
|
progress TEXT, -- free-text progress message
|
|
error TEXT,
|
|
error_stage TEXT, -- which pipeline stage failed, e.g. 'transcription'
|
|
error_detail TEXT, -- full traceback, for logs/advanced view only
|
|
created_at REAL NOT NULL,
|
|
updated_at REAL NOT NULL
|
|
)
|
|
""")
|
|
conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS campaigns (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
description TEXT NOT NULL DEFAULT '',
|
|
created_at REAL NOT NULL
|
|
)
|
|
""")
|
|
try:
|
|
conn.execute("ALTER TABLE sessions ADD COLUMN campaign_id TEXT REFERENCES campaigns(id) ON DELETE SET NULL")
|
|
except Exception:
|
|
pass
|
|
default = conn.execute("SELECT id FROM campaigns WHERE id = 'default'").fetchone()
|
|
if not default:
|
|
conn.execute(
|
|
"INSERT INTO campaigns (id, name, description, created_at) VALUES (?, ?, '', ?)",
|
|
("default", "Default Campaign", now()),
|
|
)
|
|
conn.execute("UPDATE sessions SET campaign_id = 'default' WHERE campaign_id IS NULL")
|
|
|
|
# seed defaults if empty
|
|
existing = {r["key"] for r in conn.execute("SELECT key FROM settings")}
|
|
for k, v in config.DEFAULT_SETTINGS.items():
|
|
if k not in existing:
|
|
conn.execute("INSERT INTO settings (key, value) VALUES (?, ?)", (k, v))
|
|
|
|
|
|
def get_settings() -> dict:
|
|
conn = get_conn()
|
|
rows = conn.execute("SELECT key, value FROM settings").fetchall()
|
|
return {r["key"]: r["value"] for r in rows}
|
|
|
|
|
|
def update_settings(patch: dict):
|
|
with tx() as conn:
|
|
for k, v in patch.items():
|
|
conn.execute(
|
|
"INSERT INTO settings (key, value) VALUES (?, ?) "
|
|
"ON CONFLICT(key) DO UPDATE SET value=excluded.value",
|
|
(k, str(v)),
|
|
)
|
|
|
|
|
|
def new_id() -> str:
|
|
return uuid.uuid4().hex[:12]
|
|
|
|
|
|
def now() -> float:
|
|
return time.time()
|
|
|
|
|
|
def create_job(session_id: str, job_type: str) -> str:
|
|
job_id = new_id()
|
|
with tx() as conn:
|
|
conn.execute(
|
|
"INSERT INTO jobs (id, session_id, job_type, status, created_at, updated_at) "
|
|
"VALUES (?, ?, ?, 'queued', ?, ?)",
|
|
(job_id, session_id, job_type, now(), now()),
|
|
)
|
|
return job_id
|
|
|
|
|
|
def update_job(job_id: str, **fields):
|
|
if not fields:
|
|
return
|
|
fields["updated_at"] = now()
|
|
cols = ", ".join(f"{k} = ?" for k in fields)
|
|
with tx() as conn:
|
|
conn.execute(f"UPDATE jobs SET {cols} WHERE id = ?", (*fields.values(), job_id))
|
|
|
|
|
|
def get_job(job_id: str) -> dict | None:
|
|
row = get_conn().execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
|
|
return dict(row) if row else None
|
|
|
|
def create_campaign(name: str, description: str = "") -> dict:
|
|
campaign_id = new_id()
|
|
with tx() as conn:
|
|
conn.execute(
|
|
"INSERT INTO campaigns (id, name, description, created_at) VALUES (?, ?, ?, ?)",
|
|
(campaign_id, name, description, now()),
|
|
)
|
|
from .config import campaign_audio_dir, campaign_transcript_dir, campaign_notes_dir
|
|
campaign_audio_dir(campaign_id).mkdir(parents=True, exist_ok=True)
|
|
campaign_transcript_dir(campaign_id).mkdir(parents=True, exist_ok=True)
|
|
campaign_notes_dir(campaign_id).mkdir(parents=True, exist_ok=True)
|
|
return get_campaign(campaign_id)
|
|
|
|
def list_campaigns() -> list[dict]:
|
|
rows = get_conn().execute(
|
|
"SELECT c.*, (SELECT COUNT(*) FROM sessions s WHERE s.campaign_id = c.id) as session_count "
|
|
"FROM campaigns c ORDER BY c.created_at DESC"
|
|
).fetchall()
|
|
return [dict(r) for r in rows]
|
|
|
|
def get_campaign(campaign_id: str) -> dict | None:
|
|
row = get_conn().execute(
|
|
"SELECT c.*, (SELECT COUNT(*) FROM sessions s WHERE s.campaign_id = c.id) as session_count "
|
|
"FROM campaigns c WHERE c.id = ?", (campaign_id,)
|
|
).fetchone()
|
|
return dict(row) if row else None
|
|
|
|
def update_campaign(campaign_id: str, name: str | None = None, description: str | None = None) -> dict | None:
|
|
fields = {}
|
|
if name is not None: fields["name"] = name
|
|
if description is not None: fields["description"] = description
|
|
if not fields:
|
|
return get_campaign(campaign_id)
|
|
with tx() as conn:
|
|
cols = ", ".join(f"{k} = ?" for k in fields)
|
|
conn.execute(f"UPDATE campaigns SET {cols} WHERE id = ?", (*fields.values(), campaign_id))
|
|
return get_campaign(campaign_id)
|
|
|
|
def delete_campaign(campaign_id: str) -> bool:
|
|
with tx() as conn:
|
|
conn.execute("UPDATE sessions SET campaign_id = NULL WHERE campaign_id = ?", (campaign_id,))
|
|
conn.execute("DELETE FROM campaigns WHERE id = ?", (campaign_id,))
|
|
return True
|