bdix-stremio-addon 2.0.1__tar.gz

bdix_stremio_addon-2.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 serra666
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bdix_stremio_addon-2.0.1/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: bdix-stremio-addon
+Version: 2.0.1
+Summary: One combined Stremio stream addon for BDIX/FTP sources, with a web UI to choose which sources are included.
+License: MIT License
+        
+        Copyright (c) 2026 serra666
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: stremio,stremio-addon,addon,streams,bdix,torrentio
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# bdix-stremio-addon
+
+A Stremio addon for BDIX stream sites, with a web UI to choose which sources
+are included. Python 3.8+, standard library only.
+
+## Supported sites
+
+1. **Dflix**
+2. **CircleFTP**
+
+## Install
+
+Run it without installing anything:
+
+```bash
+uvx bdix-stremio-addon           # or: pipx run bdix-stremio-addon
+```
+
+Or install it:
+
+```bash
+pipx install bdix-stremio-addon     # then run:  bdix
+pip install bdix-stremio-addon      # then run:  python -m bdix
+```
+
+Then open <http://127.0.0.1:7000/>, pick your sources, and install the addon
+into Stremio from that page.
+
+## Use it from a TV or phone
+
+The addon listens on `127.0.0.1`, which only reaches Stremio running on the
+same machine. To use it elsewhere, expose the port with a tunnel:
+
+```bash
+ngrok http 7000
+# or
+cloudflared tunnel --url http://127.0.0.1:7000
+```
+
+Either one prints a public `https://…` address. Add `/manifest.json` to that
+address and install it in Stremio → Addons → **Install from URL**.
+
+Note that CircleFTP's mirrors are ISP-locked, so its streams only play while
+the device is on your ISP's network — a tunnel can't change that. Dflix works
+from anywhere.

bdix_stremio_addon-2.0.1/README.md

@@ -0,0 +1,45 @@
+# bdix-stremio-addon
+
+A Stremio addon for BDIX stream sites, with a web UI to choose which sources
+are included. Python 3.8+, standard library only.
+
+## Supported sites
+
+1. **Dflix**
+2. **CircleFTP**
+
+## Install
+
+Run it without installing anything:
+
+```bash
+uvx bdix-stremio-addon           # or: pipx run bdix-stremio-addon
+```
+
+Or install it:
+
+```bash
+pipx install bdix-stremio-addon     # then run:  bdix
+pip install bdix-stremio-addon      # then run:  python -m bdix
+```
+
+Then open <http://127.0.0.1:7000/>, pick your sources, and install the addon
+into Stremio from that page.
+
+## Use it from a TV or phone
+
+The addon listens on `127.0.0.1`, which only reaches Stremio running on the
+same machine. To use it elsewhere, expose the port with a tunnel:
+
+```bash
+ngrok http 7000
+# or
+cloudflared tunnel --url http://127.0.0.1:7000
+```
+
+Either one prints a public `https://…` address. Add `/manifest.json` to that
+address and install it in Stremio → Addons → **Install from URL**.
+
+Note that CircleFTP's mirrors are ISP-locked, so its streams only play while
+the device is on your ISP's network — a tunnel can't change that. Dflix works
+from anywhere.

bdix_stremio_addon-2.0.1/bdix/__init__.py

@@ -0,0 +1,10 @@
+"""bdix - one combined Stremio stream addon for BDIX/FTP sources.
+
+A single manifest and a single /stream endpoint that fans out to every enabled
+source (see bdix/sources/) and merges the results, plus a small web UI for
+choosing which sources are enabled.
+
+Standard library only - no dependencies.
+"""
+
+__version__ = "2.0.1"

bdix_stremio_addon-2.0.1/bdix/__main__.py

@@ -0,0 +1,293 @@
+"""Command line entry point.
+
+    python -m bdix                 serve the addon + web UI
+    python -m bdix --smoke         headless self-check, exits 0/1
+    python -m bdix --port 8000     bind somewhere else
+    python -m bdix --idle-exit 60  quit after an hour with no requests
+
+Serving is a single process and spawns nothing, so however this is stopped
+(Ctrl+C, closing the terminal, killing the pid) nothing is left behind.
+"""
+import argparse
+import json
+import os
+import signal
+import sys
+import tempfile
+import threading
+import time
+import urllib.error
+import urllib.request
+import webbrowser
+
+from . import __version__
+from .common import meta_by_id
+from .config import config_path, load as load_config
+from .server import BDIXServer, Handler, State, collect_streams, manifest
+from .sources import discover
+
+# What --smoke probes.  A well-known film, so any working source should match it.
+SMOKE_MOVIE = "tt0111161"
+
+
+# ======================================================================
+# serving
+# ======================================================================
+
+def _sig_sources():
+    for name in ("SIGINT", "SIGTERM", "SIGBREAK"):
+        sig = getattr(signal, name, None)
+        if sig is not None:
+            yield sig
+
+
+def _banner(state, selected):
+    on = [k for k in state.sources if k in selected]
+    off = [k for k in state.sources if k not in selected]
+    base = f"http://{state.host}:{state.port}"
+    lines = [
+        f"BDIX streams  v{__version__}",
+        f"  web UI    {base}/",
+        f"  manifest  {base}/manifest.json",
+        "  sources   " + ", ".join(
+            [f"{k} (on)" for k in on] + [f"{k} (off)" for k in off]),
+        "  Press Ctrl+C once to stop. One process, nothing left behind.",
+    ]
+    print("\n".join(lines), flush=True)
+
+
+def serve(args):
+    registry = discover()
+    if not registry:
+        print("[bdix] no sources found in bdix/sources/", file=sys.stderr)
+        return 1
+
+    selected, cfg_port = load_config(list(registry))
+    port = args.port if args.port is not None else cfg_port
+    state = State(registry, selected, port)
+    state.host = args.host
+
+    try:
+        server = BDIXServer((args.host, port), Handler, state, log=args.log)
+    except OSError as e:
+        print(f"[bdix] cannot listen on {args.host}:{port} - {e}\n"
+              f"       another copy may already be running; "
+              f"try --port {port + 1}", file=sys.stderr)
+        return 1
+
+    state.port = server.server_address[1]
+    _banner(state, selected)
+    print(f"  config    {config_path()}", flush=True)
+
+    if not args.no_open:
+        threading.Thread(
+            target=lambda: webbrowser.open(f"http://{args.host}:{state.port}/"),
+            daemon=True).start()
+
+    stop = threading.Event()
+    hits = {"n": 0}
+
+    def on_signal(signum, frame):
+        hits["n"] += 1
+        if hits["n"] > 1:                   # impatient second Ctrl+C
+            print("\n[bdix] forced exit", flush=True)
+            os._exit(130)
+        print("\n[bdix] stopping (Ctrl+C again to force)", flush=True)
+        stop.set()
+
+    for sig in _sig_sources():
+        try:
+            signal.signal(sig, on_signal)
+        except (ValueError, OSError, RuntimeError):
+            pass                            # not in the main thread / unsupported
+
+    if args.idle_exit and args.idle_exit > 0:
+        threading.Thread(target=_idle_watch,
+                         args=(state, stop, args.idle_exit), daemon=True).start()
+
+    threading.Thread(target=server.serve_forever, name="bdix-http",
+                     daemon=True).start()
+    try:
+        while not stop.wait(0.5):
+            pass
+    except KeyboardInterrupt:               # signal handler not installed
+        pass
+
+    server.shutdown()
+    server.server_close()
+    print("[bdix] stopped", flush=True)
+    return 0
+
+
+def _idle_watch(state, stop, minutes):
+    limit = minutes * 60.0
+    while not stop.wait(5.0):
+        idle = time.time() - state.last_hit
+        if idle > limit:
+            print(f"[bdix] no requests for {minutes:g} min - exiting", flush=True)
+            stop.set()
+            return
+
+
+# ======================================================================
+# smoke test
+# ======================================================================
+
+def _http(url, payload=None, timeout=90):
+    """Return (status, parsed-json-or-text)."""
+    data = None
+    headers = {}
+    if payload is not None:
+        data = json.dumps(payload).encode("utf-8")
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=data, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            raw = r.read().decode("utf-8", "replace")
+            status = r.status
+    except urllib.error.HTTPError as e:
+        raw, status = e.read().decode("utf-8", "replace"), e.code
+    try:
+        return status, json.loads(raw)
+    except ValueError:
+        return status, raw
+
+
+def smoke():
+    """Run the real server on an ephemeral port and exercise the real routes."""
+    # Isolate config writes from the user's ~/.bdix/config.json
+    os.environ["BDIX_HOME"] = tempfile.mkdtemp(prefix="bdix-smoke-")
+
+    registry = discover()
+    print(f"[1] sources discovered: "
+          f"{', '.join(f'{k} ({m.NAME})' for k, m in registry.items()) or 'NONE'}")
+    if not registry:
+        print("FAIL: no sources")
+        return 1
+    fails = []
+
+    state = State(registry, list(registry), 0)
+    try:
+        server = BDIXServer(("127.0.0.1", 0), Handler, state)
+    except OSError as e:
+        print(f"FAIL: cannot bind an ephemeral port: {e}")
+        return 1
+    state.port = server.server_address[1]
+    base = f"http://127.0.0.1:{state.port}"
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+
+    try:
+        # -- 2. web UI -----------------------------------------------------
+        status, body = _http(base + "/")
+        ok = status == 200 and "BDIX" in body
+        print(f"[2] GET /                -> {status} "
+              f"{'ok' if ok else 'FAIL: expected the web UI'}")
+        if not ok:
+            fails.append("web UI")
+
+        # -- 3. manifest ---------------------------------------------------
+        status, m = _http(base + "/manifest.json")
+        ok = (status == 200 and m.get("id") == "org.bdix"
+              and m.get("resources") == ["stream"] and m.get("catalogs") == [])
+        print(f"[3] GET /manifest.json   -> {status} "
+              f"{'ok' if ok else 'FAIL: ' + str(m)[:120]}")
+        if not ok:
+            fails.append("manifest")
+
+        # -- 4. reachability (decides whether to assert on streams) --------
+        status, chk = _http(base + "/api/check", payload={}, timeout=60)
+        results = chk.get("results", []) if isinstance(chk, dict) else []
+        live = [r for r in results if r.get("ok")]
+        for r in results:
+            print(f"      {r['key']:<10} {'reachable' if r['ok'] else 'unreachable'}"
+                  f"  {r['ms']} ms  {'' if r['ok'] else r['detail'][:70]}")
+
+        # -- 5. merged streams over a real HTTP request --------------------
+        status, got = _http(base + f"/stream/movie/{SMOKE_MOVIE}.json")
+        streams = got.get("streams", []) if isinstance(got, dict) else []
+        print(f"[4] GET /stream/movie/{SMOKE_MOVIE}.json -> {status}, "
+              f"{len(streams)} stream(s)")
+        for s in streams[:6]:
+            print(f"      - {s.get('title', '?')}")
+        if status != 200:
+            fails.append("stream route status")
+        elif live and not streams:
+            fails.append("no streams despite reachable sources")
+        elif not live:
+            print("      (every source unreachable - skipping the stream assertion)")
+
+        # -- 6. per-source contribution, in process for timing -------------
+        meta = meta_by_id("movie", SMOKE_MOVIE)
+        print(f"[5] Cinemeta name: {meta.get('name')!r} "
+              f"year={meta.get('year')!r}")
+        for key, mod in registry.items():
+            t0 = time.time()
+            try:
+                n = len(mod.get_streams("movie", SMOKE_MOVIE, meta) or [])
+                note = f"{n} stream(s)"
+            except Exception as e:
+                note = f"error: {e}"
+            print(f"      {key:<10} {note}  ({time.time() - t0:.1f}s)")
+
+        # -- 7. selection actually gates the stream route ------------------
+        status, saved = _http(base + "/api/config",
+                              payload={"sources": []})
+        status2, got2 = _http(base + f"/stream/movie/{SMOKE_MOVIE}.json")
+        empty = isinstance(got2, dict) and got2.get("streams") == []
+        print(f"[6] sources=[] saved -> {status} {saved}; "
+              f"stream route now returns {len(got2.get('streams', []))} "
+              f"{'ok' if empty else 'FAIL: still serving with nothing enabled'}")
+        if not empty or status != 200:
+            fails.append("config gating")
+
+        status, cfg = _http(base + "/api/config")
+        print(f"[7] GET /api/config      -> {status}, selected={cfg.get('selected')}")
+
+        # -- 8. unknown route is a clean 404, not a crash ------------------
+        status, _ = _http(base + "/nope")
+        print(f"[8] GET /nope            -> {status} "
+              f"{'ok' if status == 404 else 'FAIL'}")
+        if status != 404:
+            fails.append("404 handling")
+    finally:
+        server.shutdown()
+        server.server_close()
+
+    print()
+    if fails:
+        print("FAIL: " + ", ".join(fails))
+        return 1
+    print("PASS")
+    return 0
+
+
+# ======================================================================
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="bdix",
+        description="One combined Stremio stream addon for BDIX/FTP sources, "
+                    "with a web UI to pick which sources are included.")
+    parser.add_argument("--host", default="127.0.0.1",
+                        help="interface to bind (default 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=None,
+                        help="port to bind (default: the saved config, else 7000)")
+    parser.add_argument("--log", action="store_true",
+                        help="log every request")
+    parser.add_argument("--no-open", action="store_true",
+                        help="don't open the web UI in a browser")
+    parser.add_argument("--idle-exit", type=float, default=0.0, metavar="MIN",
+                        help="exit after MIN minutes with no requests (0 = never)")
+    parser.add_argument("--smoke", action="store_true",
+                        help="run a headless self-check and exit")
+    parser.add_argument("--version", action="version",
+                        version=f"bdix {__version__}")
+    args = parser.parse_args(argv)
+
+    if args.smoke:
+        return smoke()
+    return serve(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

bdix_stremio_addon-2.0.1/bdix/common.py

@@ -0,0 +1,117 @@
+"""Shared framework helpers - stdlib only, no site logic in here.
+
+Sources import from this module; the server imports from this module.  This is
+where the code that used to be duplicated verbatim in both standalone addons
+lives: the Cinemeta meta lookup (+ its cache), the title matcher, the Stremio id
+parser and the quality ranking.
+"""
+import difflib
+import json
+import re
+import urllib.parse
+import urllib.request
+
+CINEMETA = "https://v3-cinemeta.strem.io/meta"
+
+UA = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) bdix/2.0"}
+
+
+# ======================================================================
+# HTTP
+# ======================================================================
+
+def fetch_text(url, timeout=60, headers=None):
+    req = urllib.request.Request(url, headers=dict(headers or UA))
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return r.read().decode("utf-8", "replace")
+
+
+def fetch_json(url, timeout=30, headers=None):
+    req = urllib.request.Request(url, headers=dict(headers or UA))
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.load(r)
+
+
+# ======================================================================
+# Cinemeta: turn a Stremio id back into name/year/kind
+# ======================================================================
+
+_META_CACHE = {}            # (vtype, base_id) -> Cinemeta meta dict (or {})
+
+
+def meta_by_id(vtype, base):
+    """Cinemeta meta for a Stremio id, cached (misses cached as {} too)."""
+    key = (vtype, base)
+    if key not in _META_CACHE:
+        try:
+            url = (f"{CINEMETA}/{vtype}/"
+                   f"{urllib.parse.quote(base, safe='')}.json")
+            meta = (fetch_json(url).get("meta") or {})
+        except Exception:
+            meta = {}
+        _META_CACHE[key] = meta
+        if len(_META_CACHE) > 2000:
+            _META_CACHE.pop(next(iter(_META_CACHE)))
+    return _META_CACHE[key]
+
+
+def int_year(v):
+    if isinstance(v, int) and v > 1900:
+        return v
+    m = re.match(r"(\d{4})", str(v or ""))
+    return int(m.group(1)) if m else None
+
+
+def meta_year(meta):
+    return (int_year(meta.get("year"))
+            or int_year(meta.get("released"))
+            or int_year(meta.get("firstAired")))
+
+
+# ======================================================================
+# Title matching
+# ======================================================================
+
+def norm(s):
+    return re.sub(r"[^a-z0-9]+", " ", (s or "").lower()).strip()
+
+
+def similar(a, b):
+    a, b = norm(a), norm(b)
+    if not a or not b:
+        return 0.0
+    if a == b:
+        return 1.0
+    if a in b or b in a:
+        return 0.9
+    return difflib.SequenceMatcher(None, a, b).ratio()
+
+
+def year_bonus(gap):
+    return {0: 0.30, 1: 0.25, 2: 0.18, 3: 0.10,
+            4: 0.04}.get(gap, 0.0)
+
+
+# ======================================================================
+# Stremio ids + stream ranking
+# ======================================================================
+
+def split_vid(vid):
+    """'tt0111161' -> (base, None, None); 'tt0903747:1:5' -> (base, 1, 5)."""
+    parts = (vid or "").split(":")
+    base = parts[0]
+    season = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else None
+    episode = int(parts[2]) if len(parts) > 2 and parts[2].isdigit() else None
+    return base, season, episode
+
+
+_QUALITY_RANK = {"2160p": 6, "4k": 6, "1080p": 5, "720p": 4,
+                 "480p": 3, "360p": 2, "240p": 1}
+
+_QUALITY_RE = re.compile(r"(2160p|4k|1080p|720p|480p|360p|240p)", re.IGNORECASE)
+
+
+def quality_score(text):
+    """Rank a stream by the quality tag in its title (0 when unknown)."""
+    m = _QUALITY_RE.search(text or "")
+    return _QUALITY_RANK.get(m.group(1).lower(), 0) if m else 0

bdix_stremio_addon-2.0.1/bdix/config.py

@@ -0,0 +1,71 @@
+"""Config storage - ~/.bdix/config.json.
+
+Holds the source selection (and optionally the port).  `BDIX_HOME` overrides the
+directory, which is what the smoke test uses to stay out of the real config.
+"""
+import json
+import os
+from pathlib import Path
+
+DEFAULT_PORT = 7000
+
+
+def config_dir():
+    override = os.environ.get("BDIX_HOME")
+    return Path(override) if override else (Path.home() / ".bdix")
+
+
+def config_path():
+    return config_dir() / "config.json"
+
+
+def load(all_keys):
+    """Return (selected_keys, port).
+
+    Missing or corrupt config means "everything enabled" - the addon is useful
+    out of the box.  An explicitly saved empty list stays empty (the user turned
+    every source off on purpose).  Unknown keys are dropped, so a config written
+    before a source was removed still loads.
+    """
+    data = {}
+    path = config_path()
+    if path.exists():
+        try:
+            data = json.loads(path.read_text("utf-8"))
+        except Exception:
+            data = {}
+    if not isinstance(data, dict):
+        data = {}
+
+    selected = data.get("sources")
+    if not isinstance(selected, list):
+        selected = list(all_keys)
+    selected = [k for k in selected if k in all_keys]
+
+    port = data.get("port")
+    if not isinstance(port, int) or isinstance(port, bool) \
+            or not (1 <= port <= 65535):
+        port = DEFAULT_PORT
+    return selected, port
+
+
+def save(selected):
+    """Persist the source selection, preserving any other stored keys."""
+    data = {}
+    path = config_path()
+    if path.exists():
+        try:
+            data = json.loads(path.read_text("utf-8"))
+        except Exception:
+            data = {}
+    if not isinstance(data, dict):
+        data = {}
+
+    data["sources"] = list(selected)
+    config_dir().mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n", "utf-8")
+    try:                                    # POSIX only; Windows ignores it
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+    return path