u-transcript-max 0.1.0a2__tar.gz → 0.1.0a3__tar.gz

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: u-transcript-max
-Version: 0.1.0a2
+Version: 0.1.0a3
 Summary: YouTube transcripts, AI translation and downloads for Python, with zero dependencies.
 Project-URL: Homepage, https://github.com/U-C4N/U-transkript
 Project-URL: Issues, https://github.com/U-C4N/U-transkript/issues
@@ -87,13 +87,13 @@ from utmax.compat import YouTubeTranscriptApi
 `utmax-mcp` gives an AI assistant four tools: `list_tracks`, `get_transcript`, `list_videos`
 and `download`. It needs no API key: ask for a translation and the assistant translates the
 transcript itself. The commands below start it with `uvx` from
-[uv](https://docs.astral.sh/uv/getting-started/installation/), which installs it from PyPI on
-first use.
+[uv](https://docs.astral.sh/uv/getting-started/installation/), which installs it from PyPI;
+`@latest` makes it move to each new release the next time the client starts the server.
 
 ### Claude Code
 
 ```bash
-claude mcp add --scope user utmax -- uvx --from "u-transcript-max[mcp]" utmax-mcp
+claude mcp add --scope user utmax -- uvx --from "u-transcript-max[mcp]@latest" utmax-mcp
 ```
 
 `claude mcp get utmax` should say `Connected`; inside Claude Code, `/mcp` lists the server.
@@ -101,7 +101,7 @@ claude mcp add --scope user utmax -- uvx --from "u-transcript-max[mcp]" utmax-mc
 ### Codex
 
 ```bash
-codex mcp add utmax -- uvx --from "u-transcript-max[mcp]" utmax-mcp
+codex mcp add utmax -- uvx --from "u-transcript-max[mcp]@latest" utmax-mcp
 ```
 
 A long download can outlast Codex's default tool timeout, and the first start installs the
@@ -111,7 +111,7 @@ file):
 ```toml
 [mcp_servers.utmax]
 command = "uvx"
-args = ["--from", "u-transcript-max[mcp]", "utmax-mcp"]
+args = ["--from", "u-transcript-max[mcp]@latest", "utmax-mcp"]
 startup_timeout_sec = 60
 tool_timeout_sec = 1800
 ```
@@ -126,7 +126,7 @@ restart Claude Desktop:
   "mcpServers": {
     "utmax": {
       "command": "uvx",
-      "args": ["--from", "u-transcript-max[mcp]", "utmax-mcp"]
+      "args": ["--from", "u-transcript-max[mcp]@latest", "utmax-mcp"]
     }
   }
 }

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/README.md

@@ -48,13 +48,13 @@ from utmax.compat import YouTubeTranscriptApi
 `utmax-mcp` gives an AI assistant four tools: `list_tracks`, `get_transcript`, `list_videos`
 and `download`. It needs no API key: ask for a translation and the assistant translates the
 transcript itself. The commands below start it with `uvx` from
-[uv](https://docs.astral.sh/uv/getting-started/installation/), which installs it from PyPI on
-first use.
+[uv](https://docs.astral.sh/uv/getting-started/installation/), which installs it from PyPI;
+`@latest` makes it move to each new release the next time the client starts the server.
 
 ### Claude Code
 
 ```bash
-claude mcp add --scope user utmax -- uvx --from "u-transcript-max[mcp]" utmax-mcp
+claude mcp add --scope user utmax -- uvx --from "u-transcript-max[mcp]@latest" utmax-mcp
 ```
 
 `claude mcp get utmax` should say `Connected`; inside Claude Code, `/mcp` lists the server.
@@ -62,7 +62,7 @@ claude mcp add --scope user utmax -- uvx --from "u-transcript-max[mcp]" utmax-mc
 ### Codex
 
 ```bash
-codex mcp add utmax -- uvx --from "u-transcript-max[mcp]" utmax-mcp
+codex mcp add utmax -- uvx --from "u-transcript-max[mcp]@latest" utmax-mcp
 ```
 
 A long download can outlast Codex's default tool timeout, and the first start installs the
@@ -72,7 +72,7 @@ file):
 ```toml
 [mcp_servers.utmax]
 command = "uvx"
-args = ["--from", "u-transcript-max[mcp]", "utmax-mcp"]
+args = ["--from", "u-transcript-max[mcp]@latest", "utmax-mcp"]
 startup_timeout_sec = 60
 tool_timeout_sec = 1800
 ```
@@ -87,7 +87,7 @@ restart Claude Desktop:
   "mcpServers": {
     "utmax": {
       "command": "uvx",
-      "args": ["--from", "u-transcript-max[mcp]", "utmax-mcp"]
+      "args": ["--from", "u-transcript-max[mcp]@latest", "utmax-mcp"]
     }
   }
 }

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/src/utmax/__init__.py

@@ -396,6 +396,8 @@ def download(
         FormatNotAvailable: no stream fits the type and quality (live streams, for example).
         StreamForbidden, DownloadIncomplete, NetworkError: the download failed; call again to
             resume.
+        PoTokenRequired: YouTube serves only the start of this video's streams without a
+            proof-of-origin token, which utmax cannot create.
         DownloadCancelled: ``cancel`` was set.
         MuxError, FFmpegFailed: the file could not be assembled.
         VideoUnavailable, VideoUnplayable, AgeRestricted, RequestBlocked: YouTube refused.

u_transcript_max-0.1.0a3/src/utmax/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0a3"

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/src/utmax/adapters/downloader.py

@@ -34,7 +34,13 @@ from utmax.core.downloads import (
 )
 from utmax.core.retry import backoff_delay, is_transient_status
 from utmax.core.streams import Stream
-from utmax.errors import DownloadCancelled, DownloadIncomplete, NetworkError, StreamForbidden
+from utmax.errors import (
+    DownloadCancelled,
+    DownloadIncomplete,
+    NetworkError,
+    PoTokenRequired,
+    StreamForbidden,
+)
 from utmax.models import Progress, ProgressPhase
 from utmax.transport import HttpRequest, HttpStream
 
@@ -173,6 +179,8 @@ class Downloader:
         Raises:
             DownloadCancelled: ``cancel`` was set; the parts stay for a resume.
             StreamForbidden: YouTube kept answering 403 after ``max_refreshes`` fresh URLs.
+            PoTokenRequired: ... while still serving the stream's first byte: it wants a
+                proof-of-origin token for this video.
             DownloadIncomplete: a stream kept failing, changed on YouTube's side or answered
                 an unexpected status.
             NetworkError: the connection kept failing.
@@ -350,13 +358,7 @@ class Downloader:
             if self._fresh_streams is None or self._refreshes >= self._max_refreshes:
                 if not required:
                     return
-                itag = target.stream.format.itag
-                raise StreamForbidden(
-                    f"YouTube refused stream {itag} of video {self._video_id} (HTTP 403) "
-                    f"after {self._refreshes} fresh URLs.",
-                    itag=itag,
-                    video_id=self._video_id,
-                )
+                raise self._forbidden(target)
             self._refreshes += 1
             log.info(
                 "getting fresh stream URLs for %s (%d/%d)",
@@ -370,6 +372,40 @@ class Downloader:
                     each.stream = self._match(each, fresh)
                 self._generation += 1
 
+    def _forbidden(self, target: _Target) -> PoTokenRequired | StreamForbidden:
+        """Why YouTube keeps refusing a stream: without a proof-of-origin token it serves only
+        the first megabyte of some videos' streams, so a stream whose first byte still comes
+        needs that token; otherwise its URLs do not work from here."""
+        stream = target.stream
+        itag = stream.format.itag
+        if self._serves_first_byte(stream):
+            return PoTokenRequired(
+                f"YouTube serves only the start of stream {itag} of video {self._video_id} and "
+                "refuses the rest (HTTP 403): it wants a proof-of-origin (PO) token for this "
+                "video, which utmax cannot create.",
+                suggestion=(
+                    "YouTube asks for this token for some videos only, and not always: try "
+                    "again later. The video's subtitles can still be fetched."
+                ),
+                video_id=self._video_id,
+            )
+        return StreamForbidden(
+            f"YouTube refused stream {itag} of video {self._video_id} (HTTP 403) "
+            f"after {self._refreshes} fresh URLs.",
+            itag=itag,
+            video_id=self._video_id,
+        )
+
+    def _serves_first_byte(self, stream: Stream) -> bool:
+        try:
+            body = self._opener(self._request(stream, "bytes=0-0"))
+        except NetworkError:
+            return False
+        try:
+            return body.status == 206
+        finally:
+            body.close()
+
     def _match(self, target: _Target, fresh: Sequence[Stream]) -> Stream:
         """The fresh stream with the same itag, size and version as ``target``'s."""
         old = target.stream.format

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/src/utmax/core/player.py

@@ -35,6 +35,7 @@ class PlayerData:
     caption_tracks: tuple[CaptionTrackInfo, ...] | None
     translation_languages: tuple[Language, ...]
     streams: tuple[Stream, ...] = ()
+    spoken_language: str | None = None
 
 
 def parse_player_response(data: Mapping[str, Any], *, video_id: str) -> PlayerData:
@@ -62,15 +63,36 @@ def parse_player_response(data: Mapping[str, Any], *, video_id: str) -> PlayerDa
         for raw in map(mapping, items(renderer.get("translationLanguages")))
         if raw.get("languageCode")
     )
+    streaming = mapping(data.get("streamingData"))
     return PlayerData(
         video=video,
         playability=parse_playability(data),
         caption_tracks=tracks or None,
         translation_languages=languages if tracks else (),
-        streams=parse_streams(mapping(data.get("streamingData"))),
+        streams=parse_streams(streaming),
+        spoken_language=_original_audio_language(streaming),
     )
 
 
+def _original_audio_language(streaming: Mapping[str, Any]) -> str | None:
+    """The language of the original audio of a video with dubbed audio tracks, like ``en-US``.
+
+    YouTube names that track "<language> original" (utmax always asks in English) and tags its
+    stream URLs ``acont=original``; videos with a single audio track mark nothing.
+    """
+    for raw in map(mapping, items(streaming.get("adaptiveFormats"))):
+        track = mapping(raw.get("audioTrack"))
+        name = str(track.get("displayName") or "").lower()
+        url = str(raw.get("url") or "").lower()
+        original = name.endswith(" original") or any(
+            mark in url for mark in ("acont%3doriginal", "acont=original")
+        )
+        code = str(track.get("id") or "").partition(".")[0]
+        if original and code:
+            return code
+    return None
+
+
 def _track(raw: Mapping[str, Any]) -> CaptionTrackInfo:
     code = str(raw.get("languageCode") or "")
     return CaptionTrackInfo(

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/src/utmax/core/selection.py

@@ -16,13 +16,17 @@ def select_track(
     *,
     include_manual: bool = True,
     include_generated: bool = True,
+    spoken_language: str | None = None,
 ) -> Track:
     """Pick one track from ``tracks``.
 
     With ``languages``, each code is tried in order: a manual track in exactly that code, then a
     manual track in the same base language (``de`` finds ``de-DE``), then the same two steps for
-    auto-generated tracks. Without ``languages`` the spoken language (that of the auto-generated
-    track) wins, manual first. YouTube's own translation is never used implicitly.
+    auto-generated tracks. Without ``languages`` the spoken language wins, manual first: the
+    language of the original audio (``spoken_language``) when tracks exist in it, else that of
+    the first auto-generated track. Videos with dubbed audio list an auto-generated track per
+    dub, so their first one need not be the original's. YouTube's own translation is never
+    used implicitly.
 
     Raises:
         NoTranscriptFound: nothing matches; the error lists every available track.
@@ -44,7 +48,11 @@ def select_track(
                 if pool:
                     return pool[0]
         raise _not_found(tracks, requested)
-    spoken = next((track.language_code for track in tracks if track.is_generated), None)
+    spoken = (
+        spoken_language
+        if spoken_language and _in_language(tracks, spoken_language)
+        else next((track.language_code for track in tracks if track.is_generated), None)
+    )
     if spoken is not None:
         manual = _in_language([track for track in candidates if not track.is_generated], spoken)
         if manual:

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/src/utmax/errors.py

@@ -197,7 +197,8 @@ class IpBlocked(RequestBlocked):
 
 
 class PoTokenRequired(YouTubeError):
-    """YouTube requires a proof-of-origin token that utmax cannot produce."""
+    """YouTube requires a proof-of-origin token that utmax cannot produce (for captions, or
+    for the streams of some videos)."""
 
     suggestion = (
         "YouTube changed how captions are served; please report it at "

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/src/utmax/models.py

@@ -172,11 +172,16 @@ class Track:
 
 @dataclass(frozen=True, slots=True)
 class TrackList(Sequence[Track]):
-    """All subtitle tracks of a video, in YouTube's order."""
+    """All subtitle tracks of a video, in YouTube's order.
+
+    ``spoken_language`` is the language of the video's original audio when YouTube marks it,
+    which it does for videos with dubbed audio tracks (``None`` otherwise).
+    """
 
     video: VideoInfo
     tracks: tuple[Track, ...]
     translation_languages: tuple[Language, ...] = ()
+    spoken_language: str | None = None
 
     @overload
     def __getitem__(self, index: int) -> Track: ...
@@ -216,6 +221,7 @@ class TrackList(Sequence[Track]):
             languages,
             include_manual=include_manual,
             include_generated=include_generated,
+            spoken_language=self.spoken_language,
         )
 
 

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/src/utmax/services/transcripts.py

@@ -44,7 +44,10 @@ class TranscriptService:
             for info in player.caption_tracks or ()
         )
         return TrackList(
-            video=player.video, tracks=tracks, translation_languages=player.translation_languages
+            video=player.video,
+            tracks=tracks,
+            translation_languages=player.translation_languages,
+            spoken_language=player.spoken_language,
         )
 
     def fetch(

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/tests/helpers/fake_media.py

@@ -100,6 +100,8 @@ class FakeMedia:
         self.requests: list[HttpRequest] = []
         self.bodies: list[FakeBody] = []
         self.expired: set[str] = set()
+        # name -> bytes served without a proof-of-origin token; requests past them answer 403
+        self.start_only: dict[str, int] = {}
         self._streams: dict[str, bytes] = {}
         self._faults: dict[str, deque[Fault]] = {}
         self._lock = threading.Lock()
@@ -129,7 +131,7 @@ class FakeMedia:
             fault = faults.popleft() if faults else Fault()
         if fault.error is not None:
             raise fault.error
-        body = self._answer(request, self._streams.get(name), fault)
+        body = self._answer(request, self._streams.get(name), fault, self.start_only.get(name))
         with self._lock:
             self.bodies.append(body)
         return body
@@ -141,7 +143,9 @@ class FakeMedia:
         body.close()
         return HttpResponse(status=body.status, url=request.url, headers=body.headers, body=data)
 
-    def _answer(self, request: HttpRequest, data: bytes | None, fault: Fault) -> FakeBody:
+    def _answer(
+        self, request: HttpRequest, data: bytes | None, fault: Fault, limit: int | None
+    ) -> FakeBody:
         if data is None:
             return FakeBody(404, {}, b"")
         if request.url in self.expired:
@@ -150,10 +154,14 @@ class FakeMedia:
             return FakeBody(fault.status, {}, b"")
         header = request.headers.get("Range")
         if header is None or fault.ignore_range:
+            if limit is not None and len(data) > limit:
+                return FakeBody(403, {}, b"")
             return FakeBody(200, {"Content-Length": str(len(data))}, data)
         first, _, last = header.removeprefix("bytes=").partition("-")
         start = int(first)
         end = min(int(last) + 1 if last else len(data), len(data))
+        if limit is not None and end > limit:
+            return FakeBody(403, {}, b"")
         if start >= len(data):
             return FakeBody(416, {"Content-Range": f"bytes */{len(data)}"}, b"")
         body = data[start:end]

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/tests/helpers/youtube.py

@@ -97,6 +97,39 @@ DEFAULT_TRACKS: tuple[tuple[str, str, bool], ...] = (
 )
 
 
+def audio_track_format(
+    track_id: str, name: str, *, xtags: str, default: bool = False
+) -> dict[str, Any]:
+    """An AAC format of one audio track of a video with dubbed audio (URL is a placeholder)."""
+    return {
+        "itag": 140,
+        "mimeType": 'audio/mp4; codecs="mp4a.40.2"',
+        "url": f"https://media.test/140?xtags={xtags}",
+        "audioTrack": {"id": track_id, "displayName": name, "audioIsDefault": default},
+    }
+
+
+# Shaped like ZcDFZzsp3_Y on 2026-10-08: English original audio, 20 automatic dubs, and an
+# auto-generated track per dub listed before the original's (Arabic first).
+DUBBED_AUDIO: dict[str, Any] = {
+    "adaptiveFormats": [
+        audio_track_format("ar.10", "Arabic", xtags="acont%3Ddubbed-auto%3Alang%3Dar"),
+        audio_track_format(
+            "en-US.4",
+            "English (US) original",
+            xtags="acont%3Doriginal%3Adrc%3D1%3Alang%3Den-US",
+            default=True,
+        ),
+    ]
+}
+DUBBED_TRACKS: tuple[tuple[str, str, bool], ...] = (
+    ("ar", "Arabic (auto-generated)", True),
+    ("en", "English", False),
+    ("en", "English (auto-generated)", True),
+    ("de", "German (auto-generated)", True),
+)
+
+
 def caption_track(
     code: str, name: str, generated: bool, *, video_id: str = VIDEO_ID
 ) -> dict[str, Any]:

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/tests/unit/adapters/test_downloader_recovery.py

@@ -19,6 +19,7 @@ from utmax.errors import (
     DownloadIncomplete,
     IpBlocked,
     NetworkError,
+    PoTokenRequired,
     StreamForbidden,
 )
 from utmax.models import Progress
@@ -138,6 +139,41 @@ def test_forbidden_streams_give_up_after_three_refreshes(tmp_path: Path) -> None
         downloader(media, refresh=refresh).run([job], video_id="v")
     assert caught.value.itag == 137
     assert len(calls) == 3
+
+
+def test_streams_served_only_at_the_start_need_a_po_token(tmp_path: Path) -> None:
+    """Without a proof-of-origin token YouTube serves only the first megabyte of some videos'
+    streams and answers 403 after it (ZcDFZzsp3_Y over ANDROID and IOS, 2026-10-08)."""
+    media, _, job = served(tmp_path, size=8000)
+    media.start_only["video"] = 1500
+    calls: list[int] = []
+
+    def refresh() -> list[Stream]:
+        calls.append(1)
+        return [media_stream(137, f"{job.stream.url}?v={len(calls)}", 8000)]
+
+    with pytest.raises(PoTokenRequired, match=r"proof-of-origin \(PO\) token") as caught:
+        downloader(media, refresh=refresh, connections=1).run([job], video_id="v")
+    error = caught.value
+    assert "stream 137 of video v" in str(error)
+    assert error.video_id == "v"
+    assert "subtitles can still be fetched" in error.suggestion
+    assert len(calls) == 3
+    assert media.ranges("video")[-1] == "bytes=0-0"
+    assert all(body.closed for body in media.bodies)
+
+
+def test_a_failed_first_byte_check_keeps_the_403_error(tmp_path: Path) -> None:
+    media, _, job = served(tmp_path, size=8000)
+    media.expired.add(job.stream.url)
+
+    def opener(request: HttpRequest) -> FakeBody:
+        if request.headers.get("Range") == "bytes=0-0":
+            raise NetworkError("Could not complete GET https://media.test: connection reset")
+        return media.stream(request)
+
+    with pytest.raises(StreamForbidden, match="after 0 fresh URLs"):
+        Downloader(opener, chunk_size=CHUNK, sleep=lambda _: None).run([job], video_id="v")
     assert completed(job) == []
 
 

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/tests/unit/core/test_player.py

@@ -6,7 +6,13 @@ from typing import Any
 
 import pytest
 
-from tests.helpers.youtube import VIDEO_ID, player_payload, streaming_data
+from tests.helpers.youtube import (
+    DUBBED_AUDIO,
+    VIDEO_ID,
+    audio_track_format,
+    player_payload,
+    streaming_data,
+)
 from utmax.core.player import CaptionTrackInfo, parse_player_response
 from utmax.models import Language, VideoInfo
 
@@ -92,3 +98,43 @@ def test_streams_are_parsed_from_streaming_data() -> None:
 
 def test_players_without_streaming_data_have_no_streams() -> None:
     assert parse_player_response(player_payload(), video_id=VIDEO_ID).streams == ()
+
+
+def test_the_original_audio_track_names_the_spoken_language() -> None:
+    payload = player_payload(streaming_data=DUBBED_AUDIO)
+    assert parse_player_response(payload, video_id=VIDEO_ID).spoken_language == "en-US"
+
+
+@pytest.mark.parametrize(
+    ("name", "xtags"),
+    [
+        ("English (US) original", ""),
+        ("English (US)", "acont%3Doriginal%3Alang%3Den-US"),
+        ("English (US)", "acont=original:lang=en-US"),
+    ],
+)
+def test_either_mark_of_the_original_audio_is_enough(name: str, xtags: str) -> None:
+    dub = audio_track_format("ar.10", "Arabic", xtags="acont%3Ddubbed-auto")
+    original = audio_track_format("en-US.4", name, xtags=xtags)
+    payload = player_payload(streaming_data={"adaptiveFormats": [dub, original]})
+    assert parse_player_response(payload, video_id=VIDEO_ID).spoken_language == "en-US"
+
+
+@pytest.mark.parametrize(
+    "streaming",
+    [
+        None,
+        {"adaptiveFormats": [audio_track_format("ar.10", "Arabic", xtags="acont%3Ddubbed-auto")]},
+        {"adaptiveFormats": [{"audioTrack": {"displayName": "English original"}}]},
+    ],
+)
+def test_without_a_marked_original_audio_there_is_no_spoken_language(
+    streaming: dict[str, Any] | None,
+) -> None:
+    payload = player_payload(streaming_data=streaming)
+    assert parse_player_response(payload, video_id=VIDEO_ID).spoken_language is None
+
+
+def test_a_single_audio_track_carries_no_mark() -> None:
+    payload = player_payload(streaming_data=streaming_data())
+    assert parse_player_response(payload, video_id=VIDEO_ID).spoken_language is None

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/tests/unit/core/test_selection.py

@@ -89,3 +89,28 @@ def test_track_list_find_uses_the_same_rules() -> None:
     assert tracks.find(["de"]) is DE
     assert tracks.find() is EN
     assert tracks.find(["en"], include_manual=False) is EN_AUTO
+
+
+AR_AUTO = make_track("ar", generated=True, name="Arabic (auto-generated)")
+DUBBED = (AR_AUTO, EN, EN_AUTO, make_track("de", generated=True))
+
+
+def test_the_original_audio_language_beats_tracks_of_dubbed_audio() -> None:
+    """Videos with dubbed audio list an auto-generated track per dub, often before the
+    original's; without the original audio's language the first one would win."""
+    assert pick(DUBBED) is AR_AUTO
+    assert select_track(DUBBED, spoken_language="en-US") is EN
+    assert select_track(DUBBED, spoken_language="en-US", include_manual=False) is EN_AUTO
+    assert select_track(DUBBED, ["ar"], spoken_language="en-US") is AR_AUTO
+
+
+def test_a_spoken_language_without_tracks_falls_back_to_the_first_auto_track() -> None:
+    assert select_track((AR_AUTO, DE), spoken_language="fr") is AR_AUTO
+    assert select_track((JA, DE), spoken_language="fr") is JA
+
+
+def test_track_list_find_uses_the_original_audio_language() -> None:
+    tracks = TrackList(video=VIDEO, tracks=DUBBED, spoken_language="en-US")
+    assert tracks.find() is EN
+    assert tracks.find(include_manual=False) is EN_AUTO
+    assert TrackList(video=VIDEO, tracks=DUBBED).find() is AR_AUTO

{u_transcript_max-0.1.0a2 → u_transcript_max-0.1.0a3}/tests/unit/services/test_transcripts.py

@@ -7,6 +7,9 @@ import pytest
 from tests.helpers.fake_transport import FakeTransport, json_response
 from tests.helpers.youtube import (
     ASR_JSON3,
+    DUBBED_AUDIO,
+    DUBBED_TRACKS,
+    MANUAL_JSON3,
     VIDEO_ID,
     json3_payload,
     player_payload,
@@ -140,6 +143,17 @@ def test_track_list_reuses_a_player_response_without_another_request() -> None:
     assert tracks[0].fetch().language_code == "en"
 
 
+def test_videos_with_dubbed_audio_default_to_their_original_language() -> None:
+    transport = FakeTransport()
+    payload = player_payload(tracks=DUBBED_TRACKS, streaming_data=DUBBED_AUDIO)
+    transport.add("POST", "/youtubei/v1/player", json_response(payload))
+    transport.add("GET", "lang=en&fmt=json3", json_response(MANUAL_JSON3))
+    tracks = service(transport).list_tracks(VIDEO_ID)
+    assert tracks.spoken_language == "en-US"
+    transcript = tracks.find().fetch()
+    assert (transcript.language_code, transcript.is_generated) == ("en", False)
+
+
 def test_track_list_is_empty_without_captions() -> None:
     transport = FakeTransport()
     transport.add("POST", "/youtubei/v1/player", json_response(player_payload(captions=False)))

u_transcript_max-0.1.0a2/src/utmax/_version.py

@@ -1 +0,0 @@
-__version__ = "0.1.0a2"