nexaai 1.0.18__cp310-cp310-macosx_14_0_universal2.whl → 1.0.19__cp310-cp310-macosx_14_0_universal2.whl

nexaai/utils/model_manager.py

@@ -595,6 +595,7 @@ class HuggingFaceDownloader:
         self.enable_transfer = enable_transfer
         self.original_hf_transfer = None
         self.endpoint = endpoint  # Store endpoint for avatar fetching
+        self._model_info_cache: Dict[str, Any] = {}  # Cache for model_info results
         
     def _create_repo_directory(self, local_dir: str, repo_id: str) -> str:
         """Create a directory structure for the repository following HF convention."""
@@ -618,6 +619,32 @@ class HuggingFaceDownloader:
         os.makedirs(local_dir, exist_ok=True)
         return local_dir
     
+    def _get_model_info_cached(self, repo_id: str, files_metadata: bool = False):
+        """Get model info with caching to avoid rate limiting.
+        
+        Args:
+            repo_id: Repository ID
+            files_metadata: Whether to include files metadata
+            
+        Returns:
+            Model info object from HuggingFace API
+        """
+        # Create cache key based on repo_id and files_metadata flag
+        cache_key = f"{repo_id}:files={files_metadata}"
+        
+        # Return cached result if available
+        if cache_key in self._model_info_cache:
+            return self._model_info_cache[cache_key]
+        
+        # Fetch from API and cache the result
+        try:
+            info = self.api.model_info(repo_id, files_metadata=files_metadata, token=self.token)
+            self._model_info_cache[cache_key] = info
+            return info
+        except Exception:
+            # Don't cache errors, re-raise
+            raise
+    
     def _get_repo_info_for_progress(
         self,
         repo_id: str,
@@ -625,7 +652,7 @@ class HuggingFaceDownloader:
     ) -> tuple[int, int]:
         """Get total repository size and file count for progress tracking."""
         try:
-            info = self.api.model_info(repo_id, files_metadata=True, token=self.token)
+            info = self._get_model_info_cached(repo_id, files_metadata=True)
             
             total_size = 0
             file_count = 0
@@ -720,7 +747,7 @@ class HuggingFaceDownloader:
     ):
         """Validate repository exists and get info."""
         try:
-            info = self.api.model_info(repo_id, token=self.token)
+            info = self._get_model_info_cached(repo_id, files_metadata=False)
             return info
         except RepositoryNotFoundError:
             error_msg = f"Repository '{repo_id}' not found. Please check the repository ID."
@@ -789,6 +816,36 @@ class HuggingFaceDownloader:
         # If no expected size, just check that file is not empty
         return os.path.getsize(file_path) > 0
     
+    def _extract_model_file_type_from_tags(self, repo_id: str) -> Optional[str]:
+        """Extract model file type from repo tags with priority: NPU > MLX > GGUF."""
+        try:
+            info = self._get_model_info_cached(repo_id, files_metadata=False)
+            if hasattr(info, 'tags') and info.tags:
+                # Convert tags to lowercase for case-insensitive matching
+                tags_lower = [tag.lower() for tag in info.tags]
+                
+                # Check with priority: NPU > MLX > GGUF
+                if 'npu' in tags_lower:
+                    return 'npu'
+                elif 'mlx' in tags_lower:
+                    return 'mlx'
+                elif 'gguf' in tags_lower:
+                    return 'gguf'
+        except Exception:
+            pass
+        return None
+    
+    def _load_downloaded_manifest(self, local_dir: str) -> Dict[str, Any]:
+        """Load nexa.manifest from the downloaded repository if it exists."""
+        manifest_path = os.path.join(local_dir, 'nexa.manifest')
+        if os.path.exists(manifest_path):
+            try:
+                with open(manifest_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError):
+                pass
+        return {}
+    
     def _fetch_and_save_metadata(self, repo_id: str, local_dir: str, is_mmproj: bool = False, file_name: Optional[Union[str, List[str]]] = None, **kwargs) -> None:
         """Fetch model info and save metadata after successful download."""
         # Initialize metadata with defaults to ensure manifest is always created
@@ -800,8 +857,8 @@ class HuggingFaceDownloader:
         
         # Try to fetch additional metadata, but don't let failures prevent manifest creation
         try:
-            # Fetch model info to get pipeline_tag
-            info = self.api.model_info(repo_id, token=self.token)
+            # Fetch model info to get pipeline_tag (using cache)
+            info = self._get_model_info_cached(repo_id, files_metadata=False)
             if hasattr(info, 'pipeline_tag') and info.pipeline_tag:
                 old_metadata['pipeline_tag'] = info.pipeline_tag
         except Exception as e:
@@ -810,11 +867,21 @@ class HuggingFaceDownloader:
         
         # Use input avater url if provided
         old_metadata['avatar_url'] = kwargs.get('avatar_url')
+        
+        # Extract model file type from tags
+        model_file_type = self._extract_model_file_type_from_tags(repo_id)
+        if model_file_type:
+            old_metadata['model_file_type'] = model_file_type
+        
+        # Load existing nexa.manifest from downloaded repo (if exists)
+        downloaded_manifest = self._load_downloaded_manifest(local_dir)
+        if downloaded_manifest:
+            old_metadata['downloaded_manifest'] = downloaded_manifest
 
         
         # CRITICAL: Always create the manifest file, regardless of metadata fetch failures
         try:
-            save_manifest_with_files_metadata(repo_id, local_dir, old_metadata, is_mmproj, file_name)
+            save_manifest_with_files_metadata(repo_id, local_dir, old_metadata, is_mmproj, file_name, **kwargs)
             print(f"[OK] Successfully created nexa.manifest for {repo_id}")
         except Exception as e:
             # This is critical - if manifest creation fails, we should know about it
@@ -823,8 +890,11 @@ class HuggingFaceDownloader:
             try:
                 minimal_manifest = {
                     "Name": repo_id,
-                    "ModelType": "other",
-                    "PluginId": "unknown",
+                    "ModelName": kwargs.get('model_name', ''),
+                    "ModelType": kwargs.get('model_type', 'other'),
+                    "PluginId": kwargs.get('plugin_id', 'unknown'),
+                    "DeviceId": kwargs.get('device_id', ''),
+                    "MinSDKVersion": kwargs.get('min_sdk_version', ''),
                     "ModelFile": {},
                     "MMProjFile": {"Name": "", "Downloaded": False, "Size": 0},
                     "TokenizerFile": {"Name": "", "Downloaded": False, "Size": 0},
@@ -1136,6 +1206,12 @@ def download_from_huggingface(
         is_mmproj (bool, optional): Whether the file being downloaded is an mmproj file. Only used when
                                    file_name is not None. If None, defaults to True if 'mmproj' is in 
                                    the filename, False otherwise.
+        **kwargs: Additional parameters including:
+            - plugin_id (str): Override PluginId in nexa.manifest (highest priority)
+            - model_name (str): Override ModelName in nexa.manifest (highest priority)
+            - model_type (str): Override ModelType in nexa.manifest (highest priority)
+            - device_id (str): Set DeviceId in nexa.manifest (highest priority)
+            - min_sdk_version (str): Set MinSDKVersion in nexa.manifest (highest priority)
     
     Returns:
         str: Path to the downloaded file or directory
@@ -1213,7 +1289,7 @@ def _download_model_if_needed(
     token: Union[bool, str, None] = None,
     is_mmproj: bool = False,
     **kwargs
-) -> str:
+) -> tuple[str, Optional[str]]:
     """
     Helper function to download a model from HuggingFace if it doesn't exist locally.
     
@@ -1224,15 +1300,38 @@ def _download_model_if_needed(
         token: HuggingFace authentication token for private repositories
         
     Returns:
-        str: Local path to the model (either existing or downloaded)
+        tuple[str, Optional[str]]: Tuple of (local_path, model_name)
+            - local_path: Local path to the model (either existing or downloaded)
+            - model_name: ModelName from nexa.manifest if available, None otherwise
         
     Raises:
         RuntimeError: If download fails
     """
+    # Helper function to extract model_name from manifest
+    def _extract_model_name_from_manifest(path: str) -> Optional[str]:
+        """Extract ModelName from nexa.manifest if it exists."""
+        # If path is a file, check its parent directory for manifest
+        if os.path.isfile(path):
+            manifest_dir = os.path.dirname(path)
+        else:
+            manifest_dir = path
+        
+        manifest_path = os.path.join(manifest_dir, 'nexa.manifest')
+        if not os.path.exists(manifest_path):
+            return None
+        
+        try:
+            with open(manifest_path, 'r', encoding='utf-8') as f:
+                manifest = json.load(f)
+                return manifest.get('ModelName')
+        except (json.JSONDecodeError, IOError):
+            return None
+    
     # Check if model_path exists locally (file or directory)
     if os.path.exists(model_path):
-        # Local path exists, return as-is
-        return model_path
+        # Local path exists, try to extract model_name
+        model_name = _extract_model_name_from_manifest(model_path)
+        return model_path, model_name
     
     # Model path doesn't exist locally, try to download from HuggingFace
     try:
@@ -1252,7 +1351,10 @@ def _download_model_if_needed(
             **kwargs
         )
         
-        return downloaded_path
+        # Extract model_name from the downloaded manifest
+        model_name = _extract_model_name_from_manifest(downloaded_path)
+        
+        return downloaded_path, model_name
         
     except Exception as e:
         # Only handle download-related errors
@@ -1321,7 +1423,7 @@ def auto_download_model(func: Callable) -> Callable:
         # Download name_or_path if needed
         if name_or_path is not None:
             try:
-                downloaded_name_path = _download_model_if_needed(
+                downloaded_name_path, model_name = _download_model_if_needed(
                     name_or_path, 'name_or_path', progress_callback, token, **kwargs
                 )
                 
@@ -1332,6 +1434,10 @@ def auto_download_model(func: Callable) -> Callable:
                         args = tuple(args_list)
                 else:
                     kwargs['name_or_path'] = downloaded_name_path
+                
+                # Add model_name to kwargs if it exists and not already set
+                if model_name is not None and 'model_name' not in kwargs:
+                    kwargs['model_name'] = model_name
                     
             except Exception as e:
                 raise e  # Re-raise the error from _download_model_if_needed
@@ -1339,7 +1445,7 @@ def auto_download_model(func: Callable) -> Callable:
         # Download mmproj_path if needed
         if mmproj_path is not None:
             try:
-                downloaded_mmproj_path = _download_model_if_needed(
+                downloaded_mmproj_path, _ = _download_model_if_needed(
                     mmproj_path, 'mmproj_path', progress_callback, token, is_mmproj=True, **kwargs
                 )
                 

nexaai/utils/model_types.py

@@ -13,6 +13,8 @@ class ModelTypeMapping(Enum):
     """Enum for mapping HuggingFace pipeline_tag to our ModelType."""
     TEXT_GENERATION = ("text-generation", "llm")
     IMAGE_TEXT_TO_TEXT = ("image-text-to-text", "vlm")
+    ANY_TO_ANY = ("any-to-any", "ata")
+    AUTOMATIC_SPEECH_RECOGNITION = ("automatic-speech-recognition", "asr")
     
     def __init__(self, pipeline_tag: str, model_type: str):
         self.pipeline_tag = pipeline_tag

nexaai/vlm.py

@@ -22,7 +22,8 @@ class VLM(BaseModel):
                    model_name: Optional[str] = None,
                    m_cfg: ModelConfig = ModelConfig(),
                    plugin_id: Union[PluginID, str] = PluginID.LLAMA_CPP,
-                   device_id: Optional[str] = None
+                   device_id: Optional[str] = None,
+                   **kwargs
         ) -> 'VLM':
         """Load VLM model from local path, routing to appropriate implementation.
         

{nexaai-1.0.18.dist-info → nexaai-1.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexaai
-Version: 1.0.18
+Version: 1.0.19
 Summary: Python bindings for NexaSDK C-lib backend
 Author-email: "Nexa AI, Inc." <dev@nexa.ai>
 Project-URL: Homepage, https://github.com/NexaAI/nexasdk-bridge
@@ -14,7 +14,6 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: huggingface_hub
 Requires-Dist: tqdm
-Requires-Dist: hf_xet
 Requires-Dist: numpy
 Requires-Dist: httpx
 Provides-Extra: mlx