nexaai 1.0.21rc5__cp313-cp313-win_arm64.whl → 1.0.21rc16__cp313-cp313-win_arm64.whl

nexaai/__init__.py

@@ -1,95 +1,95 @@
-"""
-NexaAI Python bindings for NexaSDK C-lib backend.
-"""
-
-import sys
-import os
-
-# Add mlx_backend to Python path as individual module (only if it exists)
-_current_dir = os.path.dirname(os.path.abspath(__file__))
-_mlx_backend_path = os.path.join(_current_dir, "mlx_backend")
-# Only add to path if the directory exists (it won't on Windows)
-if os.path.exists(_mlx_backend_path) and _mlx_backend_path not in sys.path:
-    sys.path.insert(0, _mlx_backend_path)
-
-try:
-    from ._version import __version__
-except ImportError:
-    # Fallback for development or when version file hasn't been generated yet
-    __version__ = "0.0.1"
-
-# Import common configuration classes first (no external dependencies)
-from .common import ModelConfig, GenerationConfig, ChatMessage, SamplerConfig, PluginID
-
-# Import logging functionality
-from .log import set_logger, get_error_message
-
-# Import runtime errors
-from .runtime_error import (
-    NexaRuntimeError,
-    ContextLengthExceededError,
-    GenerationError
-)
-
-# Create alias for PluginID to be accessible as plugin_id
-plugin_id = PluginID
-
-# Import new feature classes (no external dependencies in base classes)
-from .llm import LLM
-from .embedder import Embedder, EmbeddingConfig
-from .vlm import VLM
-from .asr import ASR, ASRConfig, ASRResult
-from .cv import CVModel, CVModelConfig, CVResult, CVResults, CVCapabilities, BoundingBox
-from .rerank import Reranker, RerankConfig
-from .image_gen import ImageGen, ImageGenerationConfig, ImageSamplerConfig, SchedulerConfig, Image
-from .tts import TTS, TTSConfig, TTSSamplerConfig, TTSResult
-
-# Build __all__ list dynamically
-__all__ = [
-    "__version__",
-    # Common configurations (always available)
-    "ModelConfig",
-    "GenerationConfig", 
-    "ChatMessage",
-    "SamplerConfig",
-    "EmbeddingConfig",
-    "PluginID",
-    "plugin_id",
-    
-    # Logging functionality
-    "set_logger",
-    "get_error_message",
-    
-    # Runtime errors
-    "NexaRuntimeError",
-    "ContextLengthExceededError",
-    "GenerationError",
-
-    "LLM",
-    "Embedder",
-    "VLM",
-    "ASR",
-    "CVModel",
-    "Reranker",
-    "ImageGen",
-    "TTS",
-
-    "ASRConfig",
-    "ASRResult",
-    "CVModelConfig",
-    "CVResult",
-    "CVResults", 
-    "CVCapabilities",
-    "BoundingBox",
-    "RerankConfig",
-    "ImageGenerationConfig",
-    "ImageSamplerConfig",
-    "SchedulerConfig",
-    "Image",
-    "TTSConfig",
-    "TTSSamplerConfig",
-    "TTSResult",
-]
-
-
-
+"""
+NexaAI Python bindings for NexaSDK C-lib backend.
+"""
+
+import sys
+import os
+
+# Add mlx_backend to Python path as individual module (only if it exists)
+_current_dir = os.path.dirname(os.path.abspath(__file__))
+_mlx_backend_path = os.path.join(_current_dir, "mlx_backend")
+# Only add to path if the directory exists (it won't on Windows)
+if os.path.exists(_mlx_backend_path) and _mlx_backend_path not in sys.path:
+    sys.path.insert(0, _mlx_backend_path)
+
+try:
+    from ._version import __version__
+except ImportError:
+    # Fallback for development or when version file hasn't been generated yet
+    __version__ = "0.0.1"
+
+# Import common configuration classes first (no external dependencies)
+from .common import ModelConfig, GenerationConfig, ChatMessage, SamplerConfig, PluginID
+
+# Import logging functionality
+from .log import set_logger, get_error_message
+
+# Import runtime errors
+from .runtime_error import (
+    NexaRuntimeError,
+    ContextLengthExceededError,
+    GenerationError
+)
+
+# Create alias for PluginID to be accessible as plugin_id
+plugin_id = PluginID
+
+# Import new feature classes (no external dependencies in base classes)
+from .llm import LLM
+from .embedder import Embedder, EmbeddingConfig
+from .vlm import VLM
+from .asr import ASR, ASRConfig, ASRResult
+from .cv import CVModel, CVModelConfig, CVResult, CVResults, CVCapabilities, BoundingBox
+from .rerank import Reranker, RerankConfig
+from .image_gen import ImageGen, ImageGenerationConfig, ImageSamplerConfig, SchedulerConfig, Image
+from .tts import TTS, TTSConfig, TTSSamplerConfig, TTSResult
+
+# Build __all__ list dynamically
+__all__ = [
+    "__version__",
+    # Common configurations (always available)
+    "ModelConfig",
+    "GenerationConfig", 
+    "ChatMessage",
+    "SamplerConfig",
+    "EmbeddingConfig",
+    "PluginID",
+    "plugin_id",
+    
+    # Logging functionality
+    "set_logger",
+    "get_error_message",
+    
+    # Runtime errors
+    "NexaRuntimeError",
+    "ContextLengthExceededError",
+    "GenerationError",
+
+    "LLM",
+    "Embedder",
+    "VLM",
+    "ASR",
+    "CVModel",
+    "Reranker",
+    "ImageGen",
+    "TTS",
+
+    "ASRConfig",
+    "ASRResult",
+    "CVModelConfig",
+    "CVResult",
+    "CVResults", 
+    "CVCapabilities",
+    "BoundingBox",
+    "RerankConfig",
+    "ImageGenerationConfig",
+    "ImageSamplerConfig",
+    "SchedulerConfig",
+    "Image",
+    "TTSConfig",
+    "TTSSamplerConfig",
+    "TTSResult",
+]
+
+
+

nexaai/_version.py

@@ -1 +1,4 @@
-__version__ = "1.0.21rc5"
+# This file is generated by CMake from _version.py.in
+# Do not modify this file manually - it will be overwritten
+
+__version__ = "1.0.21rc16" 

nexaai/asr.py

@@ -1,65 +1,68 @@
-from typing import List, Optional, Sequence, Tuple, Union
-from abc import abstractmethod
-from dataclasses import dataclass
-
-from nexaai.base import BaseModel
-from nexaai.common import PluginID
-
-
-@dataclass
-class ASRConfig:
-    """Configuration for ASR."""
-    timestamps: str = "none"  # "none" | "segment" | "word"
-    beam_size: int = 5
-    stream: bool = False
-
-
-@dataclass
-class ASRResult:
-    """Result from ASR processing."""
-    transcript: str
-    confidence_scores: Sequence[float]
-    timestamps: Sequence[Tuple[float, float]]
-
-
-class ASR(BaseModel):
-    """Abstract base class for Automatic Speech Recognition models."""
-
-    def __init__(self):
-        """Initialize base ASR class."""
-        pass
-
-    @classmethod
-    def _load_from(cls,
-                   model_path: str,
-                   tokenizer_path: Optional[str] = None,
-                   language: Optional[str] = None,
-                   plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP,
-                   device_id: Optional[str] = None,
-                   **kwargs
-        ) -> 'ASR':
-        """Load ASR model from local path, routing to appropriate implementation."""
-        # Check plugin_id value for routing - handle both enum and string
-        plugin_value = plugin_id.value if isinstance(plugin_id, PluginID) else plugin_id
-        
-        if plugin_value == "mlx":
-            from nexaai.asr_impl.mlx_asr_impl import MLXASRImpl
-            return MLXASRImpl._load_from(model_path, tokenizer_path, language, plugin_id, device_id)
-        else:
-            from nexaai.asr_impl.pybind_asr_impl import PyBindASRImpl
-            return PyBindASRImpl._load_from(model_path, tokenizer_path, language, plugin_id, device_id)
-
-    @abstractmethod
-    def transcribe(
-        self,
-        audio_path: str,
-        language: Optional[str] = None,
-        config: Optional[ASRConfig] = None,
-    ) -> ASRResult:
-        """Transcribe audio file to text."""
-        pass
-
-    @abstractmethod
-    def list_supported_languages(self) -> List[str]:
-        """List supported languages."""
-        pass
+from typing import List, Optional, Sequence, Tuple, Union
+from abc import abstractmethod
+from dataclasses import dataclass
+
+from nexaai.base import BaseModel
+from nexaai.common import PluginID, ModelConfig
+
+
+@dataclass
+class ASRConfig:
+    """Configuration for ASR."""
+    timestamps: str = "none"  # "none" | "segment" | "word"
+    beam_size: int = 5
+    stream: bool = False
+
+
+@dataclass
+class ASRResult:
+    """Result from ASR processing."""
+    transcript: str
+    confidence_scores: Sequence[float]
+    timestamps: Sequence[Tuple[float, float]]
+
+
+class ASR(BaseModel):
+    """Abstract base class for Automatic Speech Recognition models."""
+
+    def __init__(self, m_cfg: ModelConfig = ModelConfig()):
+        """Initialize base ASR class."""
+        self._m_cfg = m_cfg
+
+    @classmethod
+    def _load_from(cls,
+                   model_path: str,
+                   model_name: Optional[str] = None,
+                   tokenizer_path: Optional[str] = None,
+                   language: Optional[str] = None,
+                   m_cfg: ModelConfig = ModelConfig(),
+                   plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP,
+                   device_id: Optional[str] = None,
+                   **kwargs
+        ) -> 'ASR':
+        """Load ASR model from local path, routing to appropriate implementation."""
+        # Check plugin_id value for routing - handle both enum and string
+        plugin_value = plugin_id.value if isinstance(plugin_id, PluginID) else plugin_id
+        
+        if plugin_value == "mlx":
+            from nexaai.asr_impl.mlx_asr_impl import MLXASRImpl
+            return MLXASRImpl._load_from(model_path, model_name, tokenizer_path, language, m_cfg, plugin_id, device_id)
+        else:
+            from nexaai.asr_impl.pybind_asr_impl import PyBindASRImpl
+            return PyBindASRImpl._load_from(model_path, model_name, tokenizer_path, language, m_cfg, plugin_id, device_id)
+
+
+    @abstractmethod
+    def transcribe(
+        self,
+        audio_path: str,
+        language: Optional[str] = None,
+        config: Optional[ASRConfig] = None,
+    ) -> ASRResult:
+        """Transcribe audio file to text."""
+        pass
+
+    @abstractmethod
+    def list_supported_languages(self) -> List[str]:
+        """List supported languages."""
+        pass

nexaai/asr_impl/mlx_asr_impl.py

@@ -1,92 +1,92 @@
-# Note: This code is generated by Cursor, not tested yet.
-
-from typing import List, Optional, Union
-
-from nexaai.common import PluginID
-from nexaai.asr import ASR, ASRConfig, ASRResult
-from nexaai.mlx_backend.asr.interface import MlxAsr as MLXASRInterface
-from nexaai.mlx_backend.ml import ModelConfig as MLXModelConfig, SamplerConfig as MLXSamplerConfig, GenerationConfig as MLXGenerationConfig, EmbeddingConfig
-
-
-class MLXASRImpl(ASR):
-    def __init__(self):
-        """Initialize MLX ASR implementation."""
-        super().__init__()
-        self._mlx_asr = None
-
-    @classmethod
-    def _load_from(cls,
-                   model_path: str,
-                   tokenizer_path: Optional[str] = None,
-                   language: Optional[str] = None,
-                   plugin_id: Union[PluginID, str] = PluginID.MLX,
-                   device_id: Optional[str] = None
-        ) -> 'MLXASRImpl':
-        """Load ASR model from local path using MLX backend."""
-        try:
-            # MLX ASR interface is already imported
-            
-            # Create instance and load MLX ASR
-            instance = cls()
-            instance._mlx_asr = MLXASRInterface(
-                model_path=model_path,
-                tokenizer_path=tokenizer_path,
-                language=language,
-                device=device_id
-            )
-            
-            return instance
-        except Exception as e:
-            raise RuntimeError(f"Failed to load MLX ASR: {str(e)}")
-
-    def eject(self):
-        """Destroy the model and free resources."""
-        if self._mlx_asr:
-            self._mlx_asr.destroy()
-            self._mlx_asr = None
-            
-    def transcribe(
-        self,
-        audio_path: str,
-        language: Optional[str] = None,
-        config: Optional[ASRConfig] = None,
-    ) -> ASRResult:
-        """Transcribe audio file to text."""
-        if not self._mlx_asr:
-            raise RuntimeError("MLX ASR not loaded")
-        
-        try:
-            # Convert our config to MLX format if provided
-            mlx_config = None
-            if config:
-                from nexaai.mlx_backend.ml import ASRConfig as MLXASRConfig
-                
-                mlx_config = MLXASRConfig()
-                mlx_config.timestamps = config.timestamps
-                mlx_config.beam_size = config.beam_size
-                mlx_config.stream = config.stream
-            
-            # Use MLX ASR transcription
-            result = self._mlx_asr.transcribe(audio_path, language, mlx_config)
-            
-            # Convert MLX result to our format
-            return ASRResult(
-                transcript=result.transcript,
-                confidence_scores=result.confidence_scores,
-                timestamps=result.timestamps
-            )
-            
-        except Exception as e:
-            raise RuntimeError(f"Failed to transcribe audio: {str(e)}")
-
-    def list_supported_languages(self) -> List[str]:
-        """List supported languages."""
-        if not self._mlx_asr:
-            raise RuntimeError("MLX ASR not loaded")
-        
-        try:
-            return self._mlx_asr.list_supported_languages()
-        except Exception as e:
-            raise RuntimeError(f"Failed to list supported languages: {str(e)}")
-
-
+# Note: This code is generated by Cursor, not tested yet.
+
+from typing import List, Optional, Union
+
+from nexaai.common import PluginID
+from nexaai.asr import ASR, ASRConfig, ASRResult
+from nexaai.mlx_backend.asr.interface import MlxAsr as MLXASRInterface
+from nexaai.mlx_backend.ml import ModelConfig as MLXModelConfig, SamplerConfig as MLXSamplerConfig, GenerationConfig as MLXGenerationConfig, EmbeddingConfig
+
+
+class MLXASRImpl(ASR):
+    def __init__(self):
+        """Initialize MLX ASR implementation."""
+        super().__init__()
+        self._mlx_asr = None
+
+    @classmethod
+    def _load_from(cls,
+                   model_path: str,
+                   tokenizer_path: Optional[str] = None,
+                   language: Optional[str] = None,
+                   plugin_id: Union[PluginID, str] = PluginID.MLX,
+                   device_id: Optional[str] = None
+        ) -> 'MLXASRImpl':
+        """Load ASR model from local path using MLX backend."""
+        try:
+            # MLX ASR interface is already imported
+            
+            # Create instance and load MLX ASR
+            instance = cls()
+            instance._mlx_asr = MLXASRInterface(
+                model_path=model_path,
+                tokenizer_path=tokenizer_path,
+                language=language,
+                device=device_id
+            )
+            
+            return instance
+        except Exception as e:
+            raise RuntimeError(f"Failed to load MLX ASR: {str(e)}")
+
+    def eject(self):
+        """Destroy the model and free resources."""
+        if self._mlx_asr:
+            self._mlx_asr.destroy()
+            self._mlx_asr = None
+            
+    def transcribe(
+        self,
+        audio_path: str,
+        language: Optional[str] = None,
+        config: Optional[ASRConfig] = None,
+    ) -> ASRResult:
+        """Transcribe audio file to text."""
+        if not self._mlx_asr:
+            raise RuntimeError("MLX ASR not loaded")
+        
+        try:
+            # Convert our config to MLX format if provided
+            mlx_config = None
+            if config:
+                from nexaai.mlx_backend.ml import ASRConfig as MLXASRConfig
+                
+                mlx_config = MLXASRConfig()
+                mlx_config.timestamps = config.timestamps
+                mlx_config.beam_size = config.beam_size
+                mlx_config.stream = config.stream
+            
+            # Use MLX ASR transcription
+            result = self._mlx_asr.transcribe(audio_path, language, mlx_config)
+            
+            # Convert MLX result to our format
+            return ASRResult(
+                transcript=result.transcript,
+                confidence_scores=result.confidence_scores,
+                timestamps=result.timestamps
+            )
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to transcribe audio: {str(e)}")
+
+    def list_supported_languages(self) -> List[str]:
+        """List supported languages."""
+        if not self._mlx_asr:
+            raise RuntimeError("MLX ASR not loaded")
+        
+        try:
+            return self._mlx_asr.list_supported_languages()
+        except Exception as e:
+            raise RuntimeError(f"Failed to list supported languages: {str(e)}")
+
+