freeflix-cli 2.4.0__tar.gz → 2.4.1__tar.gz

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 2.4.1
+
+- **Match : une seule ligne par affiche**. Le catalogue répétait un même
+  match sur plusieurs créneaux (un « Twente - Ajax » en direct alors qu'un
+  autre du même jour était déjà terminé). Une entrée live/à venir/terminée
+  par match, la plus utile gagne.
+- **Bascule automatique de source** : un match en direct expose désormais
+  HD, SD, Low et des flux **Multi**. Si la qualité choisie est refusée par
+  le CDN, FreeFlix essaie les autres sources au lieu de s'arrêter.
+- **Contrôle avant lecture fiable** : le préflight passe par **ffmpeg en
+  direct** (comme la lecture) et lit sa sortie en continu. Le proxy local
+  déclenchait des 404 anti-hotlink et un live qui joue « sans fin » était
+  pris pour une panne — les deux sont corrigés. Les erreurs sont
+  distinguées : `403` (serveur qui refuse) vs `404/invalid data` (flux sans
+  données).
+- **Multi en tête** : les flux « Multi » passent avant HD/SD/Low (source la
+  plus fiable en direct) ; tri stable, ordre du catalogue conservé à
+  qualité égale.
+- Proxy HLS : rafraîchissement automatique de la playlist quand un segment
+  devient introuvable.
+- 618 tests au vert, ruff OK.
+
 ## 2.4.0
 
 - **Match regroupé par statut** : sections `En direct (n)`, `À venir (n)`,

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freeflix-cli
-Version: 2.4.0
+Version: 2.4.1
 Summary: Watch movies, series, and anime from your terminal — multi-language, multi-source, no browser required. A maintained fork of autoflix-cli.
 Project-URL: Homepage, https://github.com/freedy237/freeflix-cli
 Project-URL: Repository, https://github.com/freedy237/freeflix-cli.git

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "freeflix-cli"
-version = "2.4.0"
+version = "2.4.1"
 description = "Watch movies, series, and anime from your terminal — multi-language, multi-source, no browser required. A maintained fork of autoflix-cli."
 readme = "README.md"
 requires-python = ">=3.9.2"

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/src/freeflix_cli/handlers/match.py

@@ -81,6 +81,52 @@ def _sort_events(events: list[ym.MatchEvent], now_ts: int) -> list[ym.MatchEvent
     return sorted(events, key=lambda e: (order.get(e.status(now_ts), 3), e.start))
 
 
+def _dedupe(events: list[ym.MatchEvent], now_ts: int) -> list[ym.MatchEvent]:
+    """One row per fixture: the catalogue repeats some matches across
+    channels and time slots (a live "Twente - Ajax" while an older
+    "Twente - Ajax" of the same channel is already finished).
+
+    The most useful entry wins: live > upcoming > finished, then the nearest
+    kick-off to now. Every channel showing the fixture is kept in a side map
+    so the row can still show where else to watch it.
+    """
+    rank = {"live": 0, "upcoming": 1, "ended": 2}
+    best: dict[tuple, ym.MatchEvent] = {}
+    for ev in events:
+        key = (
+            re.sub(r"\s+", " ", (ev.home or "").strip().lower()),
+            re.sub(r"\s+", " ", (ev.away or "").strip().lower()),
+        )
+        if not key[0] or not key[1]:
+            continue
+        cur = best.get(key)
+        if cur is None:
+            best[key] = ev
+            continue
+        new_rank = (rank.get(ev.status(now_ts), 3), abs(ev.start - now_ts))
+        cur_rank = (rank.get(cur.status(now_ts), 3), abs(cur.start - now_ts))
+        if new_rank < cur_rank:
+            best[key] = ev
+    return list(best.values())
+
+
+def _channels_for(events: list[ym.MatchEvent]) -> dict[tuple, list[str]]:
+    """All channels broadcasting a given fixture pair (deduplicated)."""
+    out: dict[tuple, list[str]] = {}
+    for ev in events:
+        key = (
+            re.sub(r"\s+", " ", (ev.home or "").strip().lower()),
+            re.sub(r"\s+", " ", (ev.away or "").strip().lower()),
+        )
+        if not ev.channel:
+            continue
+        bucket = out.setdefault(key, [])
+        label = _channel_label(ev.channel)
+        if label and label not in bucket:
+            bucket.append(label)
+    return out
+
+
 _GROUP_ICONS = {"live": "fire", "upcoming": "clock", "ended": "check"}
 
 
@@ -184,20 +230,37 @@ def _quality_label(stream: dict) -> str:
             f"~{gb:.2f} {t('GB/h')}")
 
 
-def _play(event: ym.MatchEvent, stream: dict, player_name: str = "") -> None:
+def _play(event: ym.MatchEvent, stream: dict, player_name: str = "",
+          alternatives: list = None) -> None:
+    """Play `stream`, falling back to another source if it is dead.
+
+    A live fixture now ships several sources (HD, SD, Low, Multi…). The main
+    quality can be refused by the CDN while "Multi" works, so never give up
+    on the first failure: walk the remaining sources and pick the first one
+    that actually answers.
+    """
     from ..player_manager import match_stream_reachable, play_direct_stream
 
     title = f"YacineTV · {event.home}  VS  {event.away}"
-    print_info(f"{t('Selected quality:')} {stream.get('name', '?')}")
-    ok, why = match_stream_reachable(stream["url"], stream.get("headers") or {})
-    if not ok:
-        print_warning(f"{t('Cannot play this match:')} {why}")
-        print_info(t("This channel is often blocked or taken down; try another match."))
-        return
-    ok = play_direct_stream(stream["url"], stream.get("headers") or {}, title,
-                            player_name=player_name or None)
-    if not ok:
-        print_warning(t("Could not start the match stream."))
+    queue = [stream] + [s for s in (alternatives or [])
+                        if s is not stream and s.get("url") != stream.get("url")]
+    for i, cand in enumerate(queue):
+        name = cand.get("name", "?")
+        if i == 0:
+            print_info(f"{t('Selected quality:')} {name}")
+        else:
+            print_info(f"{t('Trying another source:')} {name}")
+        ok, why = match_stream_reachable(cand["url"], cand.get("headers") or {})
+        if not ok:
+            if i == 0:
+                print_warning(f"{t('Cannot play this match:')} {why}")
+            continue
+        ok = play_direct_stream(cand["url"], cand.get("headers") or {}, title,
+                                player_name=player_name or None)
+        if ok:
+            return
+    print_warning(t("Could not start the match stream."))
+    print_info(t("This channel is often blocked or taken down; try another match."))
 
 
 def _available_players() -> list[str]:
@@ -266,7 +329,7 @@ def handle_match() -> None:
 
         now = datetime.now(tz=_CAM)
         now_ts = int(now.timestamp())
-        ordered = _sort_events(events, now_ts)
+        ordered = _sort_events(_dedupe(events, now_ts), now_ts)
         player_name = _current_player()
         # Group by status with section headers so the rows line up in
         # columns; "finished" stays collapsed at the bottom.
@@ -326,11 +389,11 @@ def handle_match() -> None:
                            f"{t('GB/h')}")
                 chosen = _choose_player(player_name, allow_cancel=True)
                 if chosen:
-                    _play(event, stream, chosen)
+                    _play(event, stream, chosen, streams)
             else:
                 return
             continue
 
         chosen = _choose_player(player_name, allow_cancel=True)
         if chosen:
-            _play(event, streams[choice], chosen)
+            _play(event, streams[choice], chosen, streams)

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/src/freeflix_cli/i18n.py

@@ -1026,9 +1026,12 @@ _FR = {
     'LIVE now': 'En direct',
     'Channel server unreachable (DNS).':
         'Serveur de la chaîne injoignable (DNS).',
+    'The stream has no data (offline).':
+        'Le flux ne diffuse aucune donnée (hors ligne).',
     'Channel server refused the stream.':
         'Le serveur de la chaîne refuse le flux.',
     'Cannot play this match:': 'Impossible de lire ce match :',
+    'Trying another source:': 'Essai d’une autre source :',
     'This channel is often blocked or taken down; try another match.':
         'Cette chaîne est souvent bloquée ou retirée ; essaie un autre match.',
     'Mbps': 'Mbps',

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/src/freeflix_cli/install_health.py

@@ -13,7 +13,7 @@ import os
 import sys
 
 # Version BAKED INTO THE CODE — bump together with pyproject.toml.
-CODE_VERSION = "2.4.0"
+CODE_VERSION = "2.4.1"
 
 
 def metadata_version() -> str | None:

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/src/freeflix_cli/player_manager.py

@@ -2816,15 +2816,95 @@ def match_stream_reachable(stream_url: str, headers: dict,
             socket.getaddrinfo(host, 443, proto=socket.IPPROTO_TCP)
     except Exception:
         return False, t("Channel server unreachable (DNS).")
+    # Probe with ffmpeg DIRECTLY (same path as playback): the CDN pins some
+    # feeds to the client that opened the playlist, so going through our
+    # local proxy reported "offline" for streams that actually play.
+    ffmpeg = shutil.which("ffmpeg")
+    if ffmpeg:
+        hdr = "".join(
+            f"{k}: {str(v).replace(chr(13), ' ').replace(chr(10), ' ')}\r\n"
+            for k, v in (headers or {}).items() if v)
+        cmd = [ffmpeg, "-hide_banner", "-loglevel", "error", "-headers", hdr,
+               "-allowed_segment_extensions", "ALL", "-extension_picky", "0",
+               "-rw_timeout", str(max(4, timeout) * 1000000),
+               "-analyzeduration", "3000000", "-probesize", "1000000",
+               # Live playlists never end: bound the read so the probe cannot
+               # hang on a continuous stream (-t BEFORE -i is an input cap).
+               "-t", "4", "-i", stream_url,
+               "-t", "1", "-f", "null", "-"]
+        # IMPORTANT: a live playlist may play forever, so "no exit" is a
+        # best-case result, not a failure. Read stderr while it runs and stop
+        # as soon as the verdict is known.
+        try:
+            proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.PIPE, text=True,
+                                    errors="replace")
+        except Exception:
+            proc = None
+        if proc is not None:
+            deadline = time.time() + max(8, timeout + 4)
+            lines: list[str] = []
+            verdict = None
+            try:
+                import select as _select
+                while time.time() < deadline:
+                    ready, _, _ = _select.select([proc.stderr], [], [], 0.2)
+                    if not ready:
+                        continue
+                    line = proc.stderr.readline()
+                    if not line:
+                        break
+                    lines.append(line.strip())
+                    blob = " ".join(lines).lower()
+                    if "403 forbidden" in blob:
+                        verdict = ("refused", t("Channel server refused the stream."))
+                        break
+                    if any(k in blob for k in ("detected", "video:", "audio:",
+                                               "frame=", "stream #")):
+                        verdict = ("ok", "")
+                        break
+                    if "invalid data" in blob or "404" in blob:
+                        verdict = ("empty", t("The stream has no data (offline)."))
+                        break
+            finally:
+                try:
+                    proc.terminate()
+                    proc.wait(timeout=3)
+                except Exception:
+                    try:
+                        proc.kill()
+                    except Exception:
+                        pass
+            if verdict:
+                if verdict[0] == "ok":
+                    return True, ""
+                return False, verdict[1]
+            # No verdict in time: the stream keeps flowing (live) → playable.
+            if proc.returncode in (0, None) or proc.returncode == -15:
+                return True, ""
+            return False, t("The stream has no data (offline).")
+
     try:
         from .yacine_live_proxy import start_live_proxy
         proxy, local = start_live_proxy(stream_url, headers or {})
         try:
             import urllib.request
             with urllib.request.urlopen(local, timeout=timeout) as r:
-                body = r.read(200)
-            if b"#EXTM3U" not in body and b"#EXT-X" not in body:
+                body = r.read()
+            text = body.decode("utf-8", "replace")
+            if "#EXTM3U" not in text and "#EXT-X" not in text:
                 return False, t("Channel server refused the stream.")
+            segs = [ln.strip() for ln in text.splitlines()
+                    if ln.strip() and not ln.startswith("#")]
+            if segs and segs[0].startswith("/p/"):
+                base = f"http://127.0.0.1:{proxy.httpd.server_address[1]}"
+                try:
+                    with urllib.request.urlopen(base + segs[-1],
+                                                timeout=timeout) as seg:
+                        if not seg.read(64):
+                            return False, t("The stream has no data (offline).")
+                except Exception:
+                    return False, t("The stream has no data (offline).")
             return True, ""
         finally:
             proxy.stop()
@@ -2860,10 +2940,11 @@ def play_direct_stream(stream_url: str, headers: dict, title: str,
         if not exe:
             print_error(t("mpv is not installed or not in PATH."))
             return False
+        # Direct ffmpeg pipe first: the CDN answers 404 when the playlist is
+        # relayed through the local proxy, but serves ffmpeg directly.
         if shutil.which("ffmpeg") and _play_ffmpeg_pipe(
                 exe, stream_url, headers, title):
             return True
-        # No ffmpeg (or pipe failed): fall back to the local HLS proxy.
         proxy, local_url = start_live_proxy(stream_url, headers)
         try:
             return _play_dash_mpv(exe, local_url, {}, title, live=True)

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/src/freeflix_cli/scraping/yacine_match.py

@@ -246,10 +246,14 @@ def fetch_events(timeout: int = 10) -> tuple[list[MatchEvent], bool]:
 
 def _quality_rank(name: str) -> int:
     n = (name or "").lower()
+    # "Multi" sources are official multi-camera feeds: usually the most
+    # reliable live source when the per-quality CDN is throttled.
+    if "multi" in n:
+        return 3
     if any(k in n for k in ("4k", "2160", "uhd")):
-        return 4
+        return 5
     if any(k in n for k in ("1440", "2k")):
-        return 3
+        return 4
     if any(k in n for k in ("hd", "fhd", "1080", "full")):
         return 3
     if any(k in n for k in ("sd", "720", "medium")):
@@ -293,7 +297,12 @@ def fetch_streams(event_id: str, timeout: int = 10) -> list[dict]:
             streams = [s for s in (_stream_from_dict(r) for r in (raw or []))
                        if s and not s.get("drm")]
             if streams:
-                streams.sort(key=lambda s: _quality_rank(s["name"]), reverse=True)
+                # Stable sort: rank first, then keep the catalogue order.
+                # "Multi" feeds come first (most reliable live source),
+                # HD/SD/Low after them.
+                order = {id(s): i for i, s in enumerate(streams)}
+                streams.sort(
+                    key=lambda s: (-_quality_rank(s["name"]), order[id(s)]))
                 return streams
         except Exception as exc:  # noqa: BLE001
             last_err = exc

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/src/freeflix_cli/yacine_live_proxy.py

@@ -66,6 +66,33 @@ class _LiveProxy:
             raise RuntimeError(f"upstream HTTP {code}")
         return conn, resp
 
+    def _refresh_playlist_items(self) -> None:
+        """Re-fetch the upstream playlist and re-map the MOST RECENT segments.
+
+        Some CDNs answer 404 for a segment that was valid when the playlist
+        was fetched. The live playlist keeps moving, so the newest segments
+        almost always work: drop the old mappings and rebuild them from a
+        fresh fetch before giving up on a 404.
+        """
+        try:
+            conn, resp = self._request(self.playlist_url, self.headers)
+            try:
+                text = resp.read().decode("utf-8", "replace")
+            finally:
+                conn.close()
+        except Exception:
+            return
+        segs = [ln.strip() for ln in text.splitlines()
+                if ln.strip() and not ln.startswith("#")]
+        if not segs:
+            return
+        base = self.playlist_url
+        for old, (_url, kind) in list(self.items.items()):
+            if kind == "segment":
+                self.items.pop(old, None)
+        for ln in segs[-6:]:
+            self._register(urllib.parse.urljoin(base, ln), "segment")
+
     def _register(self, url: str, kind: str) -> str:
         self._counter += 1
         key = f"{self._counter}.{'m3u8' if kind == 'playlist' else 'ts'}"
@@ -148,7 +175,16 @@ class _LiveProxy:
                         self.end_headers()
                         self.wfile.write(data)
                         return
-                    conn, resp = outer._request(url, outer.headers)
+                    try:
+                        conn, resp = outer._request(url, outer.headers)
+                    except Exception:
+                        # Stale segment id: rebuild from the fresh playlist.
+                        outer._refresh_playlist_items()
+                        newest = [u for u, k in reversed(list(outer.items.values()))
+                                  if k == "segment"]
+                        if not newest or newest[0] == url:
+                            raise
+                        conn, resp = outer._request(newest[0], outer.headers)
                     try:
                         self.send_response(200)
                         # Upstream labels segments as application/pdf; VLC's

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/tests/test_yacine_match.py

@@ -398,7 +398,28 @@ def test_match_stream_reachable_reports_dns_failure(monkeypatch):
     assert ok is False and why
 
 
+_TS_FIXTURE = ""
+
+
+def _make_ts_fixture(path):
+    """Tiny real MPEG-TS so ffmpeg can decode at least one frame."""
+    import shutil as _sh
+    import subprocess
+
+    if not _sh.which("ffmpeg"):
+        return False
+
+    subprocess.run(
+        ["ffmpeg", "-y", "-v", "error", "-f", "lavfi", "-i",
+         "testsrc=size=64x64:rate=5", "-f", "lavfi", "-i",
+         "sine=frequency=440", "-t", "2", "-c:v", "libx264",
+         "-preset", "ultrafast", "-c:a", "aac", "-f", "mpegts", path],
+        check=True, timeout=60)
+    return True
+
+
 def test_match_stream_reachable_true_for_local_manifest(monkeypatch, tmp_path):
+
     import http.server
     import threading
     from freeflix_cli import player_manager as pm
@@ -408,13 +429,19 @@ def test_match_stream_reachable_true_for_local_manifest(monkeypatch, tmp_path):
             pass
 
         def do_GET(self):
-            body = b"#EXTM3U\n#EXTINF:6,\nseg.ts\n"
+            if "seg" in self.path:
+                body = b"\x47" * 188
+            else:
+                body = b"#EXTM3U\n#EXT-X-TARGETDURATION:6\n#EXTINF:6,\nseg.ts\n"
             self.send_response(200)
             self.send_header("Content-Type", "application/vnd.apple.mpegurl")
             self.send_header("Content-Length", str(len(body)))
             self.end_headers()
             self.wfile.write(body)
 
+    # CI runners have no ffmpeg: force the proxy fallback path.
+    monkeypatch.setattr(pm.shutil, "which",
+                        lambda name: None if name == "ffmpeg" else "x")
     srv = http.server.ThreadingHTTPServer(("127.0.0.1", 0), H)
     threading.Thread(target=srv.serve_forever, daemon=True).start()
     port = srv.server_address[1]
@@ -425,3 +452,91 @@ def test_match_stream_reachable_true_for_local_manifest(monkeypatch, tmp_path):
     finally:
         srv.shutdown()
         srv.server_close()
+
+
+def test_dedupe_prefers_live_fixture_over_finished_copy():
+    """The catalogue repeats fixtures; one row must be shown, the live one."""
+    import time
+    from freeflix_cli.handlers import match as mh
+
+    now = int(time.time())
+    finished = ym.MatchEvent("old", "NED", "Dubai Sports 1",
+                             now - 7200, now - 5400, "Twente", "Ajax")
+    live = ym.MatchEvent("new", "NED", "Dubai Sports 1",
+                         now - 600, now + 6600, "Twente", "Ajax")
+    other = ym.MatchEvent("o", "FRA", "beIN SPORTS 1",
+                          now - 600, now + 6600, "Lens", "Marseille")
+    kept = mh._dedupe([finished, live, other], now)
+    assert len(kept) == 2
+    twente = [e for e in kept if e.home == "Twente"][0]
+    assert twente.id == "new" and twente.status(now) == "live"
+
+
+def test_dedupe_never_lists_one_fixture_in_two_statuses():
+    import time
+    from freeflix_cli.handlers import match as mh
+
+    now = int(time.time())
+    events = [
+        ym.MatchEvent("a", "L", "C1", now - 8000, now - 7000, "A", "B"),
+        ym.MatchEvent("b", "L", "C2", now - 60, now + 7000, "A", "B"),
+        ym.MatchEvent("c", "L", "C1", now + 9000, now + 16000, "A", "B"),
+    ]
+    kept = mh._dedupe(events, now)
+    assert len(kept) == 1
+    assert kept[0].status(now) == "live"
+
+
+def test_preflight_rejects_manifest_with_dead_segments(monkeypatch):
+    """A playlist whose segments 404 must not open a player."""
+    import http.server
+    import threading
+    from freeflix_cli import player_manager as pm
+
+    class H(http.server.BaseHTTPRequestHandler):
+        def log_message(self, *a):
+            pass
+
+        def do_GET(self):
+            if "seg" in self.path:
+                self.send_response(404)
+                self.end_headers()
+                return
+            body = b"#EXTM3U\n#EXTINF:6,\nseg.ts\n"
+            self.send_response(200)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+    monkeypatch.setattr(pm.shutil, "which",
+                        lambda name: None if name == "ffmpeg" else "x")
+    srv = http.server.ThreadingHTTPServer(("127.0.0.1", 0), H)
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+    try:
+        ok, why = pm.match_stream_reachable(
+            f"http://127.0.0.1:{srv.server_address[1]}/live/index.m3u8", {})
+        assert ok is False
+        assert why
+    finally:
+        srv.shutdown()
+        srv.server_close()
+
+
+def test_play_falls_back_to_another_source(monkeypatch):
+    """When the chosen quality is dead, the next source is tried."""
+    from freeflix_cli.handlers import match as mh
+    from freeflix_cli import player_manager
+
+    ev = ym.MatchEvent("1", "L", "beIN SPORTS 1", 1, 2, "A", "B")
+    hd = {"name": "HD", "url": "https://dead.example/hd.m3u8", "headers": {}}
+    multi = {"name": "Multi", "url": "https://ok.example/m.m3u8", "headers": {}}
+    results = {"https://dead.example/hd.m3u8": (False, "dead"),
+               "https://ok.example/m.m3u8": (True, "")}
+    monkeypatch.setattr(player_manager, "match_stream_reachable",
+                        lambda url, h: results[url])
+    played = []
+    monkeypatch.setattr(player_manager, "play_direct_stream",
+                        lambda url, h, title, player_name=None:
+                        played.append(url) or True)
+    mh._play(ev, hd, "mpv", [hd, multi])
+    assert played == ["https://ok.example/m.m3u8"]

{freeflix_cli-2.4.0 → freeflix_cli-2.4.1}/uv.lock

@@ -238,7 +238,7 @@ wheels = [
 
 [[package]]
 name = "freeflix-cli"
-version = "2.4.0"
+version = "2.4.1"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },