donghua-cli 3.2.0__tar.gz → 3.2.1__tar.gz

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/.github/workflows/publish.yml

@@ -30,7 +30,10 @@ jobs:
         env:
           TWINE_USERNAME: __token__
           TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-        run: twine upload dist/*
+        # --skip-existing makes re-runs idempotent: if a tag is re-pushed
+        # to recover from a downstream failure, twine treats "file already
+        # exists" as success instead of failing the whole pipeline.
+        run: twine upload --skip-existing dist/*
 
       - name: Bump AUR / Homebrew / Scoop formulas
         # Runs after PyPI upload so the sdist hash matches what users install.

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to Donghua CLI will be documented in this file.
 
+## [3.2.1] - 2026-06-22
+
+### Fixed
+- **mpv process leak on auto-next.** The TUI kept no handle on the running player, so Next / Replay / auto-next launched a fresh mpv without stopping the previous one — leaking processes, audio, and IPC sockets, and stranding `wait_for_end` threads. The playback screen now holds the active player, stops it before each new playback, tears it down on screen exit, and uses a per-playback generation tag so a superseded worker never fires auto-next. `wait_for_end` binds the process locally so a concurrent `stop()` can't crash its poll loop.
+- **`geo.dailymotion.com` embeds played as HTML and died in <1s.** Canonicalization only handled the legacy `/embed/video/<id>` path; modern aggregators hand over `geo.dailymotion.com/player/<pid>.html?video=<id>` (id in a query param, no `/video/` in the path). Every embed/geo/player form now collapses to the canonical `https://www.dailymotion.com/video/<id>`.
+
 ## [3.2.0] - 2026-05-21
 
 ### Added

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: donghua-cli
-Version: 3.2.0
+Version: 3.2.1
 Summary: Wuxia-themed terminal client for streaming Chinese animation
 License-Expression: MIT
 License-File: LICENSE

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/packaging/aur/PKGBUILD

@@ -15,7 +15,7 @@ optdepends=(
     'ffmpeg: required by yt-dlp for merging streams'
 )
 source=("https://files.pythonhosted.org/packages/source/d/${pkgname}/${pkgname//-/_}-${pkgver}.tar.gz")
-sha256sums=('UPDATE_WITH_ACTUAL_SHA256')
+sha256sums=('fc6f2a9d1fb1542ca8f616963fdf18ef49cb363982feece6989aa432f4d0b9c8')
 
 build() {
     cd "${pkgname//-/_}-${pkgver}"

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/packaging/homebrew/donghua-cli.rb

@@ -4,8 +4,8 @@ class DonghuaCli < Formula
   desc "Wuxia-themed terminal client for streaming Chinese animation"
   homepage "https://github.com/Thanukamax/donghua-cli"
   # Update URL and sha256 on each release
-  url "https://files.pythonhosted.org/packages/source/d/donghua-cli/donghua_cli-3.2.0.tar.gz"
-  sha256 "UPDATE_WITH_ACTUAL_SHA256"
+  url "https://files.pythonhosted.org/packages/21/2d/3ca89831268b8c9348f3c95fee40e5ddd5d3e3584306d60966802bd9d7ee/donghua_cli-3.2.0.tar.gz"
+  sha256 "fc6f2a9d1fb1542ca8f616963fdf18ef49cb363982feece6989aa432f4d0b9c8"
   license "MIT"
 
   depends_on "python@3.12"

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "donghua-cli"
-version = "3.2.0"
+version = "3.2.1"
 description = "Wuxia-themed terminal client for streaming Chinese animation"
 readme = "README.md"
 license = "MIT"

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/scripts/release-prep.sh

@@ -12,28 +12,42 @@ set -euo pipefail
 cd "$(dirname "$0")/.."
 
 VERSION="${1:-$(python3 -c 'import re,sys; print(re.search(r"\"([^\"]+)\"", open("src/donghua_cli/__init__.py").read()).group(1))')}"
-SDIST_URL="https://files.pythonhosted.org/packages/source/d/donghua-cli/donghua_cli-${VERSION}.tar.gz"
 
-echo "Fetching sdist for v${VERSION}..."
-tmp="$(mktemp)"
-trap 'rm -f "$tmp"' EXIT
+# PyPI no longer reliably serves files at the legacy /packages/source/d/<pkg>/
+# path from every CDN edge; use the JSON API to discover the canonical sdist
+# URL + sha256 directly. Propagation can lag a few seconds after twine upload.
+echo "Looking up PyPI metadata for v${VERSION}..."
 
-# PyPI propagation can lag a few seconds after twine upload returns.
-for i in 1 2 3 4 5 6; do
-    if curl -sfL "$SDIST_URL" -o "$tmp"; then
+JSON_URL="https://pypi.org/pypi/donghua-cli/${VERSION}/json"
+SDIST_URL=""
+SHA=""
+
+for i in 1 2 3 4 5 6 7 8; do
+    METADATA="$(curl -sf "$JSON_URL" || true)"
+    if [[ -n "$METADATA" ]]; then
+        read -r SDIST_URL SHA <<<"$(printf '%s' "$METADATA" | python3 -c '
+import json, sys
+d = json.load(sys.stdin)
+for u in d.get("urls", []):
+    if u.get("packagetype") == "sdist":
+        print(u["url"], u["digests"]["sha256"])
         break
+')"
+        if [[ -n "$SDIST_URL" && -n "$SHA" ]]; then
+            break
+        fi
     fi
     echo "  waiting for PyPI (attempt $i)..."
     sleep 5
 done
 
-if [[ ! -s "$tmp" ]]; then
-    echo "ERROR: couldn't fetch $SDIST_URL after retries." >&2
+if [[ -z "$SDIST_URL" || -z "$SHA" ]]; then
+    echo "ERROR: couldn't find sdist for donghua-cli ${VERSION} on PyPI after retries." >&2
     exit 1
 fi
 
-SHA=$(sha256sum "$tmp" | cut -d' ' -f1)
-echo "sha256: $SHA"
+echo "  sdist:  $SDIST_URL"
+echo "  sha256: $SHA"
 
 # AUR PKGBUILD
 sed -i "s/^pkgver=.*/pkgver=${VERSION}/" packaging/aur/PKGBUILD

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/src/donghua_cli/__init__.py

@@ -1,3 +1,3 @@
 """Donghua CLI - Wuxia-themed terminal client for streaming Chinese animation."""
 
-__version__ = "3.2.0"
+__version__ = "3.2.1"

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/src/donghua_cli/extractor.py

@@ -70,11 +70,23 @@ def _canonicalize(url: str) -> str:
 
     url = _normalise_scheme(url)
 
-    # Dailymotion: /embed/video/<id>[?…] → /video/<id>
-    if "dailymotion.com/embed/video/" in url:
-        url = url.replace("/embed/video/", "/video/")
-        if "?" in url:
-            url = url.split("?", 1)[0]
+    # Dailymotion: collapse EVERY embed/geo/player form to the canonical
+    # https://www.dailymotion.com/video/<id> that yt-dlp's extractor pins. The
+    # legacy /embed/video/<id> path is easy, but modern aggregators hand over the
+    # geo player form geo.dailymotion.com/player/<pid>.html?video=<id> — there's
+    # no /video/ in the path, so the old substring check missed it and mpv tried
+    # to demux the player HTML and died in <1s.
+    if "dailymotion." in url:
+        vid = None
+        m = re.search(r"[?&]video=([A-Za-z0-9]+)", url)  # player.html?video=<id>
+        if m:
+            vid = m.group(1)
+        else:
+            m = re.search(r"dailymotion\.com/(?:embed/)?video/([A-Za-z0-9]+)", url)
+            if m:
+                vid = m.group(1)
+        if vid:
+            url = f"https://www.dailymotion.com/video/{vid}"
 
     # ok.ru: /videoembed/<id> → /video/<id>
     if "ok.ru/videoembed/" in url:

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/src/donghua_cli/player.py

@@ -51,15 +51,15 @@ class Player:
         user-quit). Returns False if there was no live player to begin with.
         Safe to call repeatedly.
         """
-        if self._process is None:
+        # Bind the process locally: a concurrent stop() (e.g. the user pressed
+        # Next before this episode ended) sets self._process = None, which would
+        # otherwise NoneType-crash the poll loop here.
+        proc = self._process
+        if proc is None:
             return False
-        while self._process.poll() is None:
+        while proc.poll() is None:
             time.sleep(poll_interval)
-        if self._ipc_path and os.path.exists(self._ipc_path):
-            try:
-                os.unlink(self._ipc_path)
-            except OSError:
-                pass
+        self._cleanup_socket()
         return True
 
     def stop(self) -> None:
@@ -73,6 +73,18 @@ class Player:
             except OSError:
                 pass
         self._process = None
+        # Reap the IPC socket too — without this, every superseded player leaks
+        # a stale socket file in tmp until reboot.
+        self._cleanup_socket()
+
+    def _cleanup_socket(self) -> None:
+        """Remove the IPC socket file if it's still on disk. Idempotent."""
+        if self._ipc_path and os.path.exists(self._ipc_path):
+            try:
+                os.unlink(self._ipc_path)
+            except OSError:
+                pass
+        self._ipc_path = None
 
     def is_playing(self) -> bool:
         return self._process is not None and self._process.poll() is None

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/src/donghua_cli/tui.py

@@ -12,6 +12,7 @@ Screens:
 from __future__ import annotations
 
 import random
+import threading
 from typing import TYPE_CHECKING
 
 from textual import on, work
@@ -35,6 +36,7 @@ from donghua_cli.palette import GLYPH, PALETTE
 from donghua_cli.theme import TECHNIQUES, level_for_episode
 
 if TYPE_CHECKING:
+    from donghua_cli.player import Player
     from donghua_cli.sources.base import Episode, Series
 
 # Banner technique is pinned for the lifetime of the app — never reshuffles
@@ -798,6 +800,12 @@ class PlaybackScreen(Screen):
             self._series_urls = dict(series.urls)
         self._stream_url = ""
         self._server_name = ""
+        # The currently-live player, so a new playback (Next / Replay / auto-next)
+        # can tear the old mpv down instead of leaking it. _play_gen tags each
+        # playback; a superseded worker checks it and bows out without advancing.
+        self._active_player: "Player | None" = None
+        self._play_gen = 0
+        self._play_lock = threading.Lock()
 
     def compose(self) -> ComposeResult:
         with Container(id="np-outer"):
@@ -910,7 +918,17 @@ class PlaybackScreen(Screen):
         from donghua_cli.player import Player
         from donghua_cli.sources.base import Series
 
+        # Tear down whatever was playing before starting the next one, and tag
+        # this playback. Without this, pressing Next/Replay while mpv is still
+        # open spawns a second mpv and strands the old wait_for_end thread.
         player = Player(self._core._quality)
+        with self._play_lock:
+            previous = self._active_player
+            self._play_gen += 1
+            gen = self._play_gen
+            self._active_player = player
+        if previous is not None:
+            previous.stop()
         title = f"{self._series_title} - Episode {ep.number}"
 
         if player.play(stream_url, title=title):
@@ -943,6 +961,11 @@ class PlaybackScreen(Screen):
                 import time as _time
                 started_playback = _time.time()
                 player.wait_for_end()
+                # If a newer playback superseded us (user hit Next, or another
+                # auto-next already fired), our stop() woke wait_for_end early —
+                # don't advance or report failure on this stale worker.
+                if gen != self._play_gen:
+                    return
                 elapsed = _time.time() - started_playback
                 if elapsed < 30:
                     self.app.call_from_thread(
@@ -979,6 +1002,16 @@ class PlaybackScreen(Screen):
             self.current_idx += 1
             self._play_current()
 
+    def on_unmount(self) -> None:
+        # Leaving playback (Quit / back) must kill the live mpv + its socket,
+        # otherwise it keeps playing detached after the TUI screen is gone.
+        with self._play_lock:
+            self._play_gen += 1  # invalidate any in-flight wait_for_end worker
+            player = self._active_player
+            self._active_player = None
+        if player is not None:
+            player.stop()
+
     def action_next_ep(self) -> None:
         if self.current_idx < len(self._episodes) - 1:
             self.current_idx += 1

{donghua_cli-3.2.0 → donghua_cli-3.2.1}/tests/test_extractor.py

@@ -18,6 +18,19 @@ class TestCanonicalize:
         url = "https://www.dailymotion.com/video/k3fOeWYJYDH5DVybIIp"
         assert _canonicalize(url) == url
 
+    def test_dailymotion_geo_player_html_collapses_to_video(self):
+        # Modern aggregator embed: no /video/ in the path, id is a query param.
+        url = "https://geo.dailymotion.com/player/xabcd.html?video=k5abc123&mute=true"
+        assert _canonicalize(url) == "https://www.dailymotion.com/video/k5abc123"
+
+    def test_dailymotion_geo_embed_video_collapses_to_www(self):
+        url = "https://geo.dailymotion.com/embed/video/k9zzz?autoplay=1"
+        assert _canonicalize(url) == "https://www.dailymotion.com/video/k9zzz"
+
+    def test_dailymotion_protocol_relative_geo_player(self):
+        url = "//geo.dailymotion.com/player/x1234.html?video=kPqR9"
+        assert _canonicalize(url) == "https://www.dailymotion.com/video/kPqR9"
+
     def test_ok_ru_embed_becomes_https_video(self):
         assert _canonicalize("//ok.ru/videoembed/6816742902324") == "https://ok.ru/video/6816742902324"
 

donghua_cli-3.2.1/tests/test_player.py

@@ -0,0 +1,96 @@
+"""Tests for the Player lifecycle — process + IPC socket teardown.
+
+These cover the v3.2.1 auto-next leak fix: a superseded player must release its
+mpv process and IPC socket, and wait_for_end must survive a concurrent stop()
+that nulls the process reference (which is what Next / Replay / auto-next do).
+"""
+
+import os
+import tempfile
+import threading
+import time
+
+from donghua_cli.player import Player
+
+
+class _FakeProc:
+    """Stand-in for subprocess.Popen: stays alive for `alive_polls` poll() calls,
+    then reports the exit code set by terminate()/kill() (or 0)."""
+
+    def __init__(self, alive_polls: int = 0):
+        self._remaining = alive_polls
+        self._code: int | None = None
+        self.terminated = False
+        self.killed = False
+
+    def poll(self):
+        if self._remaining > 0:
+            self._remaining -= 1
+            return None
+        return self._code if self._code is not None else 0
+
+    def terminate(self):
+        self.terminated = True
+        self._code = -15
+
+    def kill(self):
+        self.killed = True
+        self._code = -9
+
+    def wait(self, timeout=None):
+        return self._code or 0
+
+
+def _make_socket_file() -> str:
+    fd, path = tempfile.mkstemp(prefix="dhua-test-", suffix=".sock")
+    os.close(fd)
+    return path
+
+
+class TestPlayerTeardown:
+    def test_wait_for_end_no_process_returns_false(self):
+        assert Player(quality="720").wait_for_end() is False
+
+    def test_stop_unlinks_ipc_socket_and_clears_state(self):
+        p = Player(quality="720")
+        sock = _make_socket_file()
+        p._ipc_path = sock
+        p._process = _FakeProc(alive_polls=1)
+        assert os.path.exists(sock)
+        p.stop()
+        assert not os.path.exists(sock)
+        assert p._process is None
+        assert p._ipc_path is None
+
+    def test_stop_is_idempotent_with_no_process(self):
+        p = Player(quality="720")
+        p.stop()  # must not raise
+        p.stop()
+
+    def test_wait_for_end_cleans_socket_on_natural_exit(self):
+        p = Player(quality="720")
+        sock = _make_socket_file()
+        p._ipc_path = sock
+        p._process = _FakeProc(alive_polls=0)  # already exited
+        assert p.wait_for_end(poll_interval=0.01) is True
+        assert not os.path.exists(sock)
+
+    def test_wait_for_end_survives_concurrent_stop(self):
+        # The core auto-next race: a newer playback stops this player (nulling
+        # self._process) while wait_for_end is mid-poll. Binding the process
+        # locally must keep this from NoneType-crashing the poll loop.
+        p = Player(quality="720")
+        p._ipc_path = _make_socket_file()
+        proc = _FakeProc(alive_polls=50)
+        p._process = proc
+
+        def supersede():
+            time.sleep(0.02)
+            p._process = None      # what stop() does to the shared reference
+            proc._code = -15       # ...after terminating the underlying process
+            proc._remaining = 0
+
+        t = threading.Thread(target=supersede)
+        t.start()
+        assert p.wait_for_end(poll_interval=0.01) is True
+        t.join()