transcribe-cpp 0.1.2__tar.gz → 0.2.0__tar.gz

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/.gitignore

@@ -59,6 +59,10 @@ __pycache__/
 
 # WER evaluation data + generated working reports.
 /samples/wer/
+# Diarization eval corpora (AMI audio + fetched RTTMs); regenerable via
+# scripts/diar/ingest_ami.py + fetch_ami_forced_alignment.py. The committed
+# oracle case lives at samples/sortformer-2spk-mix.wav (outside samples/diar/).
+/samples/diar/
 /reports/*
 
 # Reviewable porting evidence (intake, porting log) is intentionally committed.

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: transcribe-cpp
-Version: 0.1.2
+Version: 0.2.0
 Summary: Python bindings for transcribe.cpp
 Project-URL: Homepage, https://github.com/handy-computer/transcribe.cpp
 Project-URL: Repository, https://github.com/handy-computer/transcribe.cpp
@@ -21,9 +21,9 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9
-Requires-Dist: transcribe-cpp-native==0.1.2.*
+Requires-Dist: transcribe-cpp-native==0.2.0.*
 Provides-Extra: cu12
-Requires-Dist: transcribe-cpp-native-cu12==0.1.2.*; extra == 'cu12'
+Requires-Dist: transcribe-cpp-native-cu12==0.2.0.*; extra == 'cu12'
 Provides-Extra: test
 Requires-Dist: numpy; extra == 'test'
 Requires-Dist: pytest>=7; extra == 'test'
@@ -37,6 +37,10 @@ a C/C++ speech-to-text library built on ggml.
 > **Status: in development.** Until wheels are published, use a locally built
 > `libtranscribe` through repo auto-discovery or `TRANSCRIBE_LIBRARY`.
 
+Upgrading from 0.1? See the
+[0.2 migration guide](https://github.com/handy-computer/transcribe.cpp/blob/main/docs/migrating-to-0.2.md),
+including the replacement of `gpu_device=` with exact device objects.
+
 ```python
 import transcribe_cpp
 
@@ -75,9 +79,17 @@ Long transcriptions can be cancelled from another thread with
 
 ## Backends
 
-`Model(backend=...)` picks the compute device (`"auto"` uses the best
-available). `transcribe_cpp.backends()` lists registered backends and
-`backend_available(kind)` checks one kind.
+`Model(backend=...)` applies a backend policy (`"auto"` uses the best
+available). `transcribe_cpp.backends()` returns process-local device objects;
+pass one as `Model(device=device)` for exact selection with no fallback. Persist
+a device's `device_id`, not its runtime handle or index. `backend_available(kind)`
+checks whether a backend policy can currently be satisfied.
+
+```python
+device = next(d for d in transcribe_cpp.backends() if d.device_type == "cpu")
+with transcribe_cpp.Model("model.gguf", device=device) as model:
+    print(model.device)
+```
 
 | Variable | Effect |
 |---|---|

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/README.md

@@ -6,6 +6,10 @@ a C/C++ speech-to-text library built on ggml.
 > **Status: in development.** Until wheels are published, use a locally built
 > `libtranscribe` through repo auto-discovery or `TRANSCRIBE_LIBRARY`.
 
+Upgrading from 0.1? See the
+[0.2 migration guide](https://github.com/handy-computer/transcribe.cpp/blob/main/docs/migrating-to-0.2.md),
+including the replacement of `gpu_device=` with exact device objects.
+
 ```python
 import transcribe_cpp
 
@@ -44,9 +48,17 @@ Long transcriptions can be cancelled from another thread with
 
 ## Backends
 
-`Model(backend=...)` picks the compute device (`"auto"` uses the best
-available). `transcribe_cpp.backends()` lists registered backends and
-`backend_available(kind)` checks one kind.
+`Model(backend=...)` applies a backend policy (`"auto"` uses the best
+available). `transcribe_cpp.backends()` returns process-local device objects;
+pass one as `Model(device=device)` for exact selection with no fallback. Persist
+a device's `device_id`, not its runtime handle or index. `backend_available(kind)`
+checks whether a backend policy can currently be satisfied.
+
+```python
+device = next(d for d in transcribe_cpp.backends() if d.device_type == "cpu")
+with transcribe_cpp.Model("model.gguf", device=device) as model:
+    print(model.device)
+```
 
 | Variable | Effect |
 |---|---|

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "transcribe-cpp"
-version = "0.1.2"
+version = "0.2.0"
 description = "Python bindings for transcribe.cpp"
 readme = "README.md"
 # 3.8 is EOL (2024-10); 3.9 is the floor. The binding is ctypes-only, so there
@@ -34,13 +34,13 @@ classifiers = [
 # packaging fix still resolves); the import-time version/header-hash check in
 # _library.py is the runtime backstop. check_version_sync.py gates this pin
 # against include/transcribe.h.
-dependencies = ["transcribe-cpp-native==0.1.2.*"]
+dependencies = ["transcribe-cpp-native==0.2.0.*"]
 
 [project.optional-dependencies]
 # Opt-in accelerator providers — ADDITIVE: they install alongside the default
 # provider and the best one wins at runtime. Same base-version pin contract
 # as the hard dependency (gated by check_version_sync.py).
-cu12 = ["transcribe-cpp-native-cu12==0.1.2.*"]
+cu12 = ["transcribe-cpp-native-cu12==0.2.0.*"]
 # Test-only deps. Run with: uv run --extra test pytest (from bindings/python).
 # numpy is here so the numpy PCM-input tests run in every lane instead of
 # silently skipping wherever numpy happens to be absent.

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/src/transcribe_cpp/__init__.py

@@ -24,7 +24,7 @@ import ctypes
 import os
 import threading
 import weakref
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Literal, Optional, Sequence, Union
 
 from . import _abi, _generated
@@ -46,17 +46,19 @@ from .errors import (
     raise_for_status,
 )
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 # String-enum types, exported so callers (and type checkers) can name them.
-Backend = Literal["auto", "cpu", "metal", "vulkan", "cpu_accel", "cuda"]
+Backend = Literal["auto", "cpu", "metal", "vulkan", "cpu_accel", "cuda", "rocm"]
 KVType = Literal["auto", "f32", "f16"]
 Task = Literal["transcribe", "translate"]
 Timestamps = Literal["none", "auto", "segment", "word", "token"]
+Diarize = Literal["default", "off", "on"]
+SortformerPreset = Literal["default", "very_high_latency", "high_latency", "low_latency"]
 CommitPolicy = Literal["auto", "on_finalize", "stable_prefix"]
 Feature = Literal[
     "initial_prompt", "temperature_fallback", "long_form",
-    "cancellation", "pnc", "itn",
+    "cancellation", "pnc", "itn", "diarization",
 ]
 
 __all__ = [
@@ -66,6 +68,7 @@ __all__ = [
     "Session",
     "Result",
     "Segment",
+    "SpeakerSegment",
     "Word",
     "Token",
     "Capabilities",
@@ -79,11 +82,14 @@ __all__ = [
     "MoonshineStreamingOptions",
     "ParakeetStreamOptions",
     "ParakeetBufferedStreamOptions",
+    "SortformerStreamOptions",
     "VoxtralRealtimeStreamOptions",
     "Backend",
+    "SortformerPreset",
     "KVType",
     "Task",
     "Timestamps",
+    "Diarize",
     "CommitPolicy",
     "Feature",
     "TranscribeError",
@@ -165,6 +171,7 @@ _RunParams = _generated.transcribe_run_params
 _Capabilities = _generated.transcribe_capabilities
 _Timings = _generated.transcribe_timings
 _Segment = _generated.transcribe_segment
+_SpeakerSegment = _generated.transcribe_speaker_segment
 _Word = _generated.transcribe_word
 _Token = _generated.transcribe_token
 _StreamParams = _generated.transcribe_stream_params
@@ -180,6 +187,7 @@ _BACKENDS = {
     "vulkan": _generated.TRANSCRIBE_BACKEND_VULKAN,
     "cpu_accel": _generated.TRANSCRIBE_BACKEND_CPU_ACCEL,
     "cuda": _generated.TRANSCRIBE_BACKEND_CUDA,
+    "rocm": _generated.TRANSCRIBE_BACKEND_ROCM,
 }
 _KV_TYPES = {
     "auto": _generated.TRANSCRIBE_KV_TYPE_AUTO,
@@ -198,6 +206,11 @@ _TIMESTAMPS = {
     "token": _generated.TRANSCRIBE_TIMESTAMPS_TOKEN,
 }
 _TIMESTAMP_NAMES = {v: k for k, v in _TIMESTAMPS.items()}
+_DIARIZE = {
+    "default": _generated.TRANSCRIBE_DIARIZE_MODE_DEFAULT,
+    "off": _generated.TRANSCRIBE_DIARIZE_MODE_OFF,
+    "on": _generated.TRANSCRIBE_DIARIZE_MODE_ON,
+}
 _COMMIT_POLICIES = {
     "auto": _generated.TRANSCRIBE_STREAM_COMMIT_AUTO,
     "on_finalize": _generated.TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE,
@@ -220,6 +233,7 @@ _FEATURES = {
     "cancellation": _generated.TRANSCRIBE_FEATURE_CANCELLATION,
     "pnc": _generated.TRANSCRIBE_FEATURE_PNC,
     "itn": _generated.TRANSCRIBE_FEATURE_ITN,
+    "diarization": _generated.TRANSCRIBE_FEATURE_DIARIZATION,
 }
 
 
@@ -252,13 +266,17 @@ _DEVICE_TYPE_NAMES = {
 }
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=False)
 class BackendDevice:
-    """One registered compute device (owned copies of the C strings)."""
+    """One registered compute device (owned copies of the C strings).
+
+    Equality compares opaque native identity; display index and live memory
+    snapshots do not affect whether two values name the same device.
+    """
 
     name: str
     description: str
-    kind: str  # "cpu" | "accel" | "metal" | "vulkan" | "cuda" | "sycl" | "gpu" | "unknown"
+    kind: str  # "cpu" | "accel" | "metal" | "vulkan" | "cuda" | "rocm" | "sycl" | "gpu" | "unknown"
     # Vendor-agnostic class: "cpu" | "gpu" | "igpu" | "accel", or "unknown" for a
     # value reported by a runtime newer than this binding (tell such devices
     # apart by device_id / name, not by this axis).
@@ -269,17 +287,26 @@ class BackendDevice:
     # (via backends() or Model.device) to refresh; backend-defined and not
     # comparable across device kinds.
     memory_free: int
-    # Registry index of this device — the value to pass as ``Model(...,
-    # gpu_device=index)`` to select it (0 selects the auto / first device).
-    # None when the device came from Model.device, since the underlying
-    # transcribe_model_get_device() does not expose an index; correlate such a
-    # device back to backends() by device_id / name instead. The index is
-    # order-dependent and not stable across driver updates or hosts.
+    # Registry index for display. Exact model selection uses the BackendDevice
+    # itself; indices are process-local and not stable across driver updates.
     index: Optional[int] = None
+    # Opaque process-local native device handle. Applications persist device_id,
+    # never this value.
+    _handle: Optional[int] = field(default=None, repr=False, compare=False)
+
+    def __eq__(self, other: object) -> bool:
+        if self is other:
+            return True
+        if not isinstance(other, BackendDevice):
+            return NotImplemented
+        return self._handle is not None and self._handle == other._handle
+
+    def __hash__(self) -> int:
+        return hash(self._handle) if self._handle is not None else object.__hash__(self)
 
 
-def _backend_device_from_raw(dev, index: Optional[int] = None) -> BackendDevice:
-    """Build a BackendDevice from a library-filled transcribe_backend_device."""
+def _backend_device_from_raw(dev, handle: Optional[int], index: Optional[int] = None) -> BackendDevice:
+    """Build a BackendDevice from a library-filled transcribe_device_info."""
     return BackendDevice(
         name=_decode(dev.name),
         description=_decode(dev.description),
@@ -289,6 +316,7 @@ def _backend_device_from_raw(dev, index: Optional[int] = None) -> BackendDevice:
         memory_total=int(dev.memory_total),
         memory_free=int(dev.memory_free),
         index=index,
+        _handle=handle,
     )
 
 
@@ -300,12 +328,15 @@ def backends() -> list[BackendDevice]:
     Each device's ``memory_free`` is live as of the call; call again to poll
     a device's available memory over time."""
     devices = []
-    for i in range(_lib.transcribe_backend_device_count()):
-        dev = _generated.transcribe_backend_device()
-        _lib.transcribe_backend_device_init(_byref(dev))
-        _check(_lib.transcribe_get_backend_device(i, _byref(dev)),
+    for i in range(_lib.transcribe_device_count()):
+        handle = _lib.transcribe_device_get(i)
+        if not handle:
+            continue
+        dev = _generated.transcribe_device_info()
+        _lib.transcribe_device_info_init(_byref(dev))
+        _check(_lib.transcribe_device_get_info(handle, _byref(dev)),
                f"reading backend device {i}")
-        devices.append(_backend_device_from_raw(dev, index=i))
+        devices.append(_backend_device_from_raw(dev, int(handle), index=i))
     return devices
 
 
@@ -433,6 +464,18 @@ class Segment:
     n_words: int
     first_token: int
     n_tokens: int
+    speaker_id: int
+
+
+@dataclass(frozen=True)
+class SpeakerSegment:
+    """One diarized turn. Times are zero when the model attributes text but
+    does not provide speaker timing; ``p`` is NaN when unavailable."""
+
+    t0_ms: int
+    t1_ms: int
+    speaker_id: int
+    p: float
 
 
 @dataclass(frozen=True)
@@ -498,9 +541,14 @@ class Result:
     returned, so it stays valid after later runs."""
 
     text: str
+    #: The model's decoded output before family post-processing (diarization
+    #: markers, timestamp/special tokens, tag filtering, whitespace trims).
+    #: Equal to ``text`` modulo whitespace for families that emit clean text.
+    raw_text: str
     language: str
     timestamp_kind: str
     segments: tuple[Segment, ...]
+    speaker_segments: tuple[SpeakerSegment, ...]
     words: tuple[Word, ...]
     tokens: tuple[Token, ...]
     timings: Timings
@@ -547,6 +595,14 @@ def _segment_from(s) -> Segment:
         text=_decode(s.text), t0_ms=s.t0_ms, t1_ms=s.t1_ms,
         first_word=s.first_word, n_words=s.n_words,
         first_token=s.first_token, n_tokens=s.n_tokens,
+        speaker_id=s.speaker_id,
+    )
+
+
+def _speaker_segment_from(s) -> SpeakerSegment:
+    return SpeakerSegment(
+        t0_ms=s.t0_ms, t1_ms=s.t1_ms,
+        speaker_id=s.speaker_id, p=s.p,
     )
 
 
@@ -582,7 +638,7 @@ def _stream_update_from(u) -> StreamUpdate:
 
 
 def _build_run_params(task, language, target_language, timestamps,
-                      keep_special_tags, spec_k_drafts):
+                      keep_special_tags, spec_k_drafts, diarize="default"):
     if not isinstance(spec_k_drafts, int) or spec_k_drafts < -1:
         raise InvalidArgument(
             f"spec_k_drafts must be -1 (family default), 0 (disabled), or a "
@@ -592,6 +648,7 @@ def _build_run_params(task, language, target_language, timestamps,
     _lib.transcribe_run_params_init(_byref(params))
     params.task = _enum(_TASKS, task, "task")
     params.timestamps = _enum(_TIMESTAMPS, timestamps, "timestamps")
+    params.diarize = _enum(_DIARIZE, diarize, "diarize")
     params.language = language.encode("utf-8") if language else None
     params.target_language = target_language.encode("utf-8") if target_language else None
     params.keep_special_tags = keep_special_tags
@@ -762,6 +819,40 @@ class VoxtralRealtimeStreamOptions(FamilyExtension):
             ext.min_decode_interval_ms = self.min_decode_interval_ms
 
 
+class SortformerStreamOptions(FamilyExtension):
+    """Sortformer streaming operating-point options (run slot).
+
+    Sortformer is a diarizer: a run produces speaker segments, no text.
+    ``preset`` selects the latency / accuracy trade-off from the model's
+    published menu; ``"default"`` keeps the GGUF-shipped checkpoint
+    configuration. ``"very_high_latency"`` (~30 s lookahead) is the
+    offline-file operating point; ``"low_latency"`` (~1 s) is the
+    real-time point and costs substantially more compute per audio
+    second."""
+
+    _slot = "run"
+    _kind = _generated.TRANSCRIBE_EXT_KIND_SORTFORMER_STREAM
+    _struct = _generated.transcribe_sortformer_stream_ext
+    _init = "transcribe_sortformer_stream_ext_init"
+
+    _presets = {
+        "default": _generated.TRANSCRIBE_SORTFORMER_PRESET_DEFAULT,
+        "very_high_latency": _generated.TRANSCRIBE_SORTFORMER_PRESET_VERY_HIGH_LATENCY,
+        "high_latency": _generated.TRANSCRIBE_SORTFORMER_PRESET_HIGH_LATENCY,
+        "low_latency": _generated.TRANSCRIBE_SORTFORMER_PRESET_LOW_LATENCY,
+    }
+
+    def __init__(self, *, preset: SortformerPreset | None = None):
+        if preset is not None and preset not in self._presets:
+            raise ValueError(f"unknown sortformer preset {preset!r}; "
+                             f"expected one of {sorted(self._presets)}")
+        self.preset = preset
+
+    def _apply(self, ext) -> None:
+        if self.preset is not None:
+            ext.preset = self._presets[self.preset]
+
+
 # --- high-level handles ---------------------------------------------------
 
 
@@ -782,7 +873,7 @@ class Model:
     """
 
     def __init__(self, path: str | os.PathLike, *,
-                 backend: Backend = "auto", gpu_device: int = 0):
+                 backend: Backend = "auto", device: BackendDevice | None = None):
         # Live sessions, tracked weakly: close() must free them before the
         # model, because transcribe_model_free is only valid once every
         # derived session is gone (use-after-free otherwise). Created before
@@ -795,7 +886,10 @@ class Model:
         params = _ModelLoadParams()
         _lib.transcribe_model_load_params_init(_byref(params))
         params.backend = _enum(_BACKENDS, backend, backend_source)
-        params.gpu_device = gpu_device
+        if device is not None:
+            if not isinstance(device, BackendDevice) or device._handle is None:
+                raise TypeError("device must be a BackendDevice returned by backends()")
+            params.device = device._handle
 
         handle = ctypes.c_void_p()
         status = _lib.transcribe_model_load_file(
@@ -830,11 +924,14 @@ class Model:
         live snapshot, so read this again to poll how much device memory is
         left after the model loaded. Raises if the model has no resolved
         compute device."""
-        dev = _generated.transcribe_backend_device()
-        _lib.transcribe_backend_device_init(_byref(dev))
-        _check(_lib.transcribe_model_get_device(self._h, _byref(dev)),
-               "model_get_device")
-        return _backend_device_from_raw(dev)
+        handle = _lib.transcribe_model_device(self._h)
+        if not handle:
+            raise BackendError("model has no resolved compute device")
+        dev = _generated.transcribe_device_info()
+        _lib.transcribe_device_info_init(_byref(dev))
+        _check(_lib.transcribe_device_get_info(handle, _byref(dev)),
+               "device_get_info")
+        return _backend_device_from_raw(dev, int(handle))
 
     @property
     def capabilities(self) -> Capabilities:
@@ -982,6 +1079,7 @@ class Session:
             language: str | None = None,
             target_language: str | None = None,
             timestamps: Timestamps = "auto",
+            diarize: Diarize = "default",
             keep_special_tags: bool = False,
             spec_k_drafts: int = -1,
             family: FamilyExtension | None = None) -> Result:
@@ -999,7 +1097,7 @@ class Session:
         self._cancel.clear()
         array, n_samples = _pcm_to_carray(pcm)
         params = _build_run_params(task, language, target_language, timestamps,
-                                   keep_special_tags, spec_k_drafts)
+                                   keep_special_tags, spec_k_drafts, diarize)
         ext = self._resolve_family(family, "run") if family is not None else None
         if ext is not None:
             params.family = ctypes.cast(
@@ -1018,6 +1116,7 @@ class Session:
                   language: str | None = None,
                   target_language: str | None = None,
                   timestamps: Timestamps = "auto",
+                  diarize: Diarize = "default",
                   keep_special_tags: bool = False,
                   spec_k_drafts: int = -1,
                   family: FamilyExtension | None = None,
@@ -1054,7 +1153,7 @@ class Session:
             counts[k] = n
 
         params = _build_run_params(task, language, target_language, timestamps,
-                                   keep_special_tags, spec_k_drafts)
+                                   keep_special_tags, spec_k_drafts, diarize)
         ext = self._resolve_family(family, "run") if family is not None else None
         if ext is not None:
             params.family = ctypes.cast(
@@ -1105,6 +1204,7 @@ class Session:
 
     def stream(self, *, task: Task = "transcribe", language: str | None = None,
                target_language: str | None = None, timestamps: Timestamps = "none",
+               diarize: Diarize = "default",
                keep_special_tags: bool = False, commit_policy: CommitPolicy = "auto",
                stable_prefix_agreement_n: int = 0,
                family: FamilyExtension | None = None) -> Stream:
@@ -1119,7 +1219,7 @@ class Session:
         # spec_k_drafts is an offline-decode knob; streaming always uses the
         # family default (-1).
         run_params = _build_run_params(task, language, target_language, timestamps,
-                                       keep_special_tags, -1)
+                                       keep_special_tags, -1, diarize)
         sp = _StreamParams()
         _lib.transcribe_stream_params_init(_byref(sp))
         sp.commit_policy = _enum(_COMMIT_POLICIES, commit_policy, "commit_policy")
@@ -1151,7 +1251,10 @@ class Session:
             get_word = lambda j, out: _lib.transcribe_get_word(h, j, out)
             n_tok = lambda: _lib.transcribe_n_tokens(h)
             get_tok = lambda j, out: _lib.transcribe_get_token(h, j, out)
+            n_speaker = lambda: _lib.transcribe_n_speaker_segments(h)
+            get_speaker = lambda j, out: _lib.transcribe_get_speaker_segment(h, j, out)
             full_text = _lib.transcribe_full_text(h)
+            raw_text = _lib.transcribe_raw_text(h)
             language = _lib.transcribe_detected_language(h)
             kind = _lib.transcribe_returned_timestamp_kind(h)
             get_tim = lambda out: _lib.transcribe_get_timings(h, out)
@@ -1162,7 +1265,10 @@ class Session:
             get_word = lambda j, out: _lib.transcribe_batch_get_word(h, utt, j, out)
             n_tok = lambda: _lib.transcribe_batch_n_tokens(h, utt)
             get_tok = lambda j, out: _lib.transcribe_batch_get_token(h, utt, j, out)
+            n_speaker = lambda: _lib.transcribe_batch_n_speaker_segments(h, utt)
+            get_speaker = lambda j, out: _lib.transcribe_batch_get_speaker_segment(h, utt, j, out)
             full_text = _lib.transcribe_batch_full_text(h, utt)
+            raw_text = _lib.transcribe_batch_raw_text(h, utt)
             language = _lib.transcribe_batch_detected_language(h, utt)
             kind = _lib.transcribe_batch_returned_timestamp_kind(h, utt)
             get_tim = lambda out: _lib.transcribe_batch_get_timings(h, utt, out)
@@ -1188,15 +1294,24 @@ class Session:
             get_tok(j, _byref(tok))
             tokens.append(_token_from(tok))
 
+        speaker_segments = []
+        for j in range(n_speaker()):
+            speaker = _SpeakerSegment()
+            _lib.transcribe_speaker_segment_init(_byref(speaker))
+            get_speaker(j, _byref(speaker))
+            speaker_segments.append(_speaker_segment_from(speaker))
+
         tm = _Timings()
         _lib.transcribe_timings_init(_byref(tm))
         get_tim(_byref(tm))
 
         return Result(
             text=_decode(full_text),
+            raw_text=_decode(raw_text),
             language=_decode(language),
             timestamp_kind=_TIMESTAMP_NAMES.get(kind, "unknown"),
             segments=tuple(segments),
+            speaker_segments=tuple(speaker_segments),
             words=tuple(words),
             tokens=tuple(tokens),
             timings=_timings_from(tm),
@@ -1338,7 +1453,7 @@ def transcribe(
     pcm: PCMLike,
     *,
     backend: Backend = "auto",
-    gpu_device: int = 0,
+    device: BackendDevice | None = None,
     n_threads: int = 0,
     kv_type: KVType = "auto",
     n_ctx: int = 0,
@@ -1346,6 +1461,7 @@ def transcribe(
     language: str | None = None,
     target_language: str | None = None,
     timestamps: Timestamps = "auto",
+    diarize: Diarize = "default",
     keep_special_tags: bool = False,
     spec_k_drafts: int = -1,
     family: FamilyExtension | None = None,
@@ -1355,19 +1471,20 @@ def transcribe(
     *model* may be a path (loaded and freed within this call) or an existing
     Model (reused and left open). Loading a model is not free, so to transcribe
     many clips keep a Model and call ``model.session().run(...)`` yourself; this
-    helper is for the one-shot case. ``backend`` / ``gpu_device`` apply only when
+    helper is for the one-shot case. ``backend`` / ``device`` apply only when
     *model* is a path — they are ignored when an already-loaded Model is passed.
     ``family`` / ``spec_k_drafts`` pass through to :meth:`Session.run`.
     """
     session_opts = dict(n_threads=n_threads, kv_type=kv_type, n_ctx=n_ctx)
     run_opts = dict(task=task, language=language, target_language=target_language,
-                    timestamps=timestamps, keep_special_tags=keep_special_tags,
+                    timestamps=timestamps, diarize=diarize,
+                    keep_special_tags=keep_special_tags,
                     spec_k_drafts=spec_k_drafts, family=family)
 
     if isinstance(model, Model):
         with model.session(**session_opts) as session:
             return session.run(pcm, **run_opts)
 
-    with Model(model, backend=backend, gpu_device=gpu_device) as owned:
+    with Model(model, backend=backend, device=device) as owned:
         with owned.session(**session_opts) as session:
             return session.run(pcm, **run_opts)

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/src/transcribe_cpp/_generated.py

@@ -13,7 +13,7 @@ import ctypes as _c
 # Stable digest of the ABI surface below (structs, enums, macros, layout,
 # prototypes). A native provider package echoes this back so the API
 # package can reject an ABI-mismatched provider before dlopen.
-PUBLIC_HEADER_HASH = "86b16dd97ad1cb58"
+PUBLIC_HEADER_HASH = "7df72bf9e667b8c2"
 
 # === enum constants ===
 TRANSCRIBE_OK = 0
@@ -48,7 +48,8 @@ TRANSCRIBE_ABI_STREAM_UPDATE = 9
 TRANSCRIBE_ABI_STREAM_TEXT = 10
 TRANSCRIBE_ABI_SESSION_LIMITS = 11
 TRANSCRIBE_ABI_EXT = 12
-TRANSCRIBE_ABI_BACKEND_DEVICE = 13
+TRANSCRIBE_ABI_DEVICE_INFO = 13
+TRANSCRIBE_ABI_SPEAKER_SEGMENT = 14
 TRANSCRIBE_LOG_LEVEL_NONE = 0
 TRANSCRIBE_LOG_LEVEL_INFO = 1
 TRANSCRIBE_LOG_LEVEL_WARN = 2
@@ -71,6 +72,9 @@ TRANSCRIBE_PNC_MODE_ON = 2
 TRANSCRIBE_ITN_MODE_DEFAULT = 0
 TRANSCRIBE_ITN_MODE_OFF = 1
 TRANSCRIBE_ITN_MODE_ON = 2
+TRANSCRIBE_DIARIZE_MODE_DEFAULT = 0
+TRANSCRIBE_DIARIZE_MODE_OFF = 1
+TRANSCRIBE_DIARIZE_MODE_ON = 2
 TRANSCRIBE_EXT_SLOT_RUN = 0
 TRANSCRIBE_EXT_SLOT_STREAM = 1
 TRANSCRIBE_BACKEND_AUTO = 0
@@ -79,6 +83,7 @@ TRANSCRIBE_BACKEND_METAL = 2
 TRANSCRIBE_BACKEND_VULKAN = 3
 TRANSCRIBE_BACKEND_CPU_ACCEL = 4
 TRANSCRIBE_BACKEND_CUDA = 5
+TRANSCRIBE_BACKEND_ROCM = 6
 TRANSCRIBE_DEVICE_TYPE_CPU = 0
 TRANSCRIBE_DEVICE_TYPE_GPU = 1
 TRANSCRIBE_DEVICE_TYPE_IGPU = 2
@@ -89,6 +94,7 @@ TRANSCRIBE_FEATURE_LONG_FORM = 2
 TRANSCRIBE_FEATURE_CANCELLATION = 3
 TRANSCRIBE_FEATURE_PNC = 4
 TRANSCRIBE_FEATURE_ITN = 5
+TRANSCRIBE_FEATURE_DIARIZATION = 6
 TRANSCRIBE_STREAM_IDLE = 0
 TRANSCRIBE_STREAM_ACTIVE = 1
 TRANSCRIBE_STREAM_FINISHED = 2
@@ -96,6 +102,10 @@ TRANSCRIBE_STREAM_FAILED = 3
 TRANSCRIBE_STREAM_COMMIT_AUTO = 0
 TRANSCRIBE_STREAM_COMMIT_ON_FINALIZE = 1
 TRANSCRIBE_STREAM_COMMIT_STABLE_PREFIX = 2
+TRANSCRIBE_SORTFORMER_PRESET_DEFAULT = 0
+TRANSCRIBE_SORTFORMER_PRESET_VERY_HIGH_LATENCY = 1
+TRANSCRIBE_SORTFORMER_PRESET_HIGH_LATENCY = 2
+TRANSCRIBE_SORTFORMER_PRESET_LOW_LATENCY = 3
 TRANSCRIBE_WHISPER_PROMPT_FIRST_SEGMENT = 0
 TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS = 1
 
@@ -103,13 +113,14 @@ TRANSCRIBE_WHISPER_PROMPT_ALL_SEGMENTS = 1
 TRANSCRIBE_EXT_KIND_MOONSHINE_STREAMING_STREAM = 1414746957
 TRANSCRIBE_EXT_KIND_PARAKEET_BUFFERED_STREAM = 1396853584
 TRANSCRIBE_EXT_KIND_PARAKEET_STREAM = 1414744912
+TRANSCRIBE_EXT_KIND_SORTFORMER_STREAM = 1414743635
 TRANSCRIBE_EXT_KIND_VOXTRAL_REALTIME_STREAM = 1414746710
 TRANSCRIBE_EXT_KIND_WHISPER_RUN = 1314015319
 
 # === structs ===
 class transcribe_ext(_c.Structure):
     pass
-class transcribe_backend_device(_c.Structure):
+class transcribe_device_info(_c.Structure):
     pass
 class transcribe_model_load_params(_c.Structure):
     pass
@@ -135,12 +146,16 @@ class transcribe_word(_c.Structure):
     pass
 class transcribe_token(_c.Structure):
     pass
+class transcribe_speaker_segment(_c.Structure):
+    pass
 class transcribe_moonshine_streaming_stream_ext(_c.Structure):
     pass
 class transcribe_parakeet_stream_ext(_c.Structure):
     pass
 class transcribe_parakeet_buffered_stream_ext(_c.Structure):
     pass
+class transcribe_sortformer_stream_ext(_c.Structure):
+    pass
 class transcribe_voxtral_realtime_stream_ext(_c.Structure):
     pass
 class transcribe_whisper_run_ext(_c.Structure):
@@ -149,22 +164,24 @@ class transcribe_whisper_chunk_trace(_c.Structure):
     pass
 
 transcribe_ext._fields_ = [("size", _c.c_uint64), ("kind", _c.c_uint32)]
-transcribe_backend_device._fields_ = [("struct_size", _c.c_uint64), ("name", _c.c_char_p), ("description", _c.c_char_p), ("kind", _c.c_char_p), ("device_id", _c.c_char_p), ("memory_total", _c.c_uint64), ("memory_free", _c.c_uint64), ("device_type", _c.c_int)]
-transcribe_model_load_params._fields_ = [("struct_size", _c.c_uint64), ("backend", _c.c_int), ("gpu_device", _c.c_int)]
+transcribe_device_info._fields_ = [("struct_size", _c.c_uint64), ("name", _c.c_char_p), ("description", _c.c_char_p), ("kind", _c.c_char_p), ("device_id", _c.c_char_p), ("memory_total", _c.c_uint64), ("memory_free", _c.c_uint64), ("device_type", _c.c_int)]
+transcribe_model_load_params._fields_ = [("struct_size", _c.c_uint64), ("backend", _c.c_int), ("device", _c.c_void_p)]
 transcribe_session_params._fields_ = [("struct_size", _c.c_uint64), ("n_threads", _c.c_int), ("kv_type", _c.c_int), ("n_ctx", _c.c_int32)]
-transcribe_run_params._fields_ = [("struct_size", _c.c_uint64), ("task", _c.c_int), ("timestamps", _c.c_int), ("pnc", _c.c_int), ("itn", _c.c_int), ("language", _c.c_char_p), ("target_language", _c.c_char_p), ("keep_special_tags", _c.c_bool), ("family", _c.POINTER(transcribe_ext)), ("spec_k_drafts", _c.c_int32)]
+transcribe_run_params._fields_ = [("struct_size", _c.c_uint64), ("task", _c.c_int), ("timestamps", _c.c_int), ("pnc", _c.c_int), ("itn", _c.c_int), ("diarize", _c.c_int), ("language", _c.c_char_p), ("target_language", _c.c_char_p), ("keep_special_tags", _c.c_bool), ("family", _c.POINTER(transcribe_ext)), ("spec_k_drafts", _c.c_int32)]
 transcribe_capabilities._fields_ = [("struct_size", _c.c_uint64), ("native_sample_rate", _c.c_int32), ("n_languages", _c.c_int), ("languages", _c.POINTER(_c.c_char_p)), ("max_timestamp_kind", _c.c_int), ("supports_language_detect", _c.c_bool), ("supports_translate", _c.c_bool), ("supports_streaming", _c.c_bool), ("supports_spec_decode", _c.c_bool), ("max_audio_ms", _c.c_int64), ("n_translate_target_languages", _c.c_int), ("translate_target_languages", _c.POINTER(_c.c_char_p))]
 transcribe_session_limits._fields_ = [("struct_size", _c.c_uint64), ("effective_n_ctx", _c.c_int32), ("effective_max_audio_ms", _c.c_int64), ("max_kv_bytes", _c.c_int64)]
 transcribe_stream_params._fields_ = [("struct_size", _c.c_uint64), ("family", _c.POINTER(transcribe_ext)), ("commit_policy", _c.c_int), ("stable_prefix_agreement_n", _c.c_uint32)]
 transcribe_stream_update._fields_ = [("struct_size", _c.c_uint64), ("result_changed", _c.c_bool), ("is_final", _c.c_bool), ("revision", _c.c_int32), ("input_received_ms", _c.c_int64), ("audio_committed_ms", _c.c_int64), ("buffered_ms", _c.c_int64), ("committed_changed", _c.c_bool), ("tentative_changed", _c.c_bool)]
 transcribe_stream_text._fields_ = [("struct_size", _c.c_uint64), ("full_text", _c.c_char_p), ("full_text_bytes", _c.c_uint64), ("committed_text", _c.c_char_p), ("committed_text_bytes", _c.c_uint64), ("tentative_text", _c.c_char_p), ("tentative_text_bytes", _c.c_uint64), ("raw_tentative_start_bytes", _c.c_uint64)]
 transcribe_timings._fields_ = [("struct_size", _c.c_uint64), ("load_ms", _c.c_float), ("mel_ms", _c.c_float), ("encode_ms", _c.c_float), ("decode_ms", _c.c_float)]
-transcribe_segment._fields_ = [("struct_size", _c.c_uint64), ("t0_ms", _c.c_int64), ("t1_ms", _c.c_int64), ("first_word", _c.c_int), ("n_words", _c.c_int), ("first_token", _c.c_int), ("n_tokens", _c.c_int), ("text", _c.c_char_p)]
+transcribe_segment._fields_ = [("struct_size", _c.c_uint64), ("t0_ms", _c.c_int64), ("t1_ms", _c.c_int64), ("first_word", _c.c_int), ("n_words", _c.c_int), ("first_token", _c.c_int), ("n_tokens", _c.c_int), ("text", _c.c_char_p), ("speaker_id", _c.c_int32)]
 transcribe_word._fields_ = [("struct_size", _c.c_uint64), ("t0_ms", _c.c_int64), ("t1_ms", _c.c_int64), ("seg_index", _c.c_int), ("first_token", _c.c_int), ("n_tokens", _c.c_int), ("text", _c.c_char_p)]
 transcribe_token._fields_ = [("struct_size", _c.c_uint64), ("id", _c.c_int), ("p", _c.c_float), ("t0_ms", _c.c_int64), ("t1_ms", _c.c_int64), ("seg_index", _c.c_int), ("word_index", _c.c_int), ("text", _c.c_char_p)]
+transcribe_speaker_segment._fields_ = [("struct_size", _c.c_uint64), ("t0_ms", _c.c_int64), ("t1_ms", _c.c_int64), ("speaker_id", _c.c_int32), ("p", _c.c_float)]
 transcribe_moonshine_streaming_stream_ext._fields_ = [("ext", transcribe_ext), ("min_decode_interval_ms", _c.c_int32)]
 transcribe_parakeet_stream_ext._fields_ = [("ext", transcribe_ext), ("att_context_right", _c.c_int32)]
 transcribe_parakeet_buffered_stream_ext._fields_ = [("ext", transcribe_ext), ("left_ms", _c.c_int32), ("chunk_ms", _c.c_int32), ("right_ms", _c.c_int32)]
+transcribe_sortformer_stream_ext._fields_ = [("ext", transcribe_ext), ("preset", _c.c_int)]
 transcribe_voxtral_realtime_stream_ext._fields_ = [("ext", transcribe_ext), ("num_delay_tokens", _c.c_int32), ("min_decode_interval_ms", _c.c_int32)]
 transcribe_whisper_run_ext._fields_ = [("ext", transcribe_ext), ("initial_prompt", _c.c_char_p), ("prompt_tokens", _c.POINTER(_c.c_int32)), ("n_prompt_tokens", _c.c_size_t), ("prompt_condition", _c.c_int), ("condition_on_prev_tokens", _c.c_bool), ("max_prev_context_tokens", _c.c_int32), ("temperature", _c.c_float), ("temperature_inc", _c.c_float), ("compression_ratio_thold", _c.c_float), ("logprob_thold", _c.c_float), ("no_speech_thold", _c.c_float), ("seed", _c.c_uint32), ("max_initial_timestamp", _c.c_float)]
 transcribe_whisper_chunk_trace._fields_ = [("struct_size", _c.c_uint64), ("t0_ms", _c.c_int64), ("t1_ms", _c.c_int64), ("temperature_used", _c.c_float), ("compression_ratio", _c.c_float), ("avg_logprob", _c.c_float), ("no_speech_prob", _c.c_float), ("no_speech_triggered", _c.c_bool), ("n_fallbacks", _c.c_int32)]
@@ -173,7 +190,7 @@ transcribe_whisper_chunk_trace._fields_ = [("struct_size", _c.c_uint64), ("t0_ms
 # transcribe_abi_struct id per struct (for the native size/align check).
 ABI_STRUCT_IDS = {
     'transcribe_ext': 12,
-    'transcribe_backend_device': 13,
+    'transcribe_device_info': 13,
     'transcribe_model_load_params': 0,
     'transcribe_session_params': 1,
     'transcribe_run_params': 2,
@@ -186,27 +203,30 @@ ABI_STRUCT_IDS = {
     'transcribe_segment': 6,
     'transcribe_word': 7,
     'transcribe_token': 8,
+    'transcribe_speaker_segment': 14,
 }
 
 # C-compiler layout captured at generation (for offset self-check).
 STRUCT_LAYOUT = {
     'transcribe_ext': {'size': 16, 'align': 8, 'offsets': {'size': 0, 'kind': 8}},
-    'transcribe_backend_device': {'size': 64, 'align': 8, 'offsets': {'struct_size': 0, 'name': 8, 'description': 16, 'kind': 24, 'device_id': 32, 'memory_total': 40, 'memory_free': 48, 'device_type': 56}},
-    'transcribe_model_load_params': {'size': 16, 'align': 8, 'offsets': {'struct_size': 0, 'backend': 8, 'gpu_device': 12}},
+    'transcribe_device_info': {'size': 64, 'align': 8, 'offsets': {'struct_size': 0, 'name': 8, 'description': 16, 'kind': 24, 'device_id': 32, 'memory_total': 40, 'memory_free': 48, 'device_type': 56}},
+    'transcribe_model_load_params': {'size': 24, 'align': 8, 'offsets': {'struct_size': 0, 'backend': 8, 'device': 16}},
     'transcribe_session_params': {'size': 24, 'align': 8, 'offsets': {'struct_size': 0, 'n_threads': 8, 'kv_type': 12, 'n_ctx': 16}},
-    'transcribe_run_params': {'size': 64, 'align': 8, 'offsets': {'struct_size': 0, 'task': 8, 'timestamps': 12, 'pnc': 16, 'itn': 20, 'language': 24, 'target_language': 32, 'keep_special_tags': 40, 'family': 48, 'spec_k_drafts': 56}},
+    'transcribe_run_params': {'size': 72, 'align': 8, 'offsets': {'struct_size': 0, 'task': 8, 'timestamps': 12, 'pnc': 16, 'itn': 20, 'diarize': 24, 'language': 32, 'target_language': 40, 'keep_special_tags': 48, 'family': 56, 'spec_k_drafts': 64}},
     'transcribe_capabilities': {'size': 56, 'align': 8, 'offsets': {'struct_size': 0, 'native_sample_rate': 8, 'n_languages': 12, 'languages': 16, 'max_timestamp_kind': 24, 'supports_language_detect': 28, 'supports_translate': 29, 'supports_streaming': 30, 'supports_spec_decode': 31, 'max_audio_ms': 32, 'n_translate_target_languages': 40, 'translate_target_languages': 48}},
     'transcribe_session_limits': {'size': 32, 'align': 8, 'offsets': {'struct_size': 0, 'effective_n_ctx': 8, 'effective_max_audio_ms': 16, 'max_kv_bytes': 24}},
     'transcribe_stream_params': {'size': 24, 'align': 8, 'offsets': {'struct_size': 0, 'family': 8, 'commit_policy': 16, 'stable_prefix_agreement_n': 20}},
     'transcribe_stream_update': {'size': 48, 'align': 8, 'offsets': {'struct_size': 0, 'result_changed': 8, 'is_final': 9, 'revision': 12, 'input_received_ms': 16, 'audio_committed_ms': 24, 'buffered_ms': 32, 'committed_changed': 40, 'tentative_changed': 41}},
     'transcribe_stream_text': {'size': 64, 'align': 8, 'offsets': {'struct_size': 0, 'full_text': 8, 'full_text_bytes': 16, 'committed_text': 24, 'committed_text_bytes': 32, 'tentative_text': 40, 'tentative_text_bytes': 48, 'raw_tentative_start_bytes': 56}},
     'transcribe_timings': {'size': 24, 'align': 8, 'offsets': {'struct_size': 0, 'load_ms': 8, 'mel_ms': 12, 'encode_ms': 16, 'decode_ms': 20}},
-    'transcribe_segment': {'size': 48, 'align': 8, 'offsets': {'struct_size': 0, 't0_ms': 8, 't1_ms': 16, 'first_word': 24, 'n_words': 28, 'first_token': 32, 'n_tokens': 36, 'text': 40}},
+    'transcribe_segment': {'size': 56, 'align': 8, 'offsets': {'struct_size': 0, 't0_ms': 8, 't1_ms': 16, 'first_word': 24, 'n_words': 28, 'first_token': 32, 'n_tokens': 36, 'text': 40, 'speaker_id': 48}},
     'transcribe_word': {'size': 48, 'align': 8, 'offsets': {'struct_size': 0, 't0_ms': 8, 't1_ms': 16, 'seg_index': 24, 'first_token': 28, 'n_tokens': 32, 'text': 40}},
     'transcribe_token': {'size': 48, 'align': 8, 'offsets': {'struct_size': 0, 'id': 8, 'p': 12, 't0_ms': 16, 't1_ms': 24, 'seg_index': 32, 'word_index': 36, 'text': 40}},
+    'transcribe_speaker_segment': {'size': 32, 'align': 8, 'offsets': {'struct_size': 0, 't0_ms': 8, 't1_ms': 16, 'speaker_id': 24, 'p': 28}},
     'transcribe_moonshine_streaming_stream_ext': {'size': 24, 'align': 8, 'offsets': {'ext': 0, 'min_decode_interval_ms': 16}},
     'transcribe_parakeet_stream_ext': {'size': 24, 'align': 8, 'offsets': {'ext': 0, 'att_context_right': 16}},
     'transcribe_parakeet_buffered_stream_ext': {'size': 32, 'align': 8, 'offsets': {'ext': 0, 'left_ms': 16, 'chunk_ms': 20, 'right_ms': 24}},
+    'transcribe_sortformer_stream_ext': {'size': 24, 'align': 8, 'offsets': {'ext': 0, 'preset': 16}},
     'transcribe_voxtral_realtime_stream_ext': {'size': 24, 'align': 8, 'offsets': {'ext': 0, 'num_delay_tokens': 16, 'min_decode_interval_ms': 20}},
     'transcribe_whisper_run_ext': {'size': 80, 'align': 8, 'offsets': {'ext': 0, 'initial_prompt': 16, 'prompt_tokens': 24, 'n_prompt_tokens': 32, 'prompt_condition': 40, 'condition_on_prev_tokens': 44, 'max_prev_context_tokens': 48, 'temperature': 52, 'temperature_inc': 56, 'compression_ratio_thold': 60, 'logprob_thold': 64, 'no_speech_thold': 68, 'seed': 72, 'max_initial_timestamp': 76}},
     'transcribe_whisper_chunk_trace': {'size': 48, 'align': 8, 'offsets': {'struct_size': 0, 't0_ms': 8, 't1_ms': 16, 'temperature_used': 24, 'compression_ratio': 28, 'avg_logprob': 32, 'no_speech_prob': 36, 'no_speech_triggered': 40, 'n_fallbacks': 44}},
@@ -221,16 +241,14 @@ def configure(lib):
     lib.transcribe_abi_struct_size.argtypes = [_c.c_int]
     lib.transcribe_backend_available.restype = _c.c_bool
     lib.transcribe_backend_available.argtypes = [_c.c_int]
-    lib.transcribe_backend_device_count.restype = _c.c_int
-    lib.transcribe_backend_device_count.argtypes = []
-    lib.transcribe_backend_device_init.restype = None
-    lib.transcribe_backend_device_init.argtypes = [_c.POINTER(transcribe_backend_device)]
     lib.transcribe_batch_detected_language.restype = _c.c_char_p
     lib.transcribe_batch_detected_language.argtypes = [_c.c_void_p, _c.c_int]
     lib.transcribe_batch_full_text.restype = _c.c_char_p
     lib.transcribe_batch_full_text.argtypes = [_c.c_void_p, _c.c_int]
     lib.transcribe_batch_get_segment.restype = _c.c_int
     lib.transcribe_batch_get_segment.argtypes = [_c.c_void_p, _c.c_int, _c.c_int, _c.POINTER(transcribe_segment)]
+    lib.transcribe_batch_get_speaker_segment.restype = _c.c_int
+    lib.transcribe_batch_get_speaker_segment.argtypes = [_c.c_void_p, _c.c_int, _c.c_int, _c.POINTER(transcribe_speaker_segment)]
     lib.transcribe_batch_get_timings.restype = _c.c_int
     lib.transcribe_batch_get_timings.argtypes = [_c.c_void_p, _c.c_int, _c.POINTER(transcribe_timings)]
     lib.transcribe_batch_get_token.restype = _c.c_int
@@ -241,10 +259,14 @@ def configure(lib):
     lib.transcribe_batch_n_results.argtypes = [_c.c_void_p]
     lib.transcribe_batch_n_segments.restype = _c.c_int
     lib.transcribe_batch_n_segments.argtypes = [_c.c_void_p, _c.c_int]
+    lib.transcribe_batch_n_speaker_segments.restype = _c.c_int
+    lib.transcribe_batch_n_speaker_segments.argtypes = [_c.c_void_p, _c.c_int]
     lib.transcribe_batch_n_tokens.restype = _c.c_int
     lib.transcribe_batch_n_tokens.argtypes = [_c.c_void_p, _c.c_int]
     lib.transcribe_batch_n_words.restype = _c.c_int
     lib.transcribe_batch_n_words.argtypes = [_c.c_void_p, _c.c_int]
+    lib.transcribe_batch_raw_text.restype = _c.c_char_p
+    lib.transcribe_batch_raw_text.argtypes = [_c.c_void_p, _c.c_int]
     lib.transcribe_batch_returned_timestamp_kind.restype = _c.c_int
     lib.transcribe_batch_returned_timestamp_kind.argtypes = [_c.c_void_p, _c.c_int]
     lib.transcribe_batch_status.restype = _c.c_int
@@ -255,16 +277,24 @@ def configure(lib):
     lib.transcribe_close.argtypes = [_c.c_void_p]
     lib.transcribe_detected_language.restype = _c.c_char_p
     lib.transcribe_detected_language.argtypes = [_c.c_void_p]
+    lib.transcribe_device_count.restype = _c.c_int
+    lib.transcribe_device_count.argtypes = []
+    lib.transcribe_device_get.restype = _c.c_void_p
+    lib.transcribe_device_get.argtypes = [_c.c_int]
+    lib.transcribe_device_get_info.restype = _c.c_int
+    lib.transcribe_device_get_info.argtypes = [_c.c_void_p, _c.POINTER(transcribe_device_info)]
+    lib.transcribe_device_info_init.restype = None
+    lib.transcribe_device_info_init.argtypes = [_c.POINTER(transcribe_device_info)]
     lib.transcribe_ext_check.restype = _c.c_int
     lib.transcribe_ext_check.argtypes = [_c.POINTER(transcribe_ext), _c.c_uint32, _c.c_uint64]
     lib.transcribe_full_text.restype = _c.c_char_p
     lib.transcribe_full_text.argtypes = [_c.c_void_p]
-    lib.transcribe_get_backend_device.restype = _c.c_int
-    lib.transcribe_get_backend_device.argtypes = [_c.c_int, _c.POINTER(transcribe_backend_device)]
     lib.transcribe_get_model.restype = _c.c_void_p
     lib.transcribe_get_model.argtypes = [_c.c_void_p]
     lib.transcribe_get_segment.restype = _c.c_int
     lib.transcribe_get_segment.argtypes = [_c.c_void_p, _c.c_int, _c.POINTER(transcribe_segment)]
+    lib.transcribe_get_speaker_segment.restype = _c.c_int
+    lib.transcribe_get_speaker_segment.argtypes = [_c.c_void_p, _c.c_int, _c.POINTER(transcribe_speaker_segment)]
     lib.transcribe_get_timings.restype = _c.c_int
     lib.transcribe_get_timings.argtypes = [_c.c_void_p, _c.POINTER(transcribe_timings)]
     lib.transcribe_get_token.restype = _c.c_int
@@ -287,12 +317,12 @@ def configure(lib):
     lib.transcribe_model_arch_string.argtypes = [_c.c_void_p]
     lib.transcribe_model_backend.restype = _c.c_char_p
     lib.transcribe_model_backend.argtypes = [_c.c_void_p]
+    lib.transcribe_model_device.restype = _c.c_void_p
+    lib.transcribe_model_device.argtypes = [_c.c_void_p]
     lib.transcribe_model_free.restype = None
     lib.transcribe_model_free.argtypes = [_c.c_void_p]
     lib.transcribe_model_get_capabilities.restype = _c.c_int
     lib.transcribe_model_get_capabilities.argtypes = [_c.c_void_p, _c.POINTER(transcribe_capabilities)]
-    lib.transcribe_model_get_device.restype = _c.c_int
-    lib.transcribe_model_get_device.argtypes = [_c.c_void_p, _c.POINTER(transcribe_backend_device)]
     lib.transcribe_model_load_file.restype = _c.c_int
     lib.transcribe_model_load_file.argtypes = [_c.c_char_p, _c.POINTER(transcribe_model_load_params), _c.POINTER(_c.c_void_p)]
     lib.transcribe_model_load_params_init.restype = None
@@ -307,6 +337,8 @@ def configure(lib):
     lib.transcribe_moonshine_streaming_stream_ext_init.argtypes = [_c.POINTER(transcribe_moonshine_streaming_stream_ext)]
     lib.transcribe_n_segments.restype = _c.c_int
     lib.transcribe_n_segments.argtypes = [_c.c_void_p]
+    lib.transcribe_n_speaker_segments.restype = _c.c_int
+    lib.transcribe_n_speaker_segments.argtypes = [_c.c_void_p]
     lib.transcribe_n_tokens.restype = _c.c_int
     lib.transcribe_n_tokens.argtypes = [_c.c_void_p]
     lib.transcribe_n_words.restype = _c.c_int
@@ -319,6 +351,8 @@ def configure(lib):
     lib.transcribe_parakeet_stream_ext_init.argtypes = [_c.POINTER(transcribe_parakeet_stream_ext)]
     lib.transcribe_print_timings.restype = None
     lib.transcribe_print_timings.argtypes = [_c.c_void_p]
+    lib.transcribe_raw_text.restype = _c.c_char_p
+    lib.transcribe_raw_text.argtypes = [_c.c_void_p]
     lib.transcribe_reset_timings.restype = None
     lib.transcribe_reset_timings.argtypes = [_c.c_void_p]
     lib.transcribe_returned_timestamp_kind.restype = _c.c_int
@@ -343,6 +377,10 @@ def configure(lib):
     lib.transcribe_session_params_init.argtypes = [_c.POINTER(transcribe_session_params)]
     lib.transcribe_set_abort_callback.restype = None
     lib.transcribe_set_abort_callback.argtypes = [_c.c_void_p, _c.CFUNCTYPE(_c.c_bool, _c.c_void_p), _c.c_void_p]
+    lib.transcribe_sortformer_stream_ext_init.restype = None
+    lib.transcribe_sortformer_stream_ext_init.argtypes = [_c.POINTER(transcribe_sortformer_stream_ext)]
+    lib.transcribe_speaker_segment_init.restype = None
+    lib.transcribe_speaker_segment_init.argtypes = [_c.POINTER(transcribe_speaker_segment)]
     lib.transcribe_status_string.restype = _c.c_char_p
     lib.transcribe_status_string.argtypes = [_c.c_int]
     lib.transcribe_stream_begin.restype = _c.c_int

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/src/transcribe_cpp/_library.py

@@ -27,7 +27,7 @@ or an object) with the contract fields:
 Selecting a provider picks which native artifact loads into the process; the
 per-model ``backend=`` request is a *separate* axis resolved inside it. Selection
 policy: explicit ``provider`` argument → ``TRANSCRIBE_NATIVE_PROVIDER`` env var →
-best accelerated (CUDA/Metal, then Vulkan) → CPU. A discovered provider whose
+best accelerated (CUDA/ROCm/Metal, then Vulkan) → CPU. A discovered provider whose
 declared version or header hash disagrees with this binding is a hard error
 *before* dlopen — pip pins are not enough; this runtime check is the backstop.
 
@@ -55,7 +55,7 @@ ENTRY_POINT_GROUP = "transcribe_cpp.native"
 
 #: Backend-kind preference when auto-selecting among installed providers. Higher
 #: wins; a provider's rank is the max over the kinds it advertises.
-_BACKEND_RANK = {"cuda": 3, "metal": 3, "vulkan": 2, "cpu_accel": 1, "cpu": 1}
+_BACKEND_RANK = {"cuda": 3, "rocm": 3, "metal": 3, "vulkan": 2, "cpu_accel": 1, "cpu": 1}
 
 #: Set after a successful load so the package can surface it for diagnostics.
 #: None means the library came from the dev-tree / explicit-path fallback.

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/tests/test_backends.py

@@ -9,6 +9,8 @@ build configuration the suite runs against.
 
 from __future__ import annotations
 
+from dataclasses import replace
+
 import pytest
 
 import transcribe_cpp as t
@@ -21,7 +23,7 @@ def test_at_least_one_device_registered():
     for dev in devices:
         assert dev.name
         assert dev.kind in {
-            "cpu", "accel", "metal", "vulkan", "cuda", "sycl", "gpu", "unknown"
+            "cpu", "accel", "metal", "vulkan", "cuda", "rocm", "sycl", "gpu", "unknown"
         }
 
 
@@ -31,8 +33,8 @@ def test_backends_non_empty():
 
 
 def test_device_index_and_fields():
-    # Each device carries its registry index (the value Model(..., gpu_device=)
-    # selects with) and well-formed metadata. Pin the device-selection surface.
+    # Each device carries a process-local display index and an opaque selection
+    # handle, plus well-formed metadata. Pin the device-selection surface.
     devices = t.backends()
     for i, dev in enumerate(devices):
         assert dev.index == i, f"device {i} reported index {dev.index}"
@@ -46,6 +48,13 @@ def test_device_index_and_fields():
         assert isinstance(dev.kind, str) and dev.kind
 
 
+def test_device_equality_uses_native_identity():
+    device = t.backends()[0]
+    refreshed = replace(device, memory_free=device.memory_free + 1, index=None)
+    assert refreshed == device
+    assert hash(refreshed) == hash(device)
+
+
 def test_cpu_always_available():
     # Every shipped configuration includes a CPU backend (compiled in or as
     # the baseline module); a process without one is mispackaged.
@@ -66,8 +75,8 @@ def test_available_kinds_match_device_list():
     # answer. (cpu_accel is satisfied by a CPU device per the C contract.)
     kinds = {d.kind for d in t.backends()}
     for request, device_kind in (("metal", "metal"), ("vulkan", "vulkan"),
-                                 ("cuda", "cuda"), ("cpu", "cpu"),
-                                 ("cpu_accel", "cpu")):
+                                 ("cuda", "cuda"), ("rocm", "rocm"),
+                                 ("cpu", "cpu"), ("cpu_accel", "cpu")):
         assert t.backend_available(request) == (device_kind in kinds), request
 
 
@@ -93,6 +102,6 @@ def test_init_backends_rejects_bad_dirs():
 def test_init_backends_idempotent():
     lib = t._lib
     adir = str(_library.artifact_dir()).encode("utf-8")
-    n = lib.transcribe_backend_device_count()
+    n = lib.transcribe_device_count()
     assert lib.transcribe_init_backends(adir) == 0
-    assert lib.transcribe_backend_device_count() == n  # no re-registration
+    assert lib.transcribe_device_count() == n  # no re-registration

transcribe_cpp-0.2.0/tests/test_device_select.py

@@ -0,0 +1,38 @@
+"""Exact opaque-device selection tests."""
+
+import pytest
+
+
+def _primary_devices(transcribe_cpp):
+    return [d for d in transcribe_cpp.backends() if d.device_type != "accel"]
+
+
+def test_enumerated_device_can_be_passed_to_model(transcribe_cpp, model_path):
+    devices = _primary_devices(transcribe_cpp)
+    if not devices:
+        pytest.skip("no selectable devices")
+
+    device = devices[0]
+    try:
+        with transcribe_cpp.Model(model_path, device=device) as model:
+            assert model.device == device
+    except transcribe_cpp.BackendError:
+        # Registered devices may still fail driver initialization. Exact
+        # selection must report that failure rather than choosing another.
+        pass
+
+
+def test_device_argument_rejects_non_device(transcribe_cpp, model_path):
+    with pytest.raises(TypeError):
+        transcribe_cpp.Model(model_path, device=0)
+
+
+def test_backend_must_match_explicit_device(transcribe_cpp, model_path):
+    gpu = next(
+        (d for d in transcribe_cpp.backends() if d.device_type in ("gpu", "igpu")),
+        None,
+    )
+    if gpu is None:
+        pytest.skip("no GPU device")
+    with pytest.raises(transcribe_cpp.InvalidArgument):
+        transcribe_cpp.Model(model_path, backend="cpu", device=gpu)

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/tests/test_family_ext.py

@@ -22,6 +22,7 @@ ALL_OPTION_TYPES = [
     t.MoonshineStreamingOptions,
     t.ParakeetStreamOptions,
     t.ParakeetBufferedStreamOptions,
+    t.SortformerStreamOptions,
     t.VoxtralRealtimeStreamOptions,
 ]
 
@@ -73,6 +74,19 @@ def test_parakeet_buffered_partial_overrides():
     assert built.right_ms == fresh.right_ms
 
 
+def test_sortformer_preset_maps_to_enum_value():
+    built = t.SortformerStreamOptions(preset="very_high_latency")._build()
+    assert built.preset == _generated.TRANSCRIBE_SORTFORMER_PRESET_VERY_HIGH_LATENCY
+    # None keeps the init default (DEFAULT = GGUF-shipped cfg).
+    default = t.SortformerStreamOptions()._build()
+    assert default.preset == _generated.TRANSCRIBE_SORTFORMER_PRESET_DEFAULT
+
+
+def test_sortformer_unknown_preset_rejected():
+    with pytest.raises(ValueError, match="preset"):
+        t.SortformerStreamOptions(preset="ultra_low_latency")  # type: ignore[arg-type]
+
+
 # --- model-gated: resolve_family validation + a real extension run ----------
 
 
@@ -130,7 +144,7 @@ def test_run_batch_accepts_family(model_path, audio_pcm):
 def test_supports_probe_all_features(model_path):
     with t.Model(model_path) as model:
         for feature in ("initial_prompt", "temperature_fallback", "long_form",
-                        "cancellation", "pnc", "itn"):
+                        "cancellation", "pnc", "itn", "diarization"):
             assert model.supports(feature) in (True, False)
         with pytest.raises(t.InvalidArgument, match="unknown feature"):
             model.supports("levitation")

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/tests/test_provider_discovery.py

@@ -84,6 +84,7 @@ def test_matches_request(request_str, expected):
 
 def test_rank_orders_accelerated_above_cpu():
     assert make("m", ["metal", "cpu"]).rank == 3
+    assert make("r", ["rocm", "cpu"]).rank == 3
     assert make("v", ["vulkan"]).rank == 2
     assert make("c", ["cpu"]).rank == 1
     assert make("u", ["wat"]).rank == 0

{transcribe_cpp-0.1.2 → transcribe_cpp-0.2.0}/uv.lock

@@ -386,7 +386,7 @@ wheels = [
 
 [[package]]
 name = "transcribe-cpp"
-version = "0.0.1"
+version = "0.2.0"
 source = { editable = "." }
 
 [package.optional-dependencies]
@@ -402,8 +402,8 @@ test = [
 requires-dist = [
     { name = "numpy", marker = "extra == 'test'" },
     { name = "pytest", marker = "extra == 'test'", specifier = ">=7" },
-    { name = "transcribe-cpp-native", specifier = "==0.0.1.*" },
-    { name = "transcribe-cpp-native-cu12", marker = "extra == 'cu12'", specifier = "==0.0.1.*" },
+    { name = "transcribe-cpp-native", specifier = "==0.2.0.*" },
+    { name = "transcribe-cpp-native-cu12", marker = "extra == 'cu12'", specifier = "==0.2.0.*" },
 ]
 
 [[package]]

transcribe_cpp-0.1.2/tests/test_device_select.py

@@ -1,55 +0,0 @@
-"""Model-gated device-selection tests.
-
-These take the ``model_path`` / ``transcribe_cpp`` fixtures, which ``skip``
-when the default whisper-tiny.en asset is absent (override with
-``TRANSCRIBE_SMOKE_MODEL``). They pin the device-selection surface added
-alongside the per-device ``index`` field: ``Model.device`` reports where the
-model landed (its ``.index`` is ``None`` because it did not come from
-enumeration), and an out-of-range / negative ``gpu_device`` is rejected with
-``InvalidArgument``.
-"""
-
-from __future__ import annotations
-
-import pytest
-
-import transcribe_cpp as t
-
-
-def test_model_device_matches_enumeration(transcribe_cpp, model_path):
-    # The model lands on some registered device. Model.device does not come
-    # from enumeration, so its .index is None; correlate it back to backends()
-    # by name (and by device_id when that is reported).
-    with transcribe_cpp.Model(model_path) as model:
-        dev = model.device
-        assert isinstance(dev, transcribe_cpp.BackendDevice)
-        assert dev.index is None, "Model.device should not carry a registry index"
-
-        devices = transcribe_cpp.backends()
-        by_name = [d for d in devices if d.name == dev.name]
-        assert by_name, (
-            f"model device {dev.name!r} not found among backends() "
-            f"{[d.name for d in devices]}"
-        )
-        if dev.device_id is not None:
-            assert any(d.device_id == dev.device_id for d in by_name), (
-                f"model device_id {dev.device_id!r} matched no enumerated device"
-            )
-
-
-def test_negative_gpu_device_rejected(transcribe_cpp, model_path):
-    with pytest.raises(transcribe_cpp.InvalidArgument):
-        transcribe_cpp.Model(model_path, gpu_device=-1)
-
-
-def test_out_of_range_gpu_device_rejected(transcribe_cpp, model_path):
-    bad = len(transcribe_cpp.backends()) + 1000
-    with pytest.raises(transcribe_cpp.InvalidArgument):
-        transcribe_cpp.Model(model_path, gpu_device=bad)
-
-
-def test_cpu_backend_with_gpu_index_rejected(transcribe_cpp, model_path):
-    # Hardware-independent: a CPU backend has no GPU to select, so a non-zero
-    # gpu_device is invalid regardless of what hardware is present.
-    with pytest.raises(transcribe_cpp.InvalidArgument):
-        transcribe_cpp.Model(model_path, backend="cpu", gpu_device=1)