reel-sync 1.0.0__py3-none-any.whl

reel/__init__.py

@@ -0,0 +1,2 @@
+"""Reel — a fully-local, automatic sync tool for the Sony ICD-UX570."""
+__version__ = "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/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/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/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