porter-workflow 0.2.0__py3-none-any.whl

porter/__init__.py

@@ -0,0 +1,143 @@
+"""porter — automated video localization engine.
+
+This package is the **library** layer. It contains no command-line parsing and
+never writes to stdout: two thin frontends consume it.
+
+* ``porter_cli`` — the ``porter`` console script, for humans.
+* ``porter_mcp`` — the ``porter-mcp`` MCP server, for AI agents.
+
+Architectural rules (enforced by ``lint-imports`` and a test that scans for
+``print`` calls):
+
+1. This package must never import ``porter_cli`` or ``porter_mcp``.
+2. Nothing under this package may call ``print()`` — in an MCP stdio server,
+   stdout *is* the JSON-RPC channel. Use :func:`porter.logging.get_logger`.
+3. Nothing in this package may assume a deployment layout (agent skill
+   directories, caller-supplied config paths, ...). Configuration is resolved
+   from explicit arguments, environment variables and platform user dirs.
+
+Importing this module is cheap and dependency-free. The heavier symbols
+(``JobOptions``, ``Pipeline``, ...) are resolved lazily on first attribute
+access via :pep:`562` — so ``import porter; porter.__version__`` needs nothing
+but the standard library.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from porter.errors import (
+    AsrError,
+    CapabilityMissingError,
+    ConfigError,
+    ExtractionError,
+    JobCancelled,
+    MediaError,
+    PorterError,
+    RenderError,
+    SubtitleError,
+    TranslationError,
+    UnsupportedPlatformError,
+)
+from porter.logging import configure as configure_logging
+from porter.logging import get_logger
+
+__version__ = "0.2.0"
+
+#: Public API, resolved lazily. Maps attribute name -> defining module.
+_LAZY_EXPORTS: dict[str, str] = {
+    # context
+    "RunContext": "porter.context",
+    # events
+    "ArtifactKind": "porter.events",
+    "Event": "porter.events",
+    "EventSink": "porter.events",
+    "JobState": "porter.events",
+    "Phase": "porter.events",
+    # models
+    "BurnMode": "porter.models",
+    "BurnResult": "porter.models",
+    "JobOptions": "porter.models",
+    "JobRequest": "porter.models",
+    "JobResult": "porter.models",
+    "RawMaterials": "porter.models",
+    "SubtitleItem": "porter.models",
+    "SubtitleSet": "porter.models",
+    "TaskLayout": "porter.models",
+    "TranscriptSentence": "porter.models",
+    "VideoMetadata": "porter.models",
+    # orchestration
+    "Pipeline": "porter.pipeline",
+}
+
+if TYPE_CHECKING:  # pragma: no cover - import-time only, for type checkers
+    from porter.context import RunContext
+    from porter.events import ArtifactKind, Event, EventSink, JobState, Phase
+    from porter.models import (
+        BurnMode,
+        BurnResult,
+        JobOptions,
+        JobRequest,
+        JobResult,
+        RawMaterials,
+        SubtitleItem,
+        SubtitleSet,
+        TaskLayout,
+        TranscriptSentence,
+        VideoMetadata,
+    )
+    from porter.pipeline import Pipeline
+
+
+def __getattr__(name: str) -> Any:
+    """Resolve the lazily-exported public API (PEP 562)."""
+    module_path = _LAZY_EXPORTS.get(name)
+    if module_path is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    import importlib
+
+    module = importlib.import_module(module_path)
+    value = getattr(module, name)
+    globals()[name] = value  # cache so subsequent lookups skip __getattr__
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted({*globals(), *_LAZY_EXPORTS})
+
+
+__all__ = [
+    "ArtifactKind",
+    "AsrError",
+    "BurnMode",
+    "BurnResult",
+    "CapabilityMissingError",
+    "ConfigError",
+    "Event",
+    "EventSink",
+    "ExtractionError",
+    "JobCancelled",
+    "JobOptions",
+    "JobRequest",
+    "JobResult",
+    "JobState",
+    "MediaError",
+    "Phase",
+    "Pipeline",
+    "PorterError",
+    "RawMaterials",
+    "RenderError",
+    "RunContext",
+    "SubtitleError",
+    "SubtitleItem",
+    "SubtitleSet",
+    "TaskLayout",
+    "TranscriptSentence",
+    "TranslationError",
+    "UnsupportedPlatformError",
+    "VideoMetadata",
+    "__version__",
+    "configure_logging",
+    "get_logger",
+]

porter/asr/__init__.py

@@ -0,0 +1,59 @@
+"""Speech-to-text backends and the fallback chain.
+
+``chain.py``
+    :class:`AsrChain` — implements :class:`~porter.ports.Transcriber`. Takes the
+    platform's own subtitle track when PREPARE fetched one, and otherwise walks
+    the engine chain, skipping backends whose ``available()`` is ``False``.
+``platform_subs.py``
+    Reads that fetched track. Deliberately **not** a backend: it is a file, with
+    no engine to probe and no ordering question.
+``whisper_api.py``
+    OpenAI-compatible Whisper endpoint. Requires the ``[llm]`` extra.
+``whisper_local.py``
+    ★ Local Whisper through ``faster-whisper`` (MIT, no PyTorch). Requires the
+    ``[asr-local]`` extra. The only backend that needs no key, no network and no
+    third-party service, and the only one whose ``endpoint_verified`` is true by
+    construction rather than by measurement.
+``bcut.py``
+    Bilibili Bcut. Key-free, chunked upload, its own session so a configured proxy
+    cannot stall the upload. **Unverified endpoint.**
+``google_web.py``
+    Google Web STT with recursive VAD slicing, so long dialogue does not lose its
+    tail. Requires the ``[stt]`` extra. **Unverified endpoint.**
+``videocaptioner.py``
+    ★ Optional adapter around the **external** ``videocaptioner`` CLI.
+    GPL-3.0 and ``python<3.13``, therefore never a declared dependency and only
+    ever reached through ``subprocess``. An absent binary drops the backend from
+    the chain without a user-visible warning.
+``base.py``
+    The backend protocol, the shared :class:`~porter.asr.base.AsrOutcome`, and the
+    cue helpers every backend needs.
+
+"Unverified endpoint" is a claim about the *wire format*, not the structure. Those
+two modules port v0.1's request/response handling for services that were
+reverse-engineered rather than documented; they cannot be exercised in an offline
+test suite and may already be dead. Their availability probes, error mapping,
+timeouts and cancellation handling are deliberate and tested.
+"""
+
+from porter.asr.base import AsrBackend, AsrBackendError, AsrOutcome
+from porter.asr.bcut import BcutBackend
+from porter.asr.chain import AsrChain
+from porter.asr.google_web import GoogleWebBackend
+from porter.asr.platform_subs import load_platform_subtitles
+from porter.asr.videocaptioner import VideoCaptionerBackend
+from porter.asr.whisper_api import WhisperApiBackend
+from porter.asr.whisper_local import WhisperLocalBackend
+
+__all__ = [
+    "AsrBackend",
+    "AsrBackendError",
+    "AsrChain",
+    "AsrOutcome",
+    "BcutBackend",
+    "GoogleWebBackend",
+    "VideoCaptionerBackend",
+    "WhisperApiBackend",
+    "WhisperLocalBackend",
+    "load_platform_subtitles",
+]

porter/asr/base.py

@@ -0,0 +1,169 @@
+"""The narrow contract every ASR engine implements.
+
+:class:`~porter.ports.AsrBackend` in ``porter.ports`` is the *pipeline's* view;
+this module is the *backend author's* view, plus the shared error type and the
+one helper every backend needs.
+
+## Why a separate error type
+
+The chain has to answer "should I try the next backend?" and it cannot do that
+from an arbitrary exception. A backend that returns an empty list, one that
+raises ``TimeoutError``, and one that parses a response into nothing all look the
+same from outside, and the difference decides whether falling through is right.
+
+So backends raise :class:`AsrBackendError` for *expected* failure — endpoint
+down, quota exhausted, malformed response — and let genuinely unexpected
+exceptions (a bug in our own code) propagate. The chain catches the first and
+logs the second, which keeps a typo from being silently swallowed by a fallback
+loop.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+from porter.context import RunContext
+from porter.models.subtitle import SubtitleItem
+
+__all__ = [
+    "CHUNK_SECONDS",
+    "MAX_AUDIO_BYTES",
+    "AsrBackend",
+    "AsrBackendError",
+    "AsrOutcome",
+    "coerce_items",
+    "parse_srt_items",
+]
+
+#: Upload chunk ceiling used by the cloud backends. Bilibili's endpoint rejects
+#: anything larger; the others are happy with it.
+MAX_AUDIO_BYTES = 100 * 1024 * 1024
+
+#: Long audio is sliced rather than uploaded whole, because the free endpoints
+#: time out on a 40-minute file and the failure looks like a network problem.
+CHUNK_SECONDS = 480.0
+
+
+class AsrBackendError(Exception):
+    """An expected backend failure. The chain moves on to the next engine.
+
+    Carries ``backend`` so the log line names the engine that failed rather than
+    reporting a bare message, which matters when five backends have each failed
+    for a different reason.
+
+    ## The rule every backend must obey
+
+    **Every expected failure becomes an ``AsrBackendError``.** The chain catches
+    exactly ``AsrBackendError`` and ``PorterError``; anything else propagates and
+    kills the process with a traceback.
+
+    That is deliberate -- a chain-wide ``except Exception`` would swallow real
+    bugs (a typo, a bad unpack) and report them as "backend unavailable", which is
+    the hardest kind of failure to diagnose. But it puts the burden on the
+    backend, and transport layers are where it gets missed: ``requests`` raises
+    ``RequestException``, ``urllib`` raises ``http.client.HTTPException`` (a
+    truncated chunked response is ``IncompleteRead``, which is neither an
+    ``OSError`` nor a ``RequestError``), and a library may raise something else
+    entirely. Map them all.
+    """
+
+    def __init__(self, backend: str, message: str, /, **details: object) -> None:
+        super().__init__(message)
+        self.backend = backend
+        self.message = message
+        self.details = details
+
+    def __str__(self) -> str:
+        base = f"[{self.backend}] {self.message}"
+        if self.details:
+            rendered = ", ".join(f"{key}={value!r}" for key, value in self.details.items())
+            return f"{base} ({rendered})"
+        return base
+
+
+@dataclass(frozen=True)
+class AsrOutcome:
+    """What a backend produced. Cues plus an optional provenance note.
+
+    ``used_asr`` is on the outcome rather than inferred by the chain because only
+    the backend knows: a platform-subtitle backend did no recognition at all, and
+    reporting that as "ASR was used" would mislabel the source for the operator.
+    """
+
+    items: list[SubtitleItem]
+    used_asr: bool = True
+    #: Free-text provenance for the log and the job report, e.g. "whisper-1".
+    origin: str = ""
+
+
+@runtime_checkable
+class AsrBackend(Protocol):
+    """One speech-to-text engine.
+
+    ``available()`` must be cheap and must never raise — it is called for every
+    backend on every job to decide the chain, so a backend that raises there
+    breaks the chain's ability to skip it.
+    """
+
+    name: str
+
+    #: Whether this engine's wire format has been verified against the live
+    #: service.
+    #:
+    #: ``available()`` cannot answer this: it probes *local* facts (a key is set, a
+    #: binary is on PATH), which say nothing about whether the remote endpoint
+    #: still speaks the protocol this code was written for. ``bcut`` and
+    #: ``google_web`` are reverse-engineered and answered with empty results on
+    #: every probe made while building this port, so they report ``available`` and
+    #: still cannot transcribe.
+    #:
+    #: ``False`` is not "broken" -- it is "nobody has checked", which is exactly
+    #: what a caller needs to know before promising a user that a job will finish.
+    endpoint_verified: bool
+
+    def available(self, ctx: RunContext) -> bool:
+        """Whether this engine can run right now. Never raises."""
+        ...
+
+    def transcribe(self, audio: Path, ctx: RunContext) -> AsrOutcome:
+        """Recognise ``audio``.
+
+        Raises:
+            AsrBackendError: For expected failure. The chain tries the next
+                backend.
+        """
+        ...
+
+
+def coerce_items(items: list[SubtitleItem]) -> list[SubtitleItem]:
+    """Renumber cues 1..n and drop empties.
+
+    Every backend needs this and each v0.1 copy did it slightly differently — one
+    kept the original indices, one renumbered, one left blank cues in. Renumbering
+    is the correct choice: the generators write ``index`` into the SRT, and a
+    duplicated or gapped index produces a file that some players refuse.
+    """
+    cleaned = [
+        item
+        for item in items
+        if item.source_text.strip() and item.end_ms > item.start_ms
+    ]
+    for position, item in enumerate(cleaned, start=1):
+        item.index = position
+    return cleaned
+
+
+def parse_srt_items(text: str) -> list[SubtitleItem]:
+    """Parse SRT into cues. Returns ``[]`` for anything unparseable.
+
+    Deliberately total: a backend that returns a malformed body should fall
+    through the chain, not raise a parse error that reads like a bug in porter.
+    """
+    from porter.subtitles.srt import parse_srt
+
+    try:
+        return coerce_items(parse_srt(text))
+    except (ValueError, IndexError):  # pragma: no cover - parse_srt is total
+        return []

porter/asr/bcut.py

@@ -0,0 +1,304 @@
+"""UNVERIFIED ENDPOINT. This ports v0.1's request/response handling for a
+key-free endpoint that was reverse-engineered, not documented. It cannot be
+exercised in an offline test suite and may already be dead. The structure
+(availability probe, error mapping, cancellation, timeout) is deliberate and
+tested; the wire format is best-effort and unvalidated.
+
+Measured 2026-09-22: the API host answers (``resource/create`` returns HTTP 200),
+but a real 10-minute transcription produced no usable utterances, so this path is
+not working either. Unlike Google Web, the failure here is ambiguous -- it could
+be a quota, a changed field, or a rejected upload -- so this module keeps its
+"unverified" label rather than claiming the endpoint is dead.
+
+Bilibili's Bcut speech-to-text. It requires no key and no account, which is why
+it sits in the free end of the fallback chain, but the ``rubick-interface`` API
+is undocumented: the field names (``in_boss_key``, ``ResourceFileType``,
+``Etags``) are Bilibili's own capitalisation, and the polling ``model_id`` is
+``7`` while every other step sends ``8``. Both quirks are preserved verbatim
+because "fixing" an undocumented protocol is how you get an endpoint that
+returns 200 and does nothing.
+
+The session deliberately sets ``trust_env = False``. Bilibili's object storage
+is domestic (China), and a developer's corporate or VPN proxy turns a 3-second
+chunk upload into a stall that looks like an endpoint outage.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from porter.asr.base import AsrBackendError, AsrOutcome, coerce_items
+from porter.context import RunContext
+from porter.logging import get_logger
+from porter.models.subtitle import SubtitleItem
+
+__all__ = [
+    "API_BASE",
+    "MODEL_ID",
+    "POLL_ATTEMPTS",
+    "POLL_INTERVAL",
+    "BcutBackend",
+]
+
+_logger = get_logger(__name__)
+
+NAME = "bcut"
+
+#: v0.1's endpoint, model id, retry budget and interval, unchanged.
+API_BASE = "https://member.bilibili.com/x/bcut/rubick-interface"
+MODEL_ID = "8"
+POLL_ATTEMPTS = 60
+POLL_INTERVAL = 2.0
+
+#: v0.1's per-request timeouts, unchanged: the small control calls get 15-20s
+#: and the chunk upload gets 60s.
+TIMEOUT_CREATE = 15.0
+TIMEOUT_UPLOAD = 60.0
+TIMEOUT_COMMIT = 20.0
+TIMEOUT_TASK = 20.0
+TIMEOUT_RESULT = 15.0
+
+_HEADERS = {
+    "User-Agent": "Bilibili/1.0.0 (https://www.bilibili.com)",
+    "Content-Type": "application/json",
+}
+
+
+def _data_object(response: requests.Response, what: str) -> dict[str, Any]:
+    """Extract the ``data`` object from a Bilibili envelope.
+
+    Bilibili answers ``{"code": 0, "data": {...}}`` and encodes failures inside
+    ``code`` even at HTTP 200, so a missing ``data`` is a real failure rather
+    than a reason to read a default.
+    """
+    try:
+        body = response.json()
+    except ValueError as exc:
+        raise AsrBackendError(NAME, f"{what} returned malformed JSON: {exc}") from exc
+    if not isinstance(body, dict):
+        raise AsrBackendError(NAME, f"{what} returned a non-object JSON body")
+    data = body.get("data")
+    if not isinstance(data, dict):
+        raise AsrBackendError(NAME, f"{what} response is missing the data object")
+    return data
+
+
+class BcutBackend:
+    """Bilibili Bcut. Chunked upload, then poll for the transcript."""
+
+    name = NAME
+    endpoint_verified = False
+
+    def available(self, ctx: RunContext) -> bool:
+        """Whether ``requests`` is importable. Never raises.
+
+        Bcut needs no key, so there is nothing else to probe. The check is
+        written against the module attribute rather than an import statement so
+        a host (or a test) that has torn the dependency out degrades to
+        ``False`` instead of raising.
+        """
+        try:
+            return bool(getattr(requests, "Session", None))
+        except Exception:  # available() must never raise; log and degrade.
+            _logger.error("could not inspect the requests module; Bcut unavailable", exc_info=True)
+            return False
+
+    def transcribe(self, audio: Path, ctx: RunContext) -> AsrOutcome:
+        """Upload ``audio`` to Bcut and return its utterances as cues.
+
+        Raises:
+            AsrBackendError: A missing/empty audio file, a transport or HTTP
+                failure, a malformed envelope, or an exhausted poll budget.
+        """
+        ctx.check_cancelled()
+        if getattr(requests, "Session", None) is None:
+            raise AsrBackendError(
+                self.name,
+                "the 'requests' package is required for the Bcut backend",
+            )
+
+        if not audio.exists():
+            raise AsrBackendError(self.name, f"audio file does not exist: {audio}")
+        try:
+            audio_data = audio.read_bytes()
+        except OSError as exc:
+            raise AsrBackendError(self.name, f"audio file could not be read: {exc}") from exc
+        if not audio_data:
+            raise AsrBackendError(self.name, "audio file is empty", path=str(audio))
+
+        # trust_env=False: see the module docstring. A configured proxy stalls on
+        # Bilibili's domestic object storage.
+        session = requests.Session()
+        session.trust_env = False
+
+        try:
+            download_url = self._upload(session, audio, audio_data)
+            task_id = self._create_task(session, download_url)
+            result = self._poll(session, task_id, ctx)
+        except requests.RequestException as exc:
+            raise AsrBackendError(self.name, f"Bcut request failed: {exc}") from exc
+        except ValueError as exc:
+            raise AsrBackendError(self.name, f"Bcut returned malformed JSON: {exc}") from exc
+
+        return self._outcome(result)
+
+    # -- steps --------------------------------------------------------------
+
+    def _upload(self, session: Any, audio: Path, audio_data: bytes) -> str:
+        """Steps 1-3: create the resource, PUT each chunk, commit the upload."""
+        payload = json.dumps(
+            {
+                "type": 2,
+                "name": audio.name,
+                "size": len(audio_data),
+                "ResourceFileType": audio.suffix.lstrip(".") or "wav",
+                "model_id": MODEL_ID,
+            }
+        )
+        resp = session.post(
+            f"{API_BASE}/resource/create",
+            data=payload,
+            headers=_HEADERS,
+            timeout=TIMEOUT_CREATE,
+        )
+        resp.raise_for_status()
+        data = _data_object(resp, "resource/create")
+        if "upload_urls" not in data:
+            raise AsrBackendError(self.name, "resource/create did not return upload_urls")
+
+        upload_urls = data["upload_urls"]
+        per_size = data["per_size"]
+        clips = len(upload_urls)
+
+        etags: list[str] = []
+        for clip in range(clips):
+            start = clip * per_size
+            end = (clip + 1) * per_size
+            part_resp = session.put(
+                upload_urls[clip],
+                data=audio_data[start:end],
+                headers=_HEADERS,
+                timeout=TIMEOUT_UPLOAD,
+            )
+            part_resp.raise_for_status()
+            etag = part_resp.headers.get("Etag")
+            if etag:
+                etags.append(etag)
+
+        commit_data = json.dumps(
+            {
+                "InBossKey": data["in_boss_key"],
+                "ResourceId": data["resource_id"],
+                "Etags": ",".join(etags),
+                "UploadId": data["upload_id"],
+                "model_id": MODEL_ID,
+            }
+        )
+        commit_resp = session.post(
+            f"{API_BASE}/resource/create/complete",
+            data=commit_data,
+            headers=_HEADERS,
+            timeout=TIMEOUT_COMMIT,
+        )
+        commit_resp.raise_for_status()
+        download_url = _data_object(commit_resp, "resource/create/complete").get("download_url")
+        if not download_url:
+            raise AsrBackendError(self.name, "resource/create/complete did not return a download_url")
+        return str(download_url)
+
+    def _create_task(self, session: Any, download_url: str) -> str:
+        """Step 4: submit the transcription task."""
+        task_resp = session.post(
+            f"{API_BASE}/task",
+            data=json.dumps({"resource": download_url, "model_id": MODEL_ID}),
+            headers=_HEADERS,
+            timeout=TIMEOUT_TASK,
+        )
+        task_resp.raise_for_status()
+        task_id = _data_object(task_resp, "task").get("task_id")
+        if not task_id:
+            raise AsrBackendError(self.name, "task creation did not return a task_id")
+        return str(task_id)
+
+    def _poll(self, session: Any, task_id: str, ctx: RunContext) -> dict[str, Any]:
+        """Step 5: poll until ``state == 4``.
+
+        ``ctx.cancel.wait`` replaces v0.1's bare ``time.sleep(2)`` so that Ctrl-C
+        interrupts the 120-second budget on the next tick instead of after it.
+        ``model_id`` is ``7`` here, matching v0.1 and the endpoint, not the
+        ``8`` used everywhere else.
+        """
+        for _ in range(POLL_ATTEMPTS):
+            if ctx.cancel.wait(POLL_INTERVAL):
+                ctx.check_cancelled()
+            ctx.check_cancelled()
+
+            q_resp = session.get(
+                f"{API_BASE}/task/result",
+                params={"model_id": 7, "task_id": task_id},
+                headers=_HEADERS,
+                timeout=TIMEOUT_RESULT,
+            )
+            q_resp.raise_for_status()
+            q_data = _data_object(q_resp, "task/result")
+            if q_data.get("state") == 4:
+                result = q_data.get("result", "{}")
+                parsed = json.loads(result) if isinstance(result, str) else result
+                if not isinstance(parsed, dict):
+                    raise AsrBackendError(self.name, "task/result result is not a JSON object")
+                return parsed
+
+        raise AsrBackendError(
+            self.name,
+            f"Bcut did not finish within {POLL_ATTEMPTS * POLL_INTERVAL:.0f}s",
+            task_id=task_id,
+        )
+
+    # -- result -------------------------------------------------------------
+
+    def _outcome(self, result: dict[str, Any]) -> AsrOutcome:
+        """Turn the ``utterances`` array into cues.
+
+        v0.1 built an SRT string here and returned ``False`` for an empty result.
+        Returning ``AsrOutcome`` with no items is not possible: the chain reads
+        an empty list as "this backend produced nothing", which loses *why*, so
+        an empty or malformed payload is an explicit failure.
+        """
+        utterances = result.get("utterances")
+        if not isinstance(utterances, list):
+            raise AsrBackendError(self.name, "Bcut result is missing the utterances array")
+
+        items: list[SubtitleItem] = []
+        for utterance in utterances:
+            if not isinstance(utterance, dict):
+                continue
+            text = str(utterance.get("transcript", "")).strip()
+            if not text:
+                continue
+            try:
+                start_ms = int(utterance.get("start_time", 0))
+                end_ms = int(utterance.get("end_time", 0))
+            except (TypeError, ValueError) as exc:
+                raise AsrBackendError(
+                    self.name,
+                    f"Bcut utterance has non-numeric timing: {exc}",
+                ) from exc
+            items.append(
+                SubtitleItem(
+                    index=len(items) + 1,
+                    start_ms=start_ms,
+                    end_ms=end_ms,
+                    source_text=text,
+                    target_text="",
+                )
+            )
+
+        cleaned = coerce_items(items)
+        if not cleaned:
+            raise AsrBackendError(self.name, "Bcut returned no usable utterances")
+
+        return AsrOutcome(items=cleaned, used_asr=True, origin="bcut")