nexaai 1.0.19rc7__cp310-cp310-macosx_14_0_universal2.whl → 1.0.19rc8__cp310-cp310-macosx_14_0_universal2.whl

nexaai/binds/nexa_mlx/py-lib/cv/interface.py

@@ -1,151 +0,0 @@
-# Copyright © Nexa AI
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import os
-import json
-import time
-import cv2
-import numpy as np
-from pathlib import Path
-from typing import Any, List, Optional, Sequence, Tuple, Union
-from PIL import Image
-from dataclasses import dataclass
-
-# Import necessary modules 
-import mlx.core as mx
-
-# Import from ml.py for API alignment
-from ml import (
-    CVModel as BaseCVModel,
-    CVModelConfig,
-    CVResults,
-    CVResult,
-    CVCapabilities,
-    Path as PathType,
-)
-
-# Import the model implementation
-from .modeling.pp_ocr_v4 import Config, TextSystem
-
-@dataclass
-class CVConfig:
-    """Configuration for CV processing."""
-    batch_size: int = 1
-    drop_score: float = 0.5
-    font_path: Optional[str] = None
-
-    def __init__(
-        self,
-        batch_size: int = 1,
-        drop_score: float = 0.5,
-        font_path: Optional[str] = None,
-    ) -> None:
-        self.batch_size = batch_size
-        self.drop_score = drop_score
-        self.font_path = font_path
-
-
-class CVModel(BaseCVModel):
-    """
-    CV Model interface for MLX OCR models.
-    API aligned with ml.py CVModel abstract base class.
-    """
-    def __init__(
-        self,
-        config: CVModelConfig,
-        device: Optional[str] = None,
-    ) -> None:
-        super().__init__(config, device)
-        # print(f"config: {config}")
-        # TODO: this hack is to support local model path
-        # hack only support pp_ocr_v4
-        rec_model_path_str = str(config.rec_model_path) if config.rec_model_path else None
-        model_cache_dir = os.path.dirname(rec_model_path_str) if rec_model_path_str else None
-        # print(f"model_cache_dir: {model_cache_dir}")
-        cfg = Config(model_cache_dir)
-        # print(f"cfg: {cfg}")
-        cfg.device = self.device
-        self.ocr_system = TextSystem(cfg)
-
-    def destroy(self) -> None:
-        """Destroy the model and free resources."""
-        self.ocr_system = None
-        self.config = None
-
-    def close(self) -> None:
-        """Close the model."""
-        self.destroy()
-
-    def infer(self, input_image_path: str, clear_cache: bool = True) -> CVResults:
-        """Perform inference on image."""
-        if self.ocr_system is None:
-            raise RuntimeError("Model not loaded. Call load_model() first.")
-        
-        # Load image
-        img = self._load_image(input_image_path)
-        if img is None:
-            raise ValueError(f"Failed to load image: {input_image_path}")
-        
-        # Process with OCR
-        boxes, recs = self.ocr_system(img)
-
-        if clear_cache:
-            mx.clear_cache()
-        
-        # Convert to CVResults format
-        results = []
-        for box, (text, score) in zip(boxes, recs):
-            # Create CVResult
-            result = CVResult(
-                text=text,
-                confidence=score,
-                # Note: OCR doesn't use bounding boxes in the same way as detection models
-                # but we can store the box coordinates if needed
-            )
-            results.append(result)
-        
-        return CVResults(results=results, result_count=len(results))
-
-    
-    def _load_image(self, image_path: Union[str, PathType]) -> Optional[np.ndarray]:
-        """Load image from path."""
-        try:
-            # Check if it's a GIF
-            if str(image_path).lower().endswith('.gif'):
-                gif = cv2.VideoCapture(str(image_path))
-                ret, frame = gif.read()
-                if not ret:
-                    return None
-                if len(frame.shape) == 2 or frame.shape[-1] == 1:
-                    frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
-                return frame[:, :, ::-1]  # BGR to RGB
-            else:
-                img = cv2.imread(str(image_path))
-                if img is None:
-                    return None
-                return img
-        except Exception as e:
-            print(f"Error loading image {image_path}: {e}")
-            return None
-
-
-
-def create_cv_model(
-    config: CVModelConfig,
-    device: Optional[str] = None,
-) -> CVModel:
-    """Create a CV model instance."""
-    return CVModel(config, device) 

nexaai/binds/nexa_mlx/py-lib/cv/main.py

@@ -1,81 +0,0 @@
-# Copyright © Nexa AI
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-
-from .interface import create_cv_model, CVModelConfig
-
-
-def test_cv_model(model_path, test_image_path):
-    """Test CV model functionality."""
-    
-    # Create CVModelConfig
-    config = CVModelConfig(
-        capabilities=0,  # ML_CV_OCR
-        model_path=model_path,
-        system_library_path=None,
-        backend_library_path=None,
-        extension_library_path=None,
-        config_file_path=None,
-        char_dict_path=None
-    )
-    
-    model = create_cv_model(config)
-    print("✅ Model loaded successfully!")
-    
-    # Test images (you can replace these with actual image paths)
-    test_images = [
-        "cv/modeling/input/20250406-170821.jpeg",
-        "cv/modeling/input/20250406-170838.jpeg",
-        "cv/modeling/input/20250406-170906.jpeg",
-        "cv/modeling/input/20250407-154044.jpeg",
-        "cv/modeling/input/20250407-154059.jpeg"
-    ] if test_image_path is None else [test_image_path]
-    
-    for img_path in test_images:
-        if not os.path.exists(img_path):
-            print(f"❌ Image file not found: {img_path}")
-            continue
-        
-        results = model.infer(img_path)
-        print(f"✅ OCR Results for {img_path}:")
-        print("=" * 50)
-
-        if results.result_count == 0:
-            print("No text detected in the image.")
-        else:
-            print(f"Found {results.result_count} text regions:")
-            
-            for i, result in enumerate(results.results):
-                print(f"\nRegion {i+1}:")
-                print(f"  Text: '{result.text}'")
-                print(f"  Confidence: {result.confidence:.3f}")
-    
-    print("\n✅ CV model test completed!")
-
-
-if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="Test CV processor functionality")
-    parser.add_argument("--model_path", type=str, default="nexaml/paddle-ocr-mlx", 
-                       help="Path to the CV model")
-    parser.add_argument("--image_path", type=str, default=None,
-                       help="Path to a specific image to process")
-    parser.add_argument("--test_mode", action="store_true",
-                       help="Run in test mode with sample images")
-    
-    args = parser.parse_args()
-    
-    test_cv_model(args.model_path, args.image_path) 
-