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

nexaai/cv.py

@@ -1,93 +1,93 @@
-from typing import List, Optional, Union
-from abc import abstractmethod
-from dataclasses import dataclass
-
-from nexaai.base import BaseModel
-from nexaai.common import PluginID
-
-
-@dataclass
-class BoundingBox:
-    """Generic bounding box structure."""
-    x: float  # X coordinate (normalized or pixel, depends on model)
-    y: float  # Y coordinate (normalized or pixel, depends on model) 
-    width: float  # Width
-    height: float  # Height
-
-
-@dataclass
-class CVResult:
-    """Generic detection/classification result."""
-    image_paths: Optional[List[str]] = None  # Output image paths
-    image_count: int = 0  # Number of output images
-    class_id: int = 0  # Class ID (example: ConvNext)
-    confidence: float = 0.0  # Confidence score [0.0-1.0]
-    bbox: Optional[BoundingBox] = None  # Bounding box (example: YOLO)
-    text: Optional[str] = None  # Text result (example: OCR)
-    embedding: Optional[List[float]] = None  # Feature embedding (example: CLIP embedding)
-    embedding_dim: int = 0  # Embedding dimension
-
-
-@dataclass
-class CVResults:
-    """Generic CV inference result."""
-    results: List[CVResult]  # Array of CV results
-    result_count: int  # Number of CV results
-
-
-class CVCapabilities:
-    """CV capabilities enum."""
-    OCR = 0  # OCR
-    CLASSIFICATION = 1  # Classification
-    SEGMENTATION = 2  # Segmentation
-    CUSTOM = 3  # Custom task
-
-
-@dataclass
-class CVModelConfig:
-    """CV model preprocessing configuration."""
-    capabilities: int  # CVCapabilities
-
-    # MLX-OCR
-    det_model_path: Optional[str] = None  # Detection model path
-    rec_model_path: Optional[str] = None  # Recognition model path
-
-    # QNN
-    model_path: Optional[str] = None  # Model path
-    system_library_path: Optional[str] = None  # System library path
-    backend_library_path: Optional[str] = None  # Backend library path
-    extension_library_path: Optional[str] = None  # Extension library path
-    config_file_path: Optional[str] = None  # Config file path
-    char_dict_path: Optional[str] = None  # Character dictionary path
-
-
-class CVModel(BaseModel):
-    """Abstract base class for generic computer vision models."""
-
-    def __init__(self):
-        """Initialize base CV model class."""
-        pass
-
-    @classmethod
-    def _load_from(cls,
-                   _: str,  # TODO: remove this argument, this is a hack to make api design happy
-                   config: CVModelConfig,
-                   plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP,
-                   device_id: Optional[str] = None,
-                   **kwargs
-        ) -> 'CVModel':
-        """Load CV model from configuration, 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.cv_impl.mlx_cv_impl import MLXCVImpl
-            return MLXCVImpl._load_from(config, plugin_id, device_id)
-        else:
-            from nexaai.cv_impl.pybind_cv_impl import PyBindCVImpl
-            return PyBindCVImpl._load_from(config, plugin_id, device_id)
-
-    @abstractmethod
-    def infer(self, input_image_path: str) -> CVResults:
-        """Perform inference on image."""
-        pass
+from typing import List, Optional, Union
+from abc import abstractmethod
+from dataclasses import dataclass
+
+from nexaai.base import BaseModel
+from nexaai.common import PluginID
+
+
+@dataclass
+class BoundingBox:
+    """Generic bounding box structure."""
+    x: float  # X coordinate (normalized or pixel, depends on model)
+    y: float  # Y coordinate (normalized or pixel, depends on model) 
+    width: float  # Width
+    height: float  # Height
+
+
+@dataclass
+class CVResult:
+    """Generic detection/classification result."""
+    image_paths: Optional[List[str]] = None  # Output image paths
+    image_count: int = 0  # Number of output images
+    class_id: int = 0  # Class ID (example: ConvNext)
+    confidence: float = 0.0  # Confidence score [0.0-1.0]
+    bbox: Optional[BoundingBox] = None  # Bounding box (example: YOLO)
+    text: Optional[str] = None  # Text result (example: OCR)
+    embedding: Optional[List[float]] = None  # Feature embedding (example: CLIP embedding)
+    embedding_dim: int = 0  # Embedding dimension
+
+
+@dataclass
+class CVResults:
+    """Generic CV inference result."""
+    results: List[CVResult]  # Array of CV results
+    result_count: int  # Number of CV results
+
+
+class CVCapabilities:
+    """CV capabilities enum."""
+    OCR = 0  # OCR
+    CLASSIFICATION = 1  # Classification
+    SEGMENTATION = 2  # Segmentation
+    CUSTOM = 3  # Custom task
+
+
+@dataclass
+class CVModelConfig:
+    """CV model preprocessing configuration."""
+    capabilities: int  # CVCapabilities
+
+    # MLX-OCR
+    det_model_path: Optional[str] = None  # Detection model path
+    rec_model_path: Optional[str] = None  # Recognition model path
+
+    # QNN
+    model_path: Optional[str] = None  # Model path
+    system_library_path: Optional[str] = None  # System library path
+    backend_library_path: Optional[str] = None  # Backend library path
+    extension_library_path: Optional[str] = None  # Extension library path
+    config_file_path: Optional[str] = None  # Config file path
+    char_dict_path: Optional[str] = None  # Character dictionary path
+
+
+class CVModel(BaseModel):
+    """Abstract base class for generic computer vision models."""
+
+    def __init__(self):
+        """Initialize base CV model class."""
+        pass
+
+    @classmethod
+    def _load_from(cls,
+                   _: str,  # TODO: remove this argument, this is a hack to make api design happy
+                   config: CVModelConfig,
+                   plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP,
+                   device_id: Optional[str] = None,
+                   **kwargs
+        ) -> 'CVModel':
+        """Load CV model from configuration, 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.cv_impl.mlx_cv_impl import MLXCVImpl
+            return MLXCVImpl._load_from(config, plugin_id, device_id)
+        else:
+            from nexaai.cv_impl.pybind_cv_impl import PyBindCVImpl
+            return PyBindCVImpl._load_from(config, plugin_id, device_id)
+
+    @abstractmethod
+    def infer(self, input_image_path: str) -> CVResults:
+        """Perform inference on image."""
+        pass

nexaai/cv_impl/mlx_cv_impl.py

@@ -1,89 +1,89 @@
-# Note: This code is generated by Cursor, not tested yet.
-
-from typing import Optional, Union
-import os
-
-from nexaai.common import PluginID
-from nexaai.cv import CVModel, CVModelConfig, CVResults
-from nexaai.mlx_backend.cv.interface import CVModel as MLXCVInterface, create_cv_model
-
-
-class MLXCVImpl(CVModel):
-    def __init__(self):
-        """Initialize MLX CV implementation."""
-        super().__init__()
-        self._mlx_cv = None
-
-    @classmethod
-    def _load_from(cls,
-                   config: CVModelConfig,
-                   plugin_id: Union[PluginID, str] = PluginID.MLX,
-                   device_id: Optional[str] = None
-        ) -> 'MLXCVImpl':
-        """Load CV model from configuration using MLX backend."""
-        try:
-            # Get MLX config class
-            from nexaai.mlx_backend.ml import CVModelConfig as MLXCVModelConfig
-            
-            # Convert our config to MLX format
-            mlx_config = MLXCVModelConfig(
-                capabilities=config.capabilities,
-                det_model_path=config.det_model_path,
-                rec_model_path=config.rec_model_path,
-                model_path=config.model_path,
-                system_library_path=config.system_library_path,
-                backend_library_path=config.backend_library_path,
-                extension_library_path=config.extension_library_path,
-                config_file_path=config.config_file_path,
-                char_dict_path=config.char_dict_path
-            )
-            
-            # Create instance and load MLX CV model
-            instance = cls()
-            instance._mlx_cv = create_cv_model(mlx_config, device_id)
-            
-            return instance
-        except Exception as e:
-            raise RuntimeError(f"Failed to load MLX CV: {str(e)}")
-
-    def eject(self):
-        """Destroy the model and free resources."""
-        if self._mlx_cv:
-            self._mlx_cv.destroy()
-            self._mlx_cv = None
-
-    def infer(self, input_image_path: str) -> CVResults:
-        """Perform inference on image."""
-        if not self._mlx_cv:
-            raise RuntimeError("MLX CV not loaded")
-        
-        try:
-            # Use MLX CV inference
-            result = self._mlx_cv.infer(input_image_path)
-            
-            # Convert MLX result to our format
-            from nexaai.cv import CVResult
-            
-            our_results = []
-            for mlx_result in result.results:
-                our_result = CVResult(
-                    image_paths=mlx_result.image_paths,
-                    image_count=mlx_result.image_count,
-                    class_id=mlx_result.class_id,
-                    confidence=mlx_result.confidence,
-                    bbox=mlx_result.bbox,
-                    text=mlx_result.text,
-                    embedding=mlx_result.embedding,
-                    embedding_dim=mlx_result.embedding_dim
-                )
-                our_results.append(our_result)
-            
-            return CVResults(
-                results=our_results,
-                result_count=result.result_count
-            )
-            
-        except Exception as e:
-            raise RuntimeError(f"Failed to perform CV inference: {str(e)}")
-
-
+# Note: This code is generated by Cursor, not tested yet.
+
+from typing import Optional, Union
+import os
+
+from nexaai.common import PluginID
+from nexaai.cv import CVModel, CVModelConfig, CVResults
+from nexaai.mlx_backend.cv.interface import CVModel as MLXCVInterface, create_cv_model
+
+
+class MLXCVImpl(CVModel):
+    def __init__(self):
+        """Initialize MLX CV implementation."""
+        super().__init__()
+        self._mlx_cv = None
+
+    @classmethod
+    def _load_from(cls,
+                   config: CVModelConfig,
+                   plugin_id: Union[PluginID, str] = PluginID.MLX,
+                   device_id: Optional[str] = None
+        ) -> 'MLXCVImpl':
+        """Load CV model from configuration using MLX backend."""
+        try:
+            # Get MLX config class
+            from nexaai.mlx_backend.ml import CVModelConfig as MLXCVModelConfig
+            
+            # Convert our config to MLX format
+            mlx_config = MLXCVModelConfig(
+                capabilities=config.capabilities,
+                det_model_path=config.det_model_path,
+                rec_model_path=config.rec_model_path,
+                model_path=config.model_path,
+                system_library_path=config.system_library_path,
+                backend_library_path=config.backend_library_path,
+                extension_library_path=config.extension_library_path,
+                config_file_path=config.config_file_path,
+                char_dict_path=config.char_dict_path
+            )
+            
+            # Create instance and load MLX CV model
+            instance = cls()
+            instance._mlx_cv = create_cv_model(mlx_config, device_id)
+            
+            return instance
+        except Exception as e:
+            raise RuntimeError(f"Failed to load MLX CV: {str(e)}")
+
+    def eject(self):
+        """Destroy the model and free resources."""
+        if self._mlx_cv:
+            self._mlx_cv.destroy()
+            self._mlx_cv = None
+
+    def infer(self, input_image_path: str) -> CVResults:
+        """Perform inference on image."""
+        if not self._mlx_cv:
+            raise RuntimeError("MLX CV not loaded")
+        
+        try:
+            # Use MLX CV inference
+            result = self._mlx_cv.infer(input_image_path)
+            
+            # Convert MLX result to our format
+            from nexaai.cv import CVResult
+            
+            our_results = []
+            for mlx_result in result.results:
+                our_result = CVResult(
+                    image_paths=mlx_result.image_paths,
+                    image_count=mlx_result.image_count,
+                    class_id=mlx_result.class_id,
+                    confidence=mlx_result.confidence,
+                    bbox=mlx_result.bbox,
+                    text=mlx_result.text,
+                    embedding=mlx_result.embedding,
+                    embedding_dim=mlx_result.embedding_dim
+                )
+                our_results.append(our_result)
+            
+            return CVResults(
+                results=our_results,
+                result_count=result.result_count
+            )
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to perform CV inference: {str(e)}")
+
+

nexaai/cv_impl/pybind_cv_impl.py

@@ -1,32 +1,32 @@
-from typing import Optional, Union
-
-from nexaai.common import PluginID
-from nexaai.cv import CVModel, CVModelConfig, CVResults
-
-
-class PyBindCVImpl(CVModel):
-    def __init__(self):
-        """Initialize PyBind CV implementation."""
-        super().__init__()
-        # TODO: Add PyBind-specific initialization
-
-    @classmethod
-    def _load_from(cls,
-                   config: CVModelConfig,
-                   plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP,
-                   device_id: Optional[str] = None
-        ) -> 'PyBindCVImpl':
-        """Load CV model from configuration using PyBind backend."""
-        # TODO: Implement PyBind CV loading
-        instance = cls()
-        return instance
-
-    def eject(self):
-        """Destroy the model and free resources."""
-        # TODO: Implement PyBind CV cleanup
-        pass
-
-    def infer(self, input_image_path: str) -> CVResults:
-        """Perform inference on image."""
-        # TODO: Implement PyBind CV inference
-        raise NotImplementedError("PyBind CV inference not yet implemented")
+from typing import Optional, Union
+
+from nexaai.common import PluginID
+from nexaai.cv import CVModel, CVModelConfig, CVResults
+
+
+class PyBindCVImpl(CVModel):
+    def __init__(self):
+        """Initialize PyBind CV implementation."""
+        super().__init__()
+        # TODO: Add PyBind-specific initialization
+
+    @classmethod
+    def _load_from(cls,
+                   config: CVModelConfig,
+                   plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP,
+                   device_id: Optional[str] = None
+        ) -> 'PyBindCVImpl':
+        """Load CV model from configuration using PyBind backend."""
+        # TODO: Implement PyBind CV loading
+        instance = cls()
+        return instance
+
+    def eject(self):
+        """Destroy the model and free resources."""
+        # TODO: Implement PyBind CV cleanup
+        pass
+
+    def infer(self, input_image_path: str) -> CVResults:
+        """Perform inference on image."""
+        # TODO: Implement PyBind CV inference
+        raise NotImplementedError("PyBind CV inference not yet implemented")

nexaai/embedder.py

@@ -1,73 +1,73 @@
-from typing import List, Union
-from dataclasses import dataclass
-from abc import abstractmethod
-import numpy as np
-
-from nexaai.base import BaseModel
-from nexaai.common import PluginID
-
-
-@dataclass
-class EmbeddingConfig:
-    batch_size: int = 32
-    normalize: bool = True
-    normalize_method: str = "l2"
-
-
-class Embedder(BaseModel):
-    def __init__(self):
-        """
-        Internal initializer
-        """
-        pass
-
-    @classmethod
-    def _load_from(cls, model_path: str, model_name: str = None, tokenizer_file: str = "tokenizer.json", plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP, **kwargs):
-        """
-        Load an embedder from model files, routing to appropriate implementation.
-
-        Args:
-            model_path: Path to the model file
-            model_name: Name of the model
-            tokenizer_file: Path to the tokenizer file (default: "tokenizer.json")
-            plugin_id: Plugin ID to use for the model (default: PluginID.LLAMA_CPP)
-
-        Returns:
-            Embedder instance
-        """
-        # 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.embedder_impl.mlx_embedder_impl import MLXEmbedderImpl
-            return MLXEmbedderImpl._load_from(model_path, model_name, tokenizer_file, plugin_id)
-        else:
-            from nexaai.embedder_impl.pybind_embedder_impl import PyBindEmbedderImpl
-            return PyBindEmbedderImpl._load_from(model_path, model_name, tokenizer_file, plugin_id)
-
-    @abstractmethod
-    def generate(self, texts: Union[List[str], str] = None, config: EmbeddingConfig = EmbeddingConfig(), input_ids: Union[List[int], List[List[int]]] = None) -> np.ndarray:
-        """
-        Generate embeddings for the given texts or input_ids.
-
-        Args:
-            texts: List of strings or single string to embed
-            input_ids: Pre-tokenized input as:
-                      - Single sequence: list of integers [1, 2, 3, 4]
-                      - Multiple sequences: list of lists [[1, 2, 3], [4, 5, 6]]
-            config: Configuration for embedding generation
-
-        Returns:
-            numpy array of embeddings with shape (num_sequences, embedding_dim)
-        """
-        pass
-
-    @abstractmethod
-    def get_embedding_dim(self) -> int:
-        """
-        Get the embedding dimension of the model
-
-        Returns:
-            The embedding dimension in int
-        """
-        pass
+from typing import List, Union
+from dataclasses import dataclass
+from abc import abstractmethod
+import numpy as np
+
+from nexaai.base import BaseModel
+from nexaai.common import PluginID
+
+
+@dataclass
+class EmbeddingConfig:
+    batch_size: int = 32
+    normalize: bool = True
+    normalize_method: str = "l2"
+
+
+class Embedder(BaseModel):
+    def __init__(self):
+        """
+        Internal initializer
+        """
+        pass
+
+    @classmethod
+    def _load_from(cls, model_path: str, model_name: str = None, tokenizer_file: str = "tokenizer.json", plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP, **kwargs):
+        """
+        Load an embedder from model files, routing to appropriate implementation.
+
+        Args:
+            model_path: Path to the model file
+            model_name: Name of the model
+            tokenizer_file: Path to the tokenizer file (default: "tokenizer.json")
+            plugin_id: Plugin ID to use for the model (default: PluginID.LLAMA_CPP)
+
+        Returns:
+            Embedder instance
+        """
+        # 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.embedder_impl.mlx_embedder_impl import MLXEmbedderImpl
+            return MLXEmbedderImpl._load_from(model_path, model_name, tokenizer_file, plugin_id)
+        else:
+            from nexaai.embedder_impl.pybind_embedder_impl import PyBindEmbedderImpl
+            return PyBindEmbedderImpl._load_from(model_path, model_name, tokenizer_file, plugin_id)
+
+    @abstractmethod
+    def generate(self, texts: Union[List[str], str] = None, config: EmbeddingConfig = EmbeddingConfig(), input_ids: Union[List[int], List[List[int]]] = None) -> np.ndarray:
+        """
+        Generate embeddings for the given texts or input_ids.
+
+        Args:
+            texts: List of strings or single string to embed
+            input_ids: Pre-tokenized input as:
+                      - Single sequence: list of integers [1, 2, 3, 4]
+                      - Multiple sequences: list of lists [[1, 2, 3], [4, 5, 6]]
+            config: Configuration for embedding generation
+
+        Returns:
+            numpy array of embeddings with shape (num_sequences, embedding_dim)
+        """
+        pass
+
+    @abstractmethod
+    def get_embedding_dim(self) -> int:
+        """
+        Get the embedding dimension of the model
+
+        Returns:
+            The embedding dimension in int
+        """
+        pass