k2py 0.2.4__cp314-cp314-win_amd64.whl

k2py/__init__.py

@@ -0,0 +1,137 @@
+"""k2py - Python bindings for k2 OnlineDenseIntersecter
+
+This package provides Python bindings for the k2 forced alignment library,
+specifically the OnlineDenseIntersecter for efficient streaming decoding.
+"""
+
+__version__ = "0.1.0"
+
+from dataclasses import dataclass, field
+from typing import Union, List, Dict, Any, Tuple
+
+from ._k2 import (
+    CreateFsaVecFromStr,
+    FsaVec,
+    Array2,
+    OnlineDenseIntersecter as _OnlineDenseIntersecter,
+)
+
+@dataclass
+class AlignedToken:
+    token_id: Union[str, int]
+    timestamp: int
+    duration: int  # in frames
+    score: float
+    attr: dict = field(default_factory=dict)
+
+    def to_dict(self):
+        return {
+            "token_id": self.token_id,
+            "timestamp": self.timestamp,
+            "duration": self.duration,
+            "score": self.score,
+            "attr": self.attr,
+        }
+
+class OnlineDenseIntersecter(_OnlineDenseIntersecter):
+    """Wrapper around C++ OnlineDenseIntersecter to produce Python-friendly results."""
+
+    def get_partial_labels(self) -> List[int]:
+        """Get partial per-frame labels for streaming confidence calculation.
+
+        Returns per-frame token IDs from the current lattice state.
+        Used for computing emission-based confidence scores in streaming mode.
+
+        Returns:
+            List of token IDs, one per frame.
+        """
+        return list(super().get_partial_labels())
+
+    def finish(self) -> Tuple[List[List["AlignedToken"]], List[List[int]]]:
+        """Finish decoding and return results including AlignedToken objects.
+        
+        Returns:
+            A tuple containing:
+            - results: List of List of AlignedToken objects (wrapped in list for batch consistency)
+            - labels: List of List of timestamps (wrapped in list for batch consistency)
+        """
+        final_result = super().finish()
+        
+        # Convert to AlignedToken objects
+        aligned_tokens = []
+        token_ids = final_result["token_ids"]
+        timestamps = final_result["timestamps"]
+        durations = final_result["durations"]
+        scores = final_result["scores"]
+
+        for tid, ts, dur, score in zip(token_ids, timestamps, durations, scores):
+            aligned_tokens.append(AlignedToken(tid, ts, dur, score))
+            
+        # Wrap in lists to match the expected format (list of lists for batch)
+        # currently we only support single stream in this wrapper for simplicty of k2py
+        # but the interface expects batch results
+        return [aligned_tokens], [final_result["labels"]]
+
+def AlignSegments(
+    graph_result: Dict[str, Any],
+    scores: Any, # numpy array
+    search_beam: float,
+    output_beam: float,
+    min_active_states: int,
+    max_active_states: int,
+    use_double_scores: bool = True,
+    allow_partial: bool = True,
+) -> Tuple[List[List["AlignedToken"]], List[List[int]]]:
+    """Align segments using offline dense intersection.
+
+    Args:
+        graph_result: Dictionary returned by CreateFsaVecFromStr
+        scores: Numpy array of scores (rows, cols)
+        search_beam: Beam size for search
+        output_beam: Beam size for output
+        min_active_states: Minimum active states
+        max_active_states: Maximum active states
+        use_double_scores: Whether to use double precision for scores
+        allow_partial: If True, treat all states on last frame as final
+                      when no final state is active. Default True.
+
+    Returns:
+        A tuple containing:
+        - results: List of List of AlignedToken objects (wrapped in list for batch consistency)
+        - labels: List of List of timestamps (wrapped in list for batch consistency)
+    """
+    from ._k2 import AlignSegments as _AlignSegments
+
+    final_result = _AlignSegments(
+        graph_result,
+        scores,
+        search_beam,
+        output_beam,
+        min_active_states,
+        max_active_states,
+        use_double_scores,
+        allow_partial,
+    )
+
+    # Convert to AlignedToken objects
+    aligned_tokens = []
+    token_ids = final_result["token_ids"]
+    timestamps = final_result["timestamps"]
+    durations = final_result["durations"]
+    scores = final_result["scores"]
+
+    for tid, ts, dur, score in zip(token_ids, timestamps, durations, scores):
+        aligned_tokens.append(AlignedToken(tid, ts, dur, score))
+        
+    # Wrap in lists to match the expected format (list of lists for batch)
+    return [aligned_tokens], [final_result["labels"]]
+
+
+__all__ = [
+    "CreateFsaVecFromStr",
+    "FsaVec",
+    "Array2",
+    "OnlineDenseIntersecter",
+    "AlignedToken",
+    "AlignSegments",
+]

k2py-0.2.4.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.2
+Name: k2py
+Version: 0.2.4
+Summary: Python bindings for k2
+Keywords: k2,forced-alignment,speech,asr
+Author: The LattifAI Development Team
+License: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Project-URL: Homepage, https://github.com/lattifai/k2py
+Project-URL: Repository, https://github.com/lattifai/k2py.git
+Project-URL: Issues, https://github.com/lattifai/k2py/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# k2py
+
+Python bindings for k2
+
+## Features
+
+- **Efficient Streaming Decoding**: OnlineDenseIntersecter for real-time forced alignment
+- **Cross-Platform**: Supports Linux, macOS, and Windows
+- **Python 3.10+**: Compatible with modern Python versions
+- **Built with pybind11**: Fast C++ bindings with minimal overhead
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install k2py
+```
+
+## Usage
+
+### Basic Example
+
+```python
+from k2py import OnlineDenseIntersecter, CreateFsaVecFromStr
+import numpy as np
+
+# Create FSA from string representation
+fsa_str = "0 1 1 1.0\n1 2 2 1.0\n2"
+result = CreateFsaVecFromStr(fsa_str, final_state=2)
+
+# Initialize decoder
+decoder = OnlineDenseIntersecter(
+    result["fsa"],
+    result["aux_labels"],
+    search_beam=20.0,
+    output_beam=8.0,
+    min_active_states=30,
+    max_active_states=10000
+)
+
+# Prepare acoustic scores (num_frames x vocab_size)
+scores = np.random.randn(100, 50).astype(np.float32)
+
+# Decode
+lattice = decoder.DecodeWithArray(scores, return_lattice=True)
+
+# Get final alignment result
+alignment = decoder.Finish()
+print(f"Token IDs: {alignment['token_ids']}")
+print(f"Timestamps: {alignment['timestamps']}")
+print(f"Durations: {alignment['durations']}")
+```

k2py-0.2.4.dist-info/RECORD

@@ -0,0 +1,5 @@
+k2py/__init__.py,sha256=KR-D9Luea5f6G6-O9pHsQoJTPH7kn2zLwuFXSIDs-M8,4741
+k2py/_k2.cp314-win_amd64.pyd,sha256=mqhKfBM-kqIrKs3PH5-UC42Mwsaj9y_FzEShcMMzOuI,681472
+k2py-0.2.4.dist-info/METADATA,sha256=YZxTxwdJp7Hawm0YeUP1tPYebyv0Lbc17TB2hjgO8OY,2306
+k2py-0.2.4.dist-info/WHEEL,sha256=gWMs92Yhbl9pSGNRFWCXG1mfeuNl7HhxcJG5aLu4nQc,106
+k2py-0.2.4.dist-info/RECORD,,

k2py-0.2.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_amd64
+