reel-sync 1.0.0__tar.gz

reel_sync-1.0.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: reel-sync
+Version: 1.0.0
+Summary: Fully-local sync tool for the Sony ICD-UX570 voice recorder
+Author: Nicolas
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/reel-sync/
+Keywords: sony,icd-ux570,voice-recorder,sync,dictaphone
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.0
+Requires-Dist: mutagen>=1.47
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+
+# REEL
+
+**A fully-local, automatic sync tool for the Sony ICD-UX570.** Plug in the recorder, and Reel pulls every new recording onto your PC, names it by the moment you hit record, and files it into the right category — Interviews, Songs, Memes, Podcasts, Voice Notes. Re-plug the same stick and nothing copies twice. A clean terminal, a progress bar, done.
+
+> Everything stays on your machine. The recorder is never wiped. The library is just folders — open it in Explorer any time.
+
+---
+
+## What it does
+
+- **Detects the recorder** the moment it mounts (by volume label *or* by spotting its `REC_FILE` folder — works even if the label changes).
+- **Copies only what's new.** Each file is fingerprinted; already-synced recordings are skipped.
+- **Names everything cleanly** — `2026-06-08_1432_reel-7F3A.mp3` (date-first, sorts forever).
+- **Auto-categorises** using simple, tunable rules:
+  - device `MUSIC` folder → **Songs**, `PODCASTS` → **Podcasts**
+  - a filename keyword (`interview`, `meme`, …) wins if present
+  - otherwise by length: very short → **Memes**, very long → **Interviews**, else **Voice Notes**
+- **Mirrors** to any extra drives you list (USB / cloud), so sync doubles as backup.
+- **Runs automatically** in watch mode — leave it running and every plug-in just syncs.
+
+Files land here:
+```
+Reel/
+├── Interviews/2026/2026-06-08_1432_reel-7F3A.mp3
+├── Songs/2026/2026-05-30_2011_reel-A1C9.mp3
+├── Memes/2026/…
+└── .reel/manifest.json      ← dedup index (so nothing copies twice)
+```
+
+---
+
+## Install
+
+Once it's published, anyone can install it from PyPI:
+```
+pip install reel-sync
+```
+(The package is `reel-sync`; the command you run is just `reel`.)
+
+### From this folder (for development)
+
+1. **Install Python 3.11+** (python.org → tick *Add Python to PATH*).
+2. **Install Reel as a command** — open a terminal in this folder once:
+   ```
+   pip install -e .
+   ```
+   That puts a `reel` command on your PATH, so you can run it from **any** folder
+   (including `C:\Users\YOU>`), not just this one.
+3. **Set your path** in `config.toml`:
+   ```toml
+   [library]
+   sync_root = "C:/Users/YOURNAME/Reel"
+   ```
+   Point `sync_root` at a cloud-synced folder (pCloud / OneDrive / Dropbox) and your off-site backup is automatic.
+
+Reel finds this `config.toml` automatically wherever you run it from (it also
+checks `./config.toml` and `~/.reel/config.toml` first). No config at all? It
+falls back to sensible defaults (`~/Reel`).
+
+---
+
+## Use it
+
+You really only need two commands. Run them from anywhere — your home prompt is fine.
+
+**First time** — run this, then plug in the recorder when it asks:
+```
+reel setup
+```
+A short welcome, then it waits for your ICD-UX570, does the big initial copy, and
+**stays running as auto-sync** from there. (Run `reel setup` again later and it
+just says *"Already set up :)"*.)
+
+**Every day after** — start auto-sync and leave it running:
+```
+reel start
+```
+It does the initial sync, then keeps syncing automatically whenever you **drop a
+file onto the recorder from your PC** — and it **stops by itself the moment you
+unplug** the recorder. (Press **Ctrl + C** to stop sooner.)
+
+That's the whole flow. The rest is optional:
+
+```
+reel sync              # a single one-off sync, then exit (rarely needed)
+reel sort <path>       # auto-filter a folder/files you drop in (or use the .bat)
+reel status            # what's in your library, per category
+reel devices           # is the recorder detected right now?
+reel open              # open the Reel library in Explorer
+reel reset             # clear first-time setup (to see the welcome again)
+reel --theme dark start# dark terminal theme
+```
+
+(`python -m reel start` and `python run.py start` work identically.)
+
+### Make it truly hands-off (optional)
+Put a shortcut to `reel start` in your Startup folder (`Win+R` → `shell:startup`).
+Reel will be running and watching from the moment you log in.
+
+---
+
+## Branding
+
+Light by default — colours tuned for a white terminal. Want dark? `theme = "dark"` in `config.toml`, or `--theme dark` on any command. Identity lives in `reel/branding.py`.
+
+## Notes
+
+- **Privacy:** nothing leaves your machine except the copies you put in your own mirror/cloud folders.
+- **Safety:** `delete_after_sync = false` by default — Reel copies off the recorder and never deletes from it.
+- **Coming later:** built-in playback, a podcast queue, smarter song-vs-voice detection. See `ROADMAP.md`.
+
+---
+
+*REEL v1.0.0 — plug in, walk away.*

reel_sync-1.0.0/README.md

@@ -0,0 +1,114 @@
+# REEL
+
+**A fully-local, automatic sync tool for the Sony ICD-UX570.** Plug in the recorder, and Reel pulls every new recording onto your PC, names it by the moment you hit record, and files it into the right category — Interviews, Songs, Memes, Podcasts, Voice Notes. Re-plug the same stick and nothing copies twice. A clean terminal, a progress bar, done.
+
+> Everything stays on your machine. The recorder is never wiped. The library is just folders — open it in Explorer any time.
+
+---
+
+## What it does
+
+- **Detects the recorder** the moment it mounts (by volume label *or* by spotting its `REC_FILE` folder — works even if the label changes).
+- **Copies only what's new.** Each file is fingerprinted; already-synced recordings are skipped.
+- **Names everything cleanly** — `2026-06-08_1432_reel-7F3A.mp3` (date-first, sorts forever).
+- **Auto-categorises** using simple, tunable rules:
+  - device `MUSIC` folder → **Songs**, `PODCASTS` → **Podcasts**
+  - a filename keyword (`interview`, `meme`, …) wins if present
+  - otherwise by length: very short → **Memes**, very long → **Interviews**, else **Voice Notes**
+- **Mirrors** to any extra drives you list (USB / cloud), so sync doubles as backup.
+- **Runs automatically** in watch mode — leave it running and every plug-in just syncs.
+
+Files land here:
+```
+Reel/
+├── Interviews/2026/2026-06-08_1432_reel-7F3A.mp3
+├── Songs/2026/2026-05-30_2011_reel-A1C9.mp3
+├── Memes/2026/…
+└── .reel/manifest.json      ← dedup index (so nothing copies twice)
+```
+
+---
+
+## Install
+
+Once it's published, anyone can install it from PyPI:
+```
+pip install reel-sync
+```
+(The package is `reel-sync`; the command you run is just `reel`.)
+
+### From this folder (for development)
+
+1. **Install Python 3.11+** (python.org → tick *Add Python to PATH*).
+2. **Install Reel as a command** — open a terminal in this folder once:
+   ```
+   pip install -e .
+   ```
+   That puts a `reel` command on your PATH, so you can run it from **any** folder
+   (including `C:\Users\YOU>`), not just this one.
+3. **Set your path** in `config.toml`:
+   ```toml
+   [library]
+   sync_root = "C:/Users/YOURNAME/Reel"
+   ```
+   Point `sync_root` at a cloud-synced folder (pCloud / OneDrive / Dropbox) and your off-site backup is automatic.
+
+Reel finds this `config.toml` automatically wherever you run it from (it also
+checks `./config.toml` and `~/.reel/config.toml` first). No config at all? It
+falls back to sensible defaults (`~/Reel`).
+
+---
+
+## Use it
+
+You really only need two commands. Run them from anywhere — your home prompt is fine.
+
+**First time** — run this, then plug in the recorder when it asks:
+```
+reel setup
+```
+A short welcome, then it waits for your ICD-UX570, does the big initial copy, and
+**stays running as auto-sync** from there. (Run `reel setup` again later and it
+just says *"Already set up :)"*.)
+
+**Every day after** — start auto-sync and leave it running:
+```
+reel start
+```
+It does the initial sync, then keeps syncing automatically whenever you **drop a
+file onto the recorder from your PC** — and it **stops by itself the moment you
+unplug** the recorder. (Press **Ctrl + C** to stop sooner.)
+
+That's the whole flow. The rest is optional:
+
+```
+reel sync              # a single one-off sync, then exit (rarely needed)
+reel sort <path>       # auto-filter a folder/files you drop in (or use the .bat)
+reel status            # what's in your library, per category
+reel devices           # is the recorder detected right now?
+reel open              # open the Reel library in Explorer
+reel reset             # clear first-time setup (to see the welcome again)
+reel --theme dark start# dark terminal theme
+```
+
+(`python -m reel start` and `python run.py start` work identically.)
+
+### Make it truly hands-off (optional)
+Put a shortcut to `reel start` in your Startup folder (`Win+R` → `shell:startup`).
+Reel will be running and watching from the moment you log in.
+
+---
+
+## Branding
+
+Light by default — colours tuned for a white terminal. Want dark? `theme = "dark"` in `config.toml`, or `--theme dark` on any command. Identity lives in `reel/branding.py`.
+
+## Notes
+
+- **Privacy:** nothing leaves your machine except the copies you put in your own mirror/cloud folders.
+- **Safety:** `delete_after_sync = false` by default — Reel copies off the recorder and never deletes from it.
+- **Coming later:** built-in playback, a podcast queue, smarter song-vs-voice detection. See `ROADMAP.md`.
+
+---
+
+*REEL v1.0.0 — plug in, walk away.*

reel_sync-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+# Published on PyPI as "reel-sync" (plain "reel" was taken). Friends install with
+# `pip install reel-sync`; the import package and the command both stay `reel`.
+[project]
+name = "reel-sync"
+dynamic = ["version"]          # single-sourced from reel/__init__.py
+description = "Fully-local sync tool for the Sony ICD-UX570 voice recorder"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Nicolas" }]
+keywords = ["sony", "icd-ux570", "voice-recorder", "sync", "dictaphone"]
+dependencies = [
+    "rich>=13.0",
+    "mutagen>=1.47",
+    "tomli>=2.0; python_version < '3.11'",
+]
+
+[project.urls]
+Homepage = "https://pypi.org/project/reel-sync/"
+
+[project.scripts]
+reel = "reel.__main__:main"
+
+[tool.setuptools]
+packages = ["reel"]
+py-modules = []
+
+[tool.setuptools.dynamic]
+version = { attr = "reel.__version__" }

reel_sync-1.0.0/reel/__init__.py

@@ -0,0 +1,2 @@
+"""Reel — a fully-local, automatic sync tool for the Sony ICD-UX570."""
+__version__ = "1.0.0"

reel_sync-1.0.0/reel/__main__.py

@@ -0,0 +1,157 @@
+"""
+__main__.py — the Reel command line.
+
+  reel setup               first-time setup, then flows into auto-sync
+  reel start               auto-sync: runs passively, syncs on any change
+  reel sync                one-off sync right now (rarely needed)
+  reel sort <path>...      run the same auto-filter on a folder/files (drag-drop)
+  reel status              library summary (counts per category, size)
+  reel open                open your Reel library in the file manager
+  reel devices             list any recorders currently detected
+  reel reset               clear first-time setup (to see the welcome again)
+
+Global:  --config path/to/config.toml   --theme light|dark
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .config import load, resolve_path
+
+
+def build_parser():
+    # shared options accepted both before AND after the subcommand
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--config", default=argparse.SUPPRESS)
+    common.add_argument("--theme", choices=["light", "dark"], default=argparse.SUPPRESS)
+
+    p = argparse.ArgumentParser(prog="reel", parents=[common],
+                                description="Reel — Sony ICD-UX570 sync")
+    sub = p.add_subparsers(dest="cmd")  # optional: bare `reel` -> splash
+    sub.add_parser("setup", parents=[common])
+    sub.add_parser("start", parents=[common])
+    sub.add_parser("sync", parents=[common])
+    ps = sub.add_parser("sort", parents=[common]); ps.add_argument("paths", nargs="+")
+    sub.add_parser("status", parents=[common])
+    sub.add_parser("open", parents=[common])
+    sub.add_parser("devices", parents=[common])
+    sub.add_parser("reset", parents=[common])
+    return p
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+
+    # Friendly front doors, handled before argparse:
+    #   reel            -> welcome splash
+    #   reel help / -h  -> clean command reference
+    if not argv or argv[0] in ("help", "-h", "--help"):
+        from .console import Reel
+        con = Reel(theme=load(resolve_path(None)).theme)
+        con.splash() if not argv else con.help_screen()
+        return 0
+
+    args = build_parser().parse_args(argv)
+    cfg = load(resolve_path(getattr(args, "config", None)))
+    theme = getattr(args, "theme", None)
+    if theme:
+        cfg.theme = theme
+
+    from .console import Reel
+    con = Reel(theme=cfg.theme)
+
+    if not args.cmd:
+        con.splash()
+        return 0
+
+    if args.cmd == "setup":
+        from .runner import first_setup
+        first_setup(cfg, con)
+
+    elif args.cmd == "start":
+        from .watch import auto_sync
+        from .runner import load_profile
+        con.logo()
+        con.greeting(load_profile(cfg).get("name"))
+        auto_sync(cfg, con)
+
+    elif args.cmd == "sync":
+        from .runner import sync_once
+        con.logo()
+        sync_once(cfg, con, sources=None)
+
+    elif args.cmd == "reset":
+        from .runner import reset_setup
+        if reset_setup(cfg):
+            con.ok("setup reset — run 'reel setup' to see the welcome again.")
+        else:
+            con.dim("nothing to reset — setup hasn't run yet.")
+
+    elif args.cmd == "sort":
+        from .runner import sync_once
+        con.logo()
+        paths = [Path(p) for p in args.paths]
+        missing = [str(p) for p in paths if not p.exists()]
+        if missing:
+            con.err("not found: " + ", ".join(missing))
+            return 1
+        sync_once(cfg, con, sources=paths)
+
+    elif args.cmd == "status":
+        _status(cfg, con)
+
+    elif args.cmd == "devices":
+        from . import device
+        devs = device.find_devices(cfg)
+        if not devs:
+            con.warn("no recorder detected.")
+        for d in devs:
+            con.ok(f"detected: {d}")
+
+    elif args.cmd == "open":
+        import os, subprocess
+        cfg.sync_root.mkdir(parents=True, exist_ok=True)
+        if sys.platform == "win32":
+            os.startfile(cfg.sync_root)  # noqa: S606
+        elif sys.platform == "darwin":
+            subprocess.run(["open", str(cfg.sync_root)])
+        else:
+            subprocess.run(["xdg-open", str(cfg.sync_root)])
+
+    return 0
+
+
+def _status(cfg, con):
+    from . import sync, branding
+    manifest = sync.load_manifest(cfg)
+    by_cat, total_bytes = {}, 0
+    for entry in manifest.values():
+        by_cat[entry["category"]] = by_cat.get(entry["category"], 0) + 1
+    # size from disk (authoritative)
+    if cfg.sync_root.exists():
+        for p in cfg.sync_root.rglob("*"):
+            if p.is_file() and ".reel" not in p.parts:
+                try:
+                    total_bytes += p.stat().st_size
+                except OSError:
+                    pass
+    lines = []
+    for cat in branding.CATEGORIES:
+        n = by_cat.get(cat, 0)
+        if n:
+            g = branding.CATEGORY_GLYPH.get(cat, "·")
+            col = branding.CATEGORY_COLOR.get(cat, "white")
+            lines.append(f"  [{col}]{g}[/{col}]  {cat:<12} {n}")
+    targets = ", ".join(str(t) for t in cfg.mirror_targets) or "(none)"
+    body = (f"  library   {cfg.sync_root}\n"
+            f"  recorded  {len(manifest)} files · {total_bytes/(1024*1024):.1f} MB\n"
+            f"  mirrors   {targets}\n")
+    if lines:
+        body += "\n" + "\n".join(lines)
+    con.panel("REEL status", body)
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

reel_sync-1.0.0/reel/branding.py

@@ -0,0 +1,76 @@
+"""
+branding.py — Reel's identity in one place.
+
+Clean and modern: a calm wordmark, light by default, dark on request.
+No CRT, no scanlines. Colours are chosen to read on a WHITE terminal first;
+the dark theme just brightens them.
+"""
+
+NAME = "REEL"
+VERSION = "1.0.0"
+TAGLINE = "voice-recorder sync"
+
+# A small, tasteful wordmark. Printed once at the top of a run.
+LOGO = r"""
+   ___ ___ ___ _
+  | _ \ __| __| |   ·  {tag}
+  |   / _|| _|| |__
+  |_|_\___|___|____|   {ver}
+"""
+
+# Big "Welcome" wordmark, shown on first-time setup.
+WELCOME_ART = r"""
+__        __   _
+\ \      / /__| | ___ ___  _ __ ___   ___
+ \ \ /\ / / _ \ |/ __/ _ \| '_ ` _ \ / _ \
+  \ V  V /  __/ | (_| (_) | | | | | |  __/
+   \_/\_/ \___|_|\___\___/|_| |_| |_|\___|
+"""
+
+# Categories the sorter produces, with a stable display order + glyph.
+CATEGORIES = ["Interviews", "Voice Notes", "Songs", "Podcasts", "Memes", "Other"]
+CATEGORY_GLYPH = {
+    "Interviews":  "▤",
+    "Voice Notes": "✎",
+    "Songs":       "♪",
+    "Podcasts":    "◉",
+    "Memes":       "★",
+    "Other":       "·",
+}
+
+# Semantic styles per theme. Keys are used by console.py to build a rich Theme.
+# Light = default (assumes a white/bright terminal background).
+THEMES = {
+    "light": {
+        "brand":   "bold #0b5fa5",   # deep blue wordmark
+        "accent":  "#0b5fa5",
+        "ok":      "bold #1a7f37",   # green
+        "warn":    "bold #9a6700",   # amber-brown
+        "err":     "bold #cf222e",   # red
+        "muted":   "#6e7781",        # grey
+        "value":   "default",        # the terminal's own fg — readable on any bg
+        "bar":     "#0b5fa5",
+        "bar_bg":  "#d0d7de",
+    },
+    "dark": {
+        "brand":   "bold #4493f8",
+        "accent":  "#4493f8",
+        "ok":      "bold #3fb950",
+        "warn":    "bold #d29922",
+        "err":     "bold #f85149",
+        "muted":   "#8b949e",
+        "value":   "default",
+        "bar":     "#4493f8",
+        "bar_bg":  "#30363d",
+    },
+}
+
+# Per-category accent (rich colour names / hex). Used in summaries.
+CATEGORY_COLOR = {
+    "Interviews":  "blue",
+    "Voice Notes": "cyan",
+    "Songs":       "magenta",
+    "Podcasts":    "green",
+    "Memes":       "yellow",
+    "Other":       "white",
+}

reel_sync-1.0.0/reel/classify.py

@@ -0,0 +1,35 @@
+"""
+classify.py — decide which category a recording belongs in. Rules, not AI.
+
+Signal order (first hit wins):
+  1. Source folder on the device  — MUSIC -> Songs, PODCASTS -> Podcasts.
+  2. Filename keyword             — "interview", "song", "meme", "podcast", …
+  3. Duration                     — very short -> Memes, very long -> Interviews,
+                                     otherwise -> Voice Notes.
+
+All thresholds and keywords live in config, so it's tunable without code edits.
+"""
+from __future__ import annotations
+
+
+def classify(*, source: str, filename: str, duration_sec: float | None, cfg) -> str:
+    src = (source or "").lower()
+    if src == "music":
+        return "Songs"
+    if src == "podcast":
+        return "Podcasts"
+
+    name = (filename or "").lower()
+    for kw, category in cfg.category_keywords.items():
+        if kw.lower() in name:
+            return category
+
+    d = duration_sec or 0
+    if d and d <= cfg.meme_max_sec:
+        return "Memes"
+    if d and d >= cfg.interview_min_sec:
+        return "Interviews"
+    if d:
+        return "Voice Notes"
+    # no duration available and no other signal
+    return "Voice Notes" if src == "voice" else "Other"

reel_sync-1.0.0/reel/config.py

@@ -0,0 +1,92 @@
+"""config.py — set it once. Every value has a sensible default."""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib
+
+
+@dataclass
+class Config:
+    # where synced recordings land (your "Reel" library)
+    sync_root: Path = Path.home() / "Reel"
+    # optional extra drives to also receive a copy (USB / cloud-synced folder)
+    mirror_targets: list[Path] = field(default_factory=list)
+
+    # how the ICD-UX570 shows up
+    device_labels: list[str] = field(
+        default_factory=lambda: ["IC RECORDER", "MEMORY CARD", "IC RECORDER MEMORY CARD"])
+    delete_from_device: bool = False   # safe default: copy, never wipe the recorder
+
+    # categorisation thresholds (seconds)
+    meme_max_sec: int = 20        # <= this  -> Memes
+    interview_min_sec: int = 480  # >= this  -> Interviews
+    # filename keyword -> forced category (case-insensitive substring)
+    category_keywords: dict = field(default_factory=lambda: {
+        "interview": "Interviews",
+        "song": "Songs",
+        "meme": "Memes",
+        "podcast": "Podcasts",
+    })
+
+    # watch mode
+    watch_interval_sec: int = 4
+    close_on_unplug: bool = True   # close the terminal window when the recorder is removed
+
+    # terminal theme: "light" (default) or "dark"
+    theme: str = "light"
+
+    @property
+    def manifest_path(self) -> Path:
+        return self.sync_root / ".reel" / "manifest.json"
+
+    @property
+    def profile_path(self) -> Path:
+        return self.sync_root / ".reel" / "profile.json"
+
+
+def resolve_path(explicit: str | os.PathLike | None = None) -> Path | None:
+    """Find config.toml wherever you run `reel` from. First match wins:
+      1. an explicit --config path
+      2. ./config.toml            (the folder you're standing in)
+      3. ~/.reel/config.toml      (a stable per-user spot)
+      4. config.toml next to the installed package (the project folder)
+    Returns None if none exist -> Reel runs on built-in defaults."""
+    candidates = []
+    if explicit:
+        candidates.append(Path(explicit).expanduser())
+    candidates.append(Path.cwd() / "config.toml")
+    candidates.append(Path.home() / ".reel" / "config.toml")
+    candidates.append(Path(__file__).resolve().parent.parent / "config.toml")
+    for c in candidates:
+        if c.exists():
+            return c
+    return None
+
+
+def load(path: str | os.PathLike | None) -> Config:
+    cfg = Config()
+    if path is None or not Path(path).exists():
+        return cfg
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    def g(section, key, default):
+        return data.get(section, {}).get(key, default)
+
+    cfg.sync_root = Path(g("library", "sync_root", str(cfg.sync_root))).expanduser()
+    cfg.mirror_targets = [Path(x).expanduser() for x in g("library", "mirror_targets", [])]
+    cfg.device_labels = g("device", "labels", cfg.device_labels)
+    cfg.delete_from_device = bool(g("device", "delete_after_sync", False))
+    cfg.meme_max_sec = int(g("categories", "meme_max_sec", cfg.meme_max_sec))
+    cfg.interview_min_sec = int(g("categories", "interview_min_sec", cfg.interview_min_sec))
+    cfg.category_keywords = g("categories", "keywords", cfg.category_keywords)
+    cfg.watch_interval_sec = int(g("watch", "interval_sec", cfg.watch_interval_sec))
+    cfg.close_on_unplug = bool(g("watch", "close_on_unplug", cfg.close_on_unplug))
+    cfg.theme = g("ui", "theme", cfg.theme)
+    return cfg