discstation 0.1.0

package/src/discstation_host.py

@@ -0,0 +1,380 @@
+"""Host-specific discovery and paths for DiscStation.
+
+The workflows use this module instead of assuming Linux device names or
+home-directory layout. Optical burning commands remain backend-specific.
+"""
+
+import os
+import platform
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from serial.tools import list_ports
+
+
+def system_name():
+    return platform.system().lower()
+
+
+def user_home():
+    return Path.home()
+
+
+def config_dir():
+    override = os.environ.get("DISCSTATION_CONFIG_DIR")
+    if override:
+        return Path(override).expanduser()
+    system = system_name()
+    if system == "windows":
+        return Path(os.environ.get("APPDATA", user_home())) / "DiscStation"
+    if system == "darwin":
+        return user_home() / "Library" / "Application Support" / "DiscStation"
+    return user_home() / ".local" / "share" / "discstation"
+
+
+def cache_dir():
+    override = os.environ.get("DISCSTATION_CACHE_DIR")
+    if override:
+        return Path(override).expanduser()
+    system = system_name()
+    if system == "windows":
+        return Path(os.environ.get("LOCALAPPDATA", user_home())) / "DiscStation" / "cache"
+    if system == "darwin":
+        return user_home() / "Library" / "Caches" / "DiscStation"
+    return Path(os.environ.get("XDG_CACHE_HOME", user_home() / ".cache")) / "discstation"
+
+
+def serial_port():
+    override = os.environ.get("DISC_PORT")
+    if override:
+        path = Path(override).expanduser()
+        if path.exists():
+            return str(path)
+
+    ports = list(list_ports.comports())
+    preferred = []
+    for port in ports:
+        vid_pid = (port.vid, port.pid)
+        description = (port.description or "").lower()
+        if vid_pid == (0x303A, 0x1001) or "esp32" in description or "cp210" in description:
+            preferred.append(port.device)
+    if not preferred:
+        return None
+    return _stable_serial_path(sorted(preferred)[0])
+
+
+def _stable_serial_path(device):
+    """Map a volatile /dev/ttyUSBN to its stable /dev/serial/by-id/ symlink so a
+    USB re-enumeration (ttyUSB1 -> ttyUSB0) doesn't strand the reconnect loop."""
+    try:
+        target = Path(device).resolve()
+        for link in Path("/dev/serial/by-id").iterdir():
+            try:
+                if link.resolve() == target:
+                    return str(link)
+            except OSError:
+                continue
+    except OSError:
+        pass
+    return device
+
+
+def _mac_optical_device():
+    try:
+        result = subprocess.run(
+            ["/usr/sbin/ioreg", "-r", "-c", "IODVDServices", "-l"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=3,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    match = re.search(r'"BSD Name"\s*=\s*"(disk\d+)"', result.stdout)
+    return f"/dev/{match.group(1)}" if match else None
+
+
+def disc_device():
+    system = system_name()
+    override = os.environ.get("DISC_DEVICE") or os.environ.get("DVD_DEVICE")
+    if system == "darwin":
+        detected = _mac_optical_device()
+        if detected:
+            return detected
+        if override and Path(override).exists():
+            return override
+    elif override:
+        return override
+
+    if system == "linux":
+        for name in ("/dev/dvd", "/dev/cdrom"):
+            path = Path(name)
+            if path.exists():
+                return str(path.resolve())
+        drives = sorted(Path("/dev").glob("sr*"))
+        if drives:
+            return str(drives[0])
+    elif system == "darwin":
+        try:
+            status = subprocess.run(["/usr/bin/drutil", "status"], capture_output=True, text=True, check=False, timeout=3)
+        except (OSError, subprocess.TimeoutExpired):
+            status = None
+        if status:
+            match = re.search(r"Name:\s+(/dev/disk\S+)", status.stdout + status.stderr)
+            if match:
+                return match.group(1)
+        result = subprocess.run(["/usr/sbin/diskutil", "list"], capture_output=True, text=True, check=False, timeout=5)
+        for line in result.stdout.splitlines():
+            if "/dev/disk" in line and ("CD" in line or "DVD" in line or "optical" in line.lower()):
+                return line.strip().split()[0]
+    elif system == "windows":
+        raise RuntimeError("Set DISC_DEVICE to the optical drive letter on Windows")
+    raise FileNotFoundError("No optical disc drive found; set DISC_DEVICE explicitly")
+
+
+def _drutil_media_properties():
+    result = subprocess.run(["/usr/bin/drutil", "status"], capture_output=True, text=True, check=False, timeout=3)
+    text = result.stdout + result.stderr
+    lowered = text.lower()
+    if result.returncode != 0 or "no media" in lowered:
+        return {}
+    props = {"ID_CDROM": "1", "ID_CDROM_MEDIA": "1"}
+    if "space used:" in lowered and "00:00:00" in lowered.split("space used:", 1)[1][:24]:
+        props["ID_CDROM_MEDIA_STATE"] = "blank"
+    if "type: cd" in lowered:
+        props["ID_CDROM_MEDIA_TYPE"] = "audio"
+    elif "type: dvd" in lowered:
+        props["ID_CDROM_MEDIA_TYPE"] = "dvd"
+    return props
+
+
+def media_properties(device):
+    """Return udev-like media properties on non-Linux hosts."""
+    if system_name() == "darwin":
+        try:
+            disk = subprocess.run(["/usr/sbin/diskutil", "info", device], capture_output=True, text=True, check=False, timeout=3)
+        except subprocess.TimeoutExpired:
+            return _drutil_media_properties()
+        if disk.returncode != 0:
+            return {}
+        fields = {}
+        for line in disk.stdout.splitlines():
+            if ":" in line:
+                key, value = line.split(":", 1)
+                fields[key.strip()] = value.strip()
+        optical = fields.get("Optical Media Type", "")
+        if not optical and not fields.get("Device / Media Name"):
+            return {}
+        props = {"ID_CDROM": "1", "ID_CDROM_MEDIA": "1"}
+        label = fields.get("Volume Name", "")
+        filesystem = fields.get("Type (Bundle)") or fields.get("File System Personality")
+        if label and label not in ("Not applicable (no file system)", ""):
+            props["ID_FS_LABEL"] = label
+        if filesystem:
+            normalized = re.sub(r"[^a-z0-9]+", "", filesystem.lower())
+            if "udf" in normalized or "universaldiskformat" in normalized:
+                props["ID_FS_TYPE"] = "udf"
+            elif "iso9660" in normalized:
+                props["ID_FS_TYPE"] = "iso9660"
+            else:
+                props["ID_FS_TYPE"] = filesystem.lower()
+        mount_point = fields.get("Mount Point", "")
+        if mount_point and mount_point != "Not applicable":
+            props["ID_MOUNT_POINT"] = mount_point
+        if label.lower() == "audio cd":
+            props["ID_CDROM_MEDIA_TYPE"] = "audio"
+        elif "cd" in optical.lower() and "r" not in optical.lower():
+            props["ID_CDROM_MEDIA_TYPE"] = "audio"
+        elif "dvd" in optical.lower():
+            props["ID_CDROM_MEDIA_TYPE"] = "dvd"
+        if not label or label == "Not applicable (no file system)":
+            props["ID_CDROM_MEDIA_STATE"] = "blank"
+        optical = optical.lower()
+        if "dvd+r dl" in optical or "dvd-r dl" in optical:
+            props["ID_CDROM_MEDIA_DVD_PLUS_R_DL"] = "1"
+        elif "dvd+r" in optical or "dvd-r" in optical:
+            props["ID_CDROM_MEDIA_DVD_PLUS_R"] = "1"
+        return props
+    return {}
+
+
+def media_capacity_bytes(device):
+    if system_name() == "darwin":
+        try:
+            result = subprocess.run(["/usr/sbin/diskutil", "info", device], capture_output=True, text=True, check=False, timeout=3)
+        except subprocess.TimeoutExpired:
+            result = subprocess.run(["/usr/bin/drutil", "status"], capture_output=True, text=True, check=False, timeout=3)
+            match = re.search(r"blocks:\s*(\d+)\s*/", result.stdout + result.stderr, re.IGNORECASE)
+            if match:
+                return int(match.group(1)) * 2048
+            return None
+        match = re.search(r"Disk Size:.*?\((\d+) Bytes\)", result.stdout, re.IGNORECASE)
+        if match:
+            return int(match.group(1))
+    return None
+
+
+def tool(name):
+    local = user_home() / ".local" / "bin" / name
+    if local.exists():
+        return str(local)
+    path = shutil.which(name)
+    if path:
+        return path
+    if system_name() == "darwin":
+        candidates = [
+            Path("/opt/homebrew/bin") / name,
+            Path("/usr/local/bin") / name,
+            Path("/opt/homebrew/opt/cdrtools/bin") / name,
+            Path("/usr/local/opt/cdrtools/bin") / name,
+        ]
+        for candidate in candidates:
+            if candidate.exists():
+                return str(candidate)
+    raise FileNotFoundError(
+        f"{name} is not installed on {system_name()}; install the DiscStation host dependencies"
+    )
+
+
+def null_device():
+    return "NUL" if system_name() == "windows" else "/dev/null"
+
+
+def can_use_linux_optical_backend():
+    return system_name() == "linux" and all(shutil.which(name) for name in ("growisofs", "wodim", "cdrdao"))
+
+
+def build_data_image(source_paths, output_path, label, video=False):
+    system = system_name()
+    if system == "darwin":
+        command = [tool("hdiutil"), "makehybrid", "-o", str(output_path), "-iso", "-joliet", "-udf"]
+        command += ["-default-volume-name", label, *[str(path) for path in source_paths]]
+    elif system == "windows":
+        command = [tool("xorriso"), "-as", "mkisofs", "-iso-level", "3", "-J", "-R", "-V", label, "-o", str(output_path)]
+        command += [str(path) for path in source_paths]
+    else:
+        raise RuntimeError("Image building is only used by non-Linux optical backends")
+    subprocess.run(command, check=True, capture_output=True, text=True)
+    return output_path
+
+
+def iso_burn_command(device, image_path):
+    system = system_name()
+    if system == "darwin":
+        return [tool("hdiutil"), "burn", str(image_path)]
+    if system == "windows":
+        return [tool("isoburn.exe"), "/Q", device, str(image_path)]
+    raise RuntimeError("ISO command requested on Linux; use growisofs backend")
+
+
+def audio_output_device():
+    """Return an MPV audio-device override for a connected Bluetooth sink."""
+    override = os.environ.get("DISC_AUDIO_DEVICE")
+    if override:
+        return override
+    if system_name() == "linux":
+        pactl = shutil.which("pactl")
+        if pactl:
+            result = subprocess.run([pactl, "list", "short", "sinks"], capture_output=True, text=True, check=False)
+            for line in result.stdout.splitlines():
+                fields = line.split()
+                if len(fields) >= 2 and "bluez_output." in fields[1]:
+                    return f"pipewire/{fields[1]}"
+    return None
+
+
+def cdrdao_device(device):
+    if system_name() != "darwin":
+        return device
+    cdrdao = tool("cdrdao")
+    for attempt in range(2):
+        result = subprocess.run([cdrdao, "scanbus"], capture_output=True, text=True, check=False, timeout=10)
+        for line in (result.stdout + result.stderr).splitlines():
+            if "IODVDServices" in line and " : " in line:
+                return line.split(" : ", 1)[0].strip()
+        if attempt == 0 and device:
+            subprocess.run(
+                ["/usr/sbin/diskutil", "unmountDisk", "force", device],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=15,
+            )
+    raise RuntimeError("cdrdao could not find the macOS optical writer")
+
+
+def unmount_device(device):
+    """Unmount Linux optical media before handing the device to a writer."""
+    if system_name() != "linux" or not device:
+        return True
+
+    udisksctl = shutil.which("udisksctl")
+    if udisksctl:
+        try:
+            result = subprocess.run(
+                [udisksctl, "unmount", "--block-device", device],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=15,
+            )
+            if result.returncode == 0:
+                return True
+        except (OSError, subprocess.TimeoutExpired):
+            pass
+
+    try:
+        mounts = subprocess.run(
+            ["findmnt", "--source", device, "--output", "TARGET", "--noheadings", "--raw"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=5,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise RuntimeError(f"Could not inspect optical mount: {exc}") from exc
+
+    if mounts.returncode not in (0, 1):
+        detail = (mounts.stderr or mounts.stdout or "findmnt failed").strip()
+        raise RuntimeError(f"Could not inspect optical mount: {detail}")
+
+    targets = [line.strip() for line in mounts.stdout.splitlines() if line.strip()]
+    for target in reversed(targets):
+        result = subprocess.run(
+            ["umount", "--", target],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=15,
+        )
+        if result.returncode != 0:
+            detail = (result.stderr or result.stdout or "umount failed").strip()
+            raise RuntimeError(f"Could not unmount optical disc: {detail}")
+
+    return True
+
+
+def eject_device(device, close=False):
+    system = system_name()
+    if system == "linux":
+        command = ["eject"]
+        if close:
+            command.append("-t")
+        command.append(device)
+    elif system == "darwin":
+        action = "close" if close else "open"
+        commands = [["/usr/bin/drutil", "tray", action]]
+        if device:
+            commands.append(["/usr/sbin/diskutil", "eject", device])
+        for command in commands:
+            try:
+                if subprocess.run(command, capture_output=True, text=True, timeout=10).returncode == 0:
+                    return True
+            except (OSError, subprocess.TimeoutExpired):
+                pass
+        return False
+    else:
+        raise RuntimeError("Automatic optical-drive eject is not implemented on Windows")
+    return subprocess.run(command, capture_output=True, text=True, timeout=10).returncode == 0

package/src/discstation_meta.py

@@ -0,0 +1,150 @@
+"""Optional video (movie / TV) metadata lookup via TMDb.
+
+All functions degrade to no-ops when `tmdbsimple` is not installed or no API key
+is configured (env DISCSTATION_TMDB_API_KEY, or ~/.local/share/discstation/tmdb.key
+/ ~/.config/discstation/tmdb.key).
+"""
+import json
+import os
+import re
+from pathlib import Path
+
+try:
+    import requests
+except Exception:  # pragma: no cover
+    requests = None
+
+try:
+    import tmdbsimple as _tmdb
+except Exception:
+    _tmdb = None
+
+_IMG_BASE = "https://image.tmdb.org/t/p/w500"
+_YEAR_RE = re.compile(r"(19|20)\d{2}")
+
+
+def _api_key():
+    key = os.environ.get("DISCSTATION_TMDB_API_KEY", "").strip()
+    if key:
+        return key
+    for cand in (
+        Path.home() / ".local/share/discstation/tmdb.key",
+        Path.home() / ".config/discstation/tmdb.key",
+    ):
+        try:
+            k = cand.read_text().strip()
+            if k:
+                return k
+        except OSError:
+            pass
+    return None
+
+
+def available():
+    return _tmdb is not None and _api_key() is not None
+
+
+def _clean_title(raw):
+    """Turn a disc label / filename stem into a plausible search title + year."""
+    if not raw:
+        return "", None
+    name = str(raw).replace("_", " ").strip()
+    year = None
+    m = _YEAR_RE.search(name)
+    if m:
+        year = m.group(0)
+        name = (name[:m.start()] + " " + name[m.end():])
+    name = re.sub(r"\b(disc\s*\d*|dvd|video[_ ]?ts|bluray|blu-ray|pal|ntsc|"
+                  r"region\s*\d|season\s*\d+|s\d+|d\d+)\b", " ", name, flags=re.I)
+    name = re.sub(r"[._()\[\]]+", " ", name)
+    name = re.sub(r"\s{2,}", " ", name).strip(" -")
+    return name, year
+
+
+def lookup(title_guess, year=None):
+    """Return {title, year, tmdb_id, media_type, poster_url, overview} or None."""
+    if not available():
+        return None
+    name, guessed_year = _clean_title(title_guess)
+    year = year or guessed_year
+    if not name:
+        return None
+    _tmdb.API_KEY = _api_key()
+    try:
+        search = _tmdb.Search()
+        movie_kwargs = {"query": name}
+        if year:
+            movie_kwargs["year"] = year
+        results = (search.movie(**movie_kwargs).get("results") or [])
+        media_type = "movie"
+        if not results:
+            tv_kwargs = {"query": name}
+            if year:
+                tv_kwargs["first_air_date_year"] = year
+            results = (search.tv(**tv_kwargs).get("results") or [])
+            media_type = "tv"
+        if not results:
+            return None
+        top = results[0]
+        released = top.get("release_date") or top.get("first_air_date") or ""
+        return {
+            "title": top.get("title") or top.get("name") or name,
+            "year": released[:4] or (year or ""),
+            "tmdb_id": top.get("id"),
+            "media_type": media_type,
+            "poster_url": _IMG_BASE + top["poster_path"] if top.get("poster_path") else None,
+            "overview": top.get("overview") or "",
+        }
+    except Exception as e:  # tmdbsimple raises its own APIKeyError / HTTPError types
+        print(f"TMDb lookup failed: {e}")
+        return None
+
+
+def folder_name(meta):
+    base = re.sub(r'[\\/:*?"<>|]+', "_", (meta.get("title") or "").strip())
+    base = re.sub(r"\s+", " ", base).strip()
+    year = meta.get("year")
+    if base and year:
+        return f"{base} ({year})"
+    return base or ""
+
+
+def _nfo(meta):
+    tag = "tvshow" if meta.get("media_type") == "tv" else "movie"
+
+    def esc(value):
+        return (str(value).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+
+    return "\n".join([
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        f"<{tag}>",
+        f"  <title>{esc(meta.get('title', ''))}</title>",
+        f"  <year>{esc(meta.get('year', ''))}</year>",
+        f"  <plot>{esc(meta.get('overview', ''))}</plot>",
+        f'  <uniqueid type="tmdb" default="true">{esc(meta.get("tmdb_id", ""))}</uniqueid>',
+        f"</{tag}>",
+        "",
+    ])
+
+
+def save_assets(out_dir, meta):
+    """Write movie.nfo and poster.jpg into out_dir (best effort)."""
+    out_dir = Path(out_dir)
+    try:
+        (out_dir / "movie.nfo").write_text(_nfo(meta), encoding="utf-8")
+    except OSError:
+        pass
+    if meta.get("poster_url") and requests is not None:
+        try:
+            r = requests.get(meta["poster_url"], timeout=30)
+            if r.status_code == 200 and r.content:
+                (out_dir / "poster.jpg").write_bytes(r.content)
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":  # quick manual test: python3 discstation_meta.py "The Matrix 1999"
+    import sys
+    print("available:", available())
+    if len(sys.argv) > 1:
+        print(json.dumps(lookup(" ".join(sys.argv[1:])), indent=2))