nexaai 1.0.9__cp310-cp310-win_amd64.whl → 1.0.11rc1__cp310-cp310-win_amd64.whl

nexaai/_version.py

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

nexaai/embedder_impl/mlx_embedder_impl.py

@@ -3,7 +3,7 @@ import numpy as np
 
 from nexaai.common import PluginID
 from nexaai.embedder import Embedder, EmbeddingConfig
-from nexaai.mlx_backend.embedding.interface import create_embedder
+from nexaai.mlx_backend.embedding.interface import Embedder as MLXEmbedderInterface
 from nexaai.mlx_backend.ml import ModelConfig as MLXModelConfig, SamplerConfig as MLXSamplerConfig, GenerationConfig as MLXGenerationConfig, EmbeddingConfig
 
 
@@ -27,12 +27,11 @@ class MLXEmbedderImpl(Embedder):
             MLXEmbedderImpl instance
         """
         try:
-            # Create instance
-            instance = cls()
+            # MLX interface is already imported
             
-            # Use the factory function to create the appropriate embedder based on model type
-            # This will automatically detect if it's JinaV2 or generic model and route correctly
-            instance._mlx_embedder = create_embedder(
+            # Create instance and load MLX embedder
+            instance = cls()
+            instance._mlx_embedder = MLXEmbedderInterface(
                 model_path=model_path,
                 tokenizer_path=tokenizer_file
             )

nexaai/utils/model_manager.py

@@ -5,22 +5,17 @@ from datetime import datetime
 from dataclasses import dataclass
 from typing import Optional, Callable, Dict, Any, List, Union
 import functools
-from enum import Enum
 from tqdm.auto import tqdm
 from huggingface_hub import HfApi
 from huggingface_hub.utils import HfHubHTTPError, RepositoryNotFoundError
 
 from .progress_tracker import CustomProgressTqdm, DownloadProgressTracker
 from .avatar_fetcher import get_avatar_url_for_repo
-from .manifest_utils import (
-    load_download_metadata,
-    save_download_metadata,
-    save_manifest_with_files_metadata,
-)
 
 # Default path for model storage
 DEFAULT_MODEL_SAVING_PATH = "~/.cache/nexa.ai/nexa_sdk/models/"
 
+
 @dataclass
 class DownloadedModel:
     """Data class representing a downloaded model with all its metadata."""
@@ -93,6 +88,30 @@ def _check_for_incomplete_downloads(directory_path: str) -> bool:
         # If we can't access the directory, assume download is complete
         return True
 
+
+def _load_download_metadata(directory_path: str) -> Dict[str, Any]:
+    """Load download metadata from download_metadata.json if it exists."""
+    metadata_path = os.path.join(directory_path, 'download_metadata.json')
+    if os.path.exists(metadata_path):
+        try:
+            with open(metadata_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {}
+
+
+def _save_download_metadata(directory_path: str, metadata: Dict[str, Any]) -> None:
+    """Save download metadata to download_metadata.json."""
+    metadata_path = os.path.join(directory_path, 'download_metadata.json')
+    try:
+        with open(metadata_path, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f, indent=2)
+    except IOError:
+        # If we can't save metadata, don't fail the download
+        pass
+
+
 def _get_directory_size_and_files(directory_path: str) -> tuple[int, List[str]]:
     """Get total size and list of files in a directory."""
     total_size = 0
@@ -118,13 +137,6 @@ def _get_directory_size_and_files(directory_path: str) -> tuple[int, List[str]]:
     return total_size, files
 
 
-def _has_valid_metadata(directory_path: str) -> bool:
-    """Check if directory has either nexa.manifest or download_metadata.json (for backward compatibility)."""
-    manifest_path = os.path.join(directory_path, 'nexa.manifest')
-    old_metadata_path = os.path.join(directory_path, 'download_metadata.json')
-    return os.path.exists(manifest_path) or os.path.exists(old_metadata_path)
-
-
 def _scan_for_repo_folders(base_path: str) -> List[DownloadedModel]:
     """Scan a directory for repository folders and return model information."""
     models = []
@@ -150,27 +162,24 @@ def _scan_for_repo_folders(base_path: str) -> List[DownloadedModel]:
                     if os.path.isdir(subitem_path):
                         has_subdirs = True
                         # This looks like owner/repo structure
-                        # Only include if nexa.manifest or download_metadata.json exists (backward compatibility)
-                        if _has_valid_metadata(subitem_path):
-                            size_bytes, files = _get_directory_size_and_files(subitem_path)
-                            if files:  # Only include if there are files
-                                # Check if the download is complete
-                                download_complete = _check_for_incomplete_downloads(subitem_path)
-                                # Load metadata if it exists
-                                repo_id = f"{item}/{subitem}"
-                                metadata = load_download_metadata(subitem_path, repo_id)
-                                models.append(DownloadedModel(
-                                    repo_id=repo_id,
-                                    files=files,
-                                    folder_type='owner_repo',
-                                    local_path=subitem_path,
-                                    size_bytes=size_bytes,
-                                    file_count=len(files),
-                                    full_repo_download_complete=download_complete,
-                                    pipeline_tag=metadata.get('pipeline_tag'),
-                                    download_time=metadata.get('download_time'),
-                                    avatar_url=metadata.get('avatar_url')
-                                ))
+                        size_bytes, files = _get_directory_size_and_files(subitem_path)
+                        if files:  # Only include if there are files
+                            # Check if the download is complete
+                            download_complete = _check_for_incomplete_downloads(subitem_path)
+                            # Load metadata if it exists
+                            metadata = _load_download_metadata(subitem_path)
+                            models.append(DownloadedModel(
+                                repo_id=f"{item}/{subitem}",
+                                files=files,
+                                folder_type='owner_repo',
+                                local_path=subitem_path,
+                                size_bytes=size_bytes,
+                                file_count=len(files),
+                                full_repo_download_complete=download_complete,
+                                pipeline_tag=metadata.get('pipeline_tag'),
+                                download_time=metadata.get('download_time'),
+                                avatar_url=metadata.get('avatar_url')
+                            ))
                     else:
                         direct_files.append(subitem)
             except (OSError, IOError):
@@ -179,27 +188,24 @@ def _scan_for_repo_folders(base_path: str) -> List[DownloadedModel]:
             
             # Direct repo folder (no owner structure)
             if not has_subdirs and direct_files:
-                # Only include if nexa.manifest or download_metadata.json exists (backward compatibility)
-                if _has_valid_metadata(item_path):
-                    size_bytes, files = _get_directory_size_and_files(item_path)
-                    if files:  # Only include if there are files
-                        # Check if the download is complete
-                        download_complete = _check_for_incomplete_downloads(item_path)
-                        # Load metadata if it exists
-                        repo_id = item
-                        metadata = load_download_metadata(item_path, repo_id)
-                        models.append(DownloadedModel(
-                            repo_id=repo_id,
-                            files=files,
-                            folder_type='direct_repo',
-                            local_path=item_path,
-                            size_bytes=size_bytes,
-                            file_count=len(files),
-                            full_repo_download_complete=download_complete,
-                            pipeline_tag=metadata.get('pipeline_tag'),
-                            download_time=metadata.get('download_time'),
-                            avatar_url=metadata.get('avatar_url')
-                        ))
+                size_bytes, files = _get_directory_size_and_files(item_path)
+                if files:  # Only include if there are files
+                    # Check if the download is complete
+                    download_complete = _check_for_incomplete_downloads(item_path)
+                    # Load metadata if it exists
+                    metadata = _load_download_metadata(item_path)
+                    models.append(DownloadedModel(
+                        repo_id=item,
+                        files=files,
+                        folder_type='direct_repo',
+                        local_path=item_path,
+                        size_bytes=size_bytes,
+                        file_count=len(files),
+                        full_repo_download_complete=download_complete,
+                        pipeline_tag=metadata.get('pipeline_tag'),
+                        download_time=metadata.get('download_time'),
+                        avatar_url=metadata.get('avatar_url')
+                    ))
     
     except (OSError, IOError):
         # Skip if base path can't be accessed
@@ -729,57 +735,27 @@ class HuggingFaceDownloader:
     
     def _fetch_and_save_metadata(self, repo_id: str, local_dir: str) -> None:
         """Fetch model info and save metadata after successful download."""
-        # Initialize metadata with defaults to ensure manifest is always created
-        old_metadata = {
-            'pipeline_tag': "text-generation", # Default to text-generation pipeline-tag
-            'download_time': datetime.now().isoformat(),
-            'avatar_url': None
-        }
-        
-        # 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)
-            if hasattr(info, 'pipeline_tag'):
-                old_metadata['pipeline_tag'] = info.pipeline_tag
-        except Exception as e:
-            # Log the error but continue with manifest creation
-            print(f"Warning: Could not fetch model info for {repo_id}: {e}")
-        
-        try:
+            pipeline_tag = info.pipeline_tag if hasattr(info, 'pipeline_tag') else None
+            
             # Get avatar URL
             avatar_url = get_avatar_url_for_repo(repo_id, custom_endpoint=self.endpoint)
-            if avatar_url:
-                old_metadata['avatar_url'] = avatar_url
-        except Exception as e:
-            # Log the error but continue with manifest creation
-            print(f"Warning: Could not fetch avatar URL for {repo_id}: {e}")
-        
-        # CRITICAL: Always create the manifest file, regardless of metadata fetch failures
-        try:
-            save_manifest_with_files_metadata(repo_id, local_dir, old_metadata)
-            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
-            print(f"ERROR: Failed to create nexa.manifest for {repo_id}: {e}")
-            # Try a fallback approach - create a minimal manifest
-            try:
-                minimal_manifest = {
-                    "Name": repo_id,
-                    "ModelType": "other",
-                    "PluginId": "unknown",
-                    "ModelFile": {},
-                    "MMProjFile": {"Name": "", "Downloaded": False, "Size": 0},
-                    "TokenizerFile": {"Name": "", "Downloaded": False, "Size": 0},
-                    "ExtraFiles": None,
-                    "pipeline_tag": old_metadata.get('pipeline_tag'),
-                    "download_time": old_metadata.get('download_time'),
-                    "avatar_url": old_metadata.get('avatar_url')
-                }
-                save_download_metadata(local_dir, minimal_manifest)
-                print(f"[OK] Created minimal nexa.manifest for {repo_id} as fallback")
-            except Exception as fallback_error:
-                print(f"CRITICAL ERROR: Could not create even minimal manifest for {repo_id}: {fallback_error}")
+            
+            # Prepare metadata
+            metadata = {
+                'pipeline_tag': pipeline_tag,
+                'download_time': datetime.now().isoformat(),
+                'avatar_url': avatar_url
+            }
+            
+            # Save metadata to the repository directory
+            _save_download_metadata(local_dir, metadata)
+            
+        except Exception:
+            # Don't fail the download if metadata fetch fails
+            pass
     
     def _download_single_file(
         self,
@@ -796,7 +772,7 @@ class HuggingFaceDownloader:
         # Check if file already exists
         local_file_path = os.path.join(file_local_dir, file_name)
         if not force_download and self._check_file_exists_and_valid(local_file_path):
-            print(f"[SKIP] File already exists: {file_name}")
+            print(f"✓ File already exists, skipping: {file_name}")
             # Stop progress tracking
             if progress_tracker:
                 progress_tracker.stop_tracking()
@@ -844,6 +820,14 @@ class HuggingFaceDownloader:
         # Create a subdirectory for this specific repo
         repo_local_dir = self._create_repo_directory(local_dir, repo_id)
         
+        # Check if repository already exists (basic check for directory existence)
+        if not force_download and os.path.exists(repo_local_dir) and os.listdir(repo_local_dir):
+            print(f"✓ Repository already exists, skipping: {repo_id}")
+            # Stop progress tracking
+            if progress_tracker:
+                progress_tracker.stop_tracking()
+            return repo_local_dir
+        
         try:
             download_kwargs = {
                 'repo_id': repo_id,
@@ -903,7 +887,7 @@ class HuggingFaceDownloader:
                 # Check if file already exists
                 local_file_path = os.path.join(repo_local_dir, file_name)
                 if not force_download and self._check_file_exists_and_valid(local_file_path):
-                    print(f"[SKIP] File already exists: {file_name}")
+                    print(f"✓ File already exists, skipping: {file_name}")
                     overall_progress.update(1)
                     continue
                 

nexaai/utils/progress_tracker.py

@@ -107,7 +107,7 @@ class DownloadProgressTracker:
             time_diff = current_time - self.last_time
             
             # Only calculate if we have a meaningful time difference (avoid division by very small numbers)
-            if time_diff > 0.1:  # At least 100ms between measurements
+            if time_diff > 0.5:  # At least 500ms between measurements
                 bytes_diff = current_downloaded - self.last_downloaded
                 
                 # Only calculate speed if bytes actually changed
@@ -118,14 +118,6 @@ class DownloadProgressTracker:
                     self.speed_history.append(speed)
                     if len(self.speed_history) > self.max_speed_history:
                         self.speed_history.pop(0)
-                    
-                    # Update tracking variables when we actually calculate speed
-                    self.last_downloaded = current_downloaded
-                    self.last_time = current_time
-        else:
-            # First measurement - initialize tracking variables
-            self.last_downloaded = current_downloaded
-            self.last_time = current_time
         
         # Return the average of historical speeds if we have any
         # This ensures we show the last known speed even when skipping updates
@@ -165,9 +157,13 @@ class DownloadProgressTracker:
                 total_file_sizes += data['total']
                 active_file_count += 1
         
-        # Calculate speed (tracking variables are updated internally)
+        # Calculate speed
         speed = self.calculate_speed(total_downloaded)
         
+        # Update tracking variables
+        self.last_downloaded = total_downloaded
+        self.last_time = time.time()
+        
         # Determine total size - prioritize pre-fetched repo size, then aggregate file sizes
         if self.total_repo_size > 0:
             # Use pre-fetched repository info if available
@@ -249,11 +245,11 @@ class DownloadProgressTracker:
         if known_total and total_size_raw > 0:
             # Known total size - show actual progress
             filled_width = int(bar_width * min(percentage, 100) / 100)
-            bar = '#' * filled_width + '-' * (bar_width - filled_width)
+            bar = '█' * filled_width + '░' * (bar_width - filled_width)
         else:
             # Unknown total size - show animated progress
             animation_pos = int(time.time() * 2) % bar_width
-            bar = '-' * animation_pos + '#' + '-' * (bar_width - animation_pos - 1)
+            bar = '░' * animation_pos + '█' + '░' * (bar_width - animation_pos - 1)
         
         # Format the progress line
         status = progress_data.get('status', 'unknown')

{nexaai-1.0.9.dist-info → nexaai-1.0.11rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexaai
-Version: 1.0.9
+Version: 1.0.11rc1
 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
@@ -21,7 +21,6 @@ Provides-Extra: mlx
 Requires-Dist: mlx; extra == "mlx"
 Requires-Dist: mlx-lm; extra == "mlx"
 Requires-Dist: mlx-vlm; extra == "mlx"
-Requires-Dist: mlx-embeddings; extra == "mlx"
 Requires-Dist: tokenizers; extra == "mlx"
 Requires-Dist: safetensors; extra == "mlx"
 Requires-Dist: Pillow; extra == "mlx"

{nexaai-1.0.9.dist-info → nexaai-1.0.11rc1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 nexaai/__init__.py,sha256=Lt8NU57eTMtWrDYzpFeYR9XtGAPXqizynP83TPU0UW0,2105
-nexaai/_stub.cp310-win_amd64.pyd,sha256=prPCDVLT2TNclJO6TTUEqn7cIhKvCt-T0J6cobBaSlY,10752
-nexaai/_version.py,sha256=YNusSkVDDoIG_U-jPH9h6HT-4PWMEdZ7mfTwH3R1-xg,142
+nexaai/_stub.cp310-win_amd64.pyd,sha256=7aqosa3n18u2ozQ1vEFLREjBe1LsDwbga_XtCvEtXDI,10752
+nexaai/_version.py,sha256=IAZFz3Tmh0wm59QVo7wZ0vs1f6pEESeZiaGrhy9wl8Y,147
 nexaai/asr.py,sha256=_fsGaxpiU137bUtO5ujtFSYCI1RLsyeEm3Gf4GhHVRk,2118
 nexaai/base.py,sha256=qQBCiQVNzgpkQjZX9aiFDEdbAAe56TROKC3WnWra2Zg,1021
 nexaai/common.py,sha256=6keIpdX5XS5us4z79EMoa6RSkVze9SbbXax13IJ9yvs,3525
@@ -16,25 +16,25 @@ nexaai/asr_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/asr_impl/mlx_asr_impl.py,sha256=XwMX3LYMeulp8cDS0TCCYcjvttFHAyDWQ_oMvABwQmI,3349
 nexaai/asr_impl/pybind_asr_impl.py,sha256=20o5SOPzhF9x41ra8L_qIM7YxCkYeLb5csSrNde-dds,1560
 nexaai/binds/__init__.py,sha256=tYvy0pFhoY29GstDT5r-oRiPRarPLECvJAkcamJItOg,83
-nexaai/binds/common_bind.cp310-win_amd64.pyd,sha256=0R-nkrDqQyEHgdp_U-CqjnExG75RQPqVSlaioQCu6yQ,201216
-nexaai/binds/embedder_bind.cp310-win_amd64.pyd,sha256=7MixJxfH945Z-PD6DR591YoSJjpH27RZiyrJsHdCEeM,182784
+nexaai/binds/common_bind.cp310-win_amd64.pyd,sha256=V0gHlgHOmcKqFllX-4-0_WZkeGIfB1ZJhv2ygQHt2DE,201216
+nexaai/binds/embedder_bind.cp310-win_amd64.pyd,sha256=c-FvvhkIQNffP4qPABCZd7P0I3M7dAu7q5iXJXliFUE,182784
 nexaai/binds/libcrypto-3-x64.dll,sha256=-Lau6pL5DpDXzpg9MED63gCeL8oRrSLI_e2LeaxIHqk,7314432
 nexaai/binds/libssl-3-x64.dll,sha256=Tzzyu5jRpUugFxr_65hbFlAtFpjxIDpOYMU1E0ijkJw,1313792
-nexaai/binds/llm_bind.cp310-win_amd64.pyd,sha256=M7IhRGIJA_BqYGLE2e_0aiF0Bo-YbfX-G8xANIfmhpk,162816
-nexaai/binds/nexa_bridge.dll,sha256=afAM7Sfz3Wx-Xy29D4FP0dgVuFbH1kpC2iPzqxVm8wc,178688
-nexaai/binds/nexa_llama_cpp/ggml-base.dll,sha256=KI4qpa6BKAO-v-q3F6kUE44oQp-X0Po41Hg-QWHGIxk,513536
-nexaai/binds/nexa_llama_cpp/ggml-cpu.dll,sha256=ZmPo74eaazq0Y-D_8FNIvtKJqI-xxq1xpVwUG65rlWo,656384
-nexaai/binds/nexa_llama_cpp/ggml-cuda.dll,sha256=kuAps8hxorUWCvpxrgVkZBGf-NQFsHFozX06wwjyF9A,302319616
-nexaai/binds/nexa_llama_cpp/ggml-vulkan.dll,sha256=5SclfC18rbvdhwhgClv-r31H_GIMbrZoIu8ZTgQSxFw,24686080
-nexaai/binds/nexa_llama_cpp/ggml.dll,sha256=c9eLBKMyy8yVaytb3_aRz8Q8LL16U8XhhKmJ7_FfeFw,66560
-nexaai/binds/nexa_llama_cpp/llama.dll,sha256=AGKbkn8-9EGnEGTZRudHiVPXZBZKbyCDO-18CbMjJBg,1587712
-nexaai/binds/nexa_llama_cpp/mtmd.dll,sha256=zH17sJtxpCWLCZMaQ3TiEydhvI0FJLZzU0E5-dxkenQ,557056
-nexaai/binds/nexa_llama_cpp/nexa_plugin.dll,sha256=eNqgG5-3XeNRpRRSudtr1gpbIIlD58_G-W_tqgs4dYY,1366528
+nexaai/binds/llm_bind.cp310-win_amd64.pyd,sha256=-mpRfsSUoM-aYVlDW2pEq6v7tDPAzK0MtMjHySr_rr0,162816
+nexaai/binds/nexa_bridge.dll,sha256=qfsnj_Jts1ReToEMqvofLrVK4vImTSD1GgOHPWg2kD4,166912
+nexaai/binds/nexa_llama_cpp/ggml-base.dll,sha256=a3OsLcS9AAuQ-nKTDqi5BUYrfAU_6rY5pP7dnOgWzUQ,514560
+nexaai/binds/nexa_llama_cpp/ggml-cpu.dll,sha256=M72uWKily3IsUgc1XDYlTA3q0t6RYrJMJmeRyk9-oa8,663552
+nexaai/binds/nexa_llama_cpp/ggml-cuda.dll,sha256=JXo5QpjoldFTUU0QphmvTV52aJB01cWoak-e17IgKJs,315100160
+nexaai/binds/nexa_llama_cpp/ggml-vulkan.dll,sha256=y3cUfOqckORGsyFTxT6g11RQyuEyYkV5JX_mLgWPyxY,26204160
+nexaai/binds/nexa_llama_cpp/ggml.dll,sha256=MWRWpVOvWV4XL6gU-Dz8v9Hm2RprPsrbMdzIrKnbUTE,66560
+nexaai/binds/nexa_llama_cpp/llama.dll,sha256=KBn-iK1UDBIMC-csWQNNz0wFG-5gevto5u7kMiRHK6M,1587712
+nexaai/binds/nexa_llama_cpp/mtmd.dll,sha256=hc2C9kxlTtp-2bSi82BooYwa7riBo5bo9poIFWrY_tE,560128
+nexaai/binds/nexa_llama_cpp/nexa_plugin.dll,sha256=cUdm1G651PTwriYabad1vDgXZ-vxWDxC6CVTpr5h0CE,1384448
 nexaai/cv_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/cv_impl/mlx_cv_impl.py,sha256=QLd_8w90gtxH8kmssaDYatCTRvQNIJuUGKZNnYrmx6E,3317
 nexaai/cv_impl/pybind_cv_impl.py,sha256=aSOCAxmHrwJbEkSN6VX3Cykqlj_9RIpVrZXILul04GA,1096
 nexaai/embedder_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nexaai/embedder_impl/mlx_embedder_impl.py,sha256=Kzd-veLNl95FbI2oEJMtr6qKbjtPDDajzsGUVjJfTRA,4598
+nexaai/embedder_impl/mlx_embedder_impl.py,sha256=MN5vAGohgyEreLn3H7dg2JeWp2v8emLhrfIDGndk-us,4498
 nexaai/embedder_impl/pybind_embedder_impl.py,sha256=FoLsUrzF5cNtEsSFchPlapkdqLGFOUGNPx0Kc8hdCvA,3589
 nexaai/image_gen_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/image_gen_impl/mlx_image_gen_impl.py,sha256=peUE9ue9ApaPlZVOICBWiHtd13sY40OWQbE8EjfIUMU,11511
@@ -50,15 +50,12 @@ nexaai/tts_impl/mlx_tts_impl.py,sha256=LcH9bVdIl3Q6lOzSUB_X2s-_nWFmlCl1yL7XSUK0f
 nexaai/tts_impl/pybind_tts_impl.py,sha256=n3z4zmPQayQJgAwcvETw0IBUCp8IYROuYFSg0tAy_8Y,1487
 nexaai/utils/avatar_fetcher.py,sha256=D01f8je-37Nd68zGw8MYK2m7y3fvGlC6h0KR-aN9kdU,3925
 nexaai/utils/decode.py,sha256=0Z9jDH4ICzw4YXj8nD4L-sMouDaev-TISGRQ4KzidWE,421
-nexaai/utils/manifest_utils.py,sha256=zMgQpf5dAgF2RjGhk73zBggxRDGMRKDGxh2a8m8kmYg,10045
-nexaai/utils/model_manager.py,sha256=EZ_wMTVIcLkuQTgtkHztKn2gc75S2oeaoKDdozswuC0,51458
-nexaai/utils/model_types.py,sha256=arIyb9q-1uG0nyUGdWZaxxDJAxv0cfnJEpjCzyELL5Q,1416
-nexaai/utils/progress_tracker.py,sha256=BztrFqtjwNUmeREwZ5m7H6ZcrVzQEbpZfsxndWh4z0A,15778
-nexaai/utils/quantization_utils.py,sha256=jjQaz7K4qH6TdP8Tnv5Ktb2viz8BaVBSOrb_jm3ns28,7889
+nexaai/utils/model_manager.py,sha256=Ksl-tKq-a3miTUxEn6-SSOC_KVdn6RPjcUdkWmDDwCk,49767
+nexaai/utils/progress_tracker.py,sha256=FmJBoOlzfQdc-TmccEav0cBR_iSNrrcskG3Fm1OrEJA,15482
 nexaai/vlm_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/vlm_impl/mlx_vlm_impl.py,sha256=oY_qb9z_iF0zArBuY5CCYIvZcA3R0i_NKXrr_r-QSgg,10989
 nexaai/vlm_impl/pybind_vlm_impl.py,sha256=Hu8g8OXyPn8OzLQOpRSE5lfGmhjChiKj7fMRB8mC_cI,9147
-nexaai-1.0.9.dist-info/METADATA,sha256=nO4vHcnhCNKVyTCjQs6trVAXuygpCbqzvEBYdNadBIM,1229
-nexaai-1.0.9.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
-nexaai-1.0.9.dist-info/top_level.txt,sha256=LRE2YERlrZk2vfuygnSzsEeqSknnZbz3Z1MHyNmBU4w,7
-nexaai-1.0.9.dist-info/RECORD,,
+nexaai-1.0.11rc1.dist-info/METADATA,sha256=dpKfhFQkkUYBQnAsSGEuLLHEfe__vDuJ3R-WOHHCrmY,1186
+nexaai-1.0.11rc1.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
+nexaai-1.0.11rc1.dist-info/top_level.txt,sha256=LRE2YERlrZk2vfuygnSzsEeqSknnZbz3Z1MHyNmBU4w,7
+nexaai-1.0.11rc1.dist-info/RECORD,,

nexaai/utils/manifest_utils.py

@@ -1,280 +0,0 @@
-"""
-Manifest and metadata utilities for handling nexa.manifest files and model metadata.
-
-This module provides utilities to:
-- Load and save nexa.manifest files
-- Create GGUF and MLX manifests
-- Process manifest metadata (handle null fields, fetch avatars, etc.)
-- Manage backward compatibility with old download_metadata.json files
-"""
-
-import os
-import json
-from datetime import datetime
-from typing import Dict, Any, List, Optional
-
-from .quantization_utils import (
-    extract_quantization_from_filename, 
-    detect_quantization_for_mlx
-)
-from .model_types import (
-    PIPELINE_TO_MODEL_TYPE,
-    MODEL_TYPE_TO_PIPELINE
-)
-
-
-def process_manifest_metadata(manifest: Dict[str, Any], repo_id: str) -> Dict[str, Any]:
-    """Process manifest metadata to handle null/missing fields."""
-    # Handle pipeline_tag
-    pipeline_tag = manifest.get('pipeline_tag')
-    if not pipeline_tag:
-        # Reverse map from ModelType if available
-        model_type = manifest.get('ModelType')
-        pipeline_tag = MODEL_TYPE_TO_PIPELINE.get(model_type) if model_type else None
-    
-    # Handle download_time - keep as null if missing
-    download_time = manifest.get('download_time')
-    
-    # Handle avatar_url - fetch on-the-fly if missing/null
-    avatar_url = manifest.get('avatar_url')
-    if not avatar_url:
-        try:
-            from .avatar_fetcher import get_avatar_url_for_repo
-            avatar_url = get_avatar_url_for_repo(repo_id)
-        except Exception:
-            # If fetching fails, leave as None
-            avatar_url = None
-    
-    # Return processed metadata
-    processed_manifest = manifest.copy()
-    processed_manifest.update({
-        'pipeline_tag': pipeline_tag,
-        'download_time': download_time,
-        'avatar_url': avatar_url
-    })
-    
-    return processed_manifest
-
-
-def load_nexa_manifest(directory_path: str) -> Dict[str, Any]:
-    """Load manifest from nexa.manifest if it exists."""
-    manifest_path = os.path.join(directory_path, '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 load_download_metadata(directory_path: str, repo_id: Optional[str] = None) -> Dict[str, Any]:
-    """Load download metadata from nexa.manifest if it exists, fallback to old format."""
-    # First try to load from new manifest format
-    manifest = load_nexa_manifest(directory_path)
-    if manifest and repo_id:
-        # Process the manifest to handle null/missing fields
-        return process_manifest_metadata(manifest, repo_id)
-    elif manifest:
-        # Return manifest as-is if no repo_id provided (for backward compatibility)
-        return manifest
-    
-    # Fallback to old format for backward compatibility
-    old_metadata_path = os.path.join(directory_path, 'download_metadata.json')
-    if os.path.exists(old_metadata_path):
-        try:
-            with open(old_metadata_path, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except (json.JSONDecodeError, IOError):
-            pass
-    return {}
-
-
-def save_download_metadata(directory_path: str, metadata: Dict[str, Any]) -> None:
-    """Save download metadata to nexa.manifest in the new format."""
-    manifest_path = os.path.join(directory_path, 'nexa.manifest')
-    try:
-        with open(manifest_path, 'w', encoding='utf-8') as f:
-            json.dump(metadata, f, indent=2)
-    except IOError:
-        # If we can't save metadata, don't fail the download
-        pass
-
-
-def create_gguf_manifest(repo_id: str, files: List[str], directory_path: str, old_metadata: Dict[str, Any]) -> Dict[str, Any]:
-    """Create GGUF format manifest."""
-    
-    # Load existing manifest to merge GGUF files if it exists
-    existing_manifest = load_nexa_manifest(directory_path)
-    
-    model_files = {}
-    if existing_manifest and "ModelFile" in existing_manifest:
-        model_files = existing_manifest["ModelFile"].copy()
-    
-    # Process GGUF files
-    for file_name in files:
-        if file_name.endswith('.gguf'):
-            # Use the new enum-based quantization extraction
-            quantization_type = extract_quantization_from_filename(file_name)
-            quant_level = quantization_type.value if quantization_type else "UNKNOWN"
-            
-            file_path = os.path.join(directory_path, file_name)
-            file_size = 0
-            if os.path.exists(file_path):
-                try:
-                    file_size = os.path.getsize(file_path)
-                except (OSError, IOError):
-                    pass
-            
-            model_files[quant_level] = {
-                "Name": file_name,
-                "Downloaded": True,
-                "Size": file_size
-            }
-    
-    manifest = {
-        "Name": repo_id,
-        "ModelType": PIPELINE_TO_MODEL_TYPE.get(old_metadata.get('pipeline_tag'), "other"),
-        "PluginId": "llama_cpp",
-        "ModelFile": model_files,
-        "MMProjFile": {
-            "Name": "",
-            "Downloaded": False,
-            "Size": 0
-        },
-        "TokenizerFile": {
-            "Name": "",
-            "Downloaded": False,
-            "Size": 0
-        },
-        "ExtraFiles": None,
-        # Preserve old metadata fields
-        "pipeline_tag": old_metadata.get('pipeline_tag'),
-        "download_time": old_metadata.get('download_time'),
-        "avatar_url": old_metadata.get('avatar_url')
-    }
-    
-    return manifest
-
-
-def create_mlx_manifest(repo_id: str, files: List[str], directory_path: str, old_metadata: Dict[str, Any]) -> Dict[str, Any]:
-    """Create MLX format manifest."""
-    
-    model_files = {}
-    extra_files = []
-    
-    # Try different methods to extract quantization for MLX models
-    quantization_type = detect_quantization_for_mlx(repo_id, directory_path)
-    
-    # Use the detected quantization or default to "DEFAULT"
-    quant_level = quantization_type.value if quantization_type else "DEFAULT"
-    
-    for file_name in files:
-        file_path = os.path.join(directory_path, file_name)
-        file_size = 0
-        if os.path.exists(file_path):
-            try:
-                file_size = os.path.getsize(file_path)
-            except (OSError, IOError):
-                pass
-        
-        # Check if this is a main model file (safetensors but not index files)
-        if (file_name.endswith('.safetensors') and not file_name.endswith('.index.json')):
-            model_files[quant_level] = {
-                "Name": file_name,
-                "Downloaded": True,
-                "Size": file_size
-            }
-        else:
-            # Add to extra files
-            extra_files.append({
-                "Name": file_name,
-                "Downloaded": True,
-                "Size": file_size
-            })
-    
-    manifest = {
-        "Name": repo_id,
-        "ModelType": PIPELINE_TO_MODEL_TYPE.get(old_metadata.get('pipeline_tag'), "other"),
-        "PluginId": "mlx",
-        "ModelFile": model_files,
-        "MMProjFile": {
-            "Name": "",
-            "Downloaded": False,
-            "Size": 0
-        },
-        "TokenizerFile": {
-            "Name": "",
-            "Downloaded": False,
-            "Size": 0
-        },
-        "ExtraFiles": extra_files if extra_files else None,
-        # Preserve old metadata fields
-        "pipeline_tag": old_metadata.get('pipeline_tag'),
-        "download_time": old_metadata.get('download_time'),
-        "avatar_url": old_metadata.get('avatar_url')
-    }
-    
-    return manifest
-
-
-def detect_model_type(files: List[str]) -> str:
-    """Detect if this is a GGUF or MLX model based on file extensions."""
-    has_gguf = any(f.endswith('.gguf') for f in files)
-    has_safetensors = any(f.endswith('.safetensors') or 'safetensors' in f for f in files)
-    
-    if has_gguf:
-        return "gguf"
-    elif has_safetensors:
-        return "mlx"
-    else:
-        # Default to mlx for other types
-        return "mlx"
-
-
-def create_manifest_from_files(repo_id: str, files: List[str], directory_path: str, old_metadata: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Create appropriate manifest format based on detected model type.
-    
-    Args:
-        repo_id: Repository ID
-        files: List of files in the model directory
-        directory_path: Path to the model directory
-        old_metadata: Existing metadata (pipeline_tag, download_time, avatar_url)
-        
-    Returns:
-        Dict containing the appropriate manifest format
-    """
-    model_type = detect_model_type(files)
-    
-    if model_type == "gguf":
-        return create_gguf_manifest(repo_id, files, directory_path, old_metadata)
-    else:  # mlx or other
-        return create_mlx_manifest(repo_id, files, directory_path, old_metadata)
-
-
-def save_manifest_with_files_metadata(repo_id: str, local_dir: str, old_metadata: Dict[str, Any]) -> None:
-    """
-    Create and save manifest based on files found in the directory.
-    
-    Args:
-        repo_id: Repository ID
-        local_dir: Local directory containing the model files
-        old_metadata: Existing metadata to preserve
-    """
-    # Get list of files in the directory
-    files = []
-    try:
-        for root, dirs, filenames in os.walk(local_dir):
-            for filename in filenames:
-                # Store relative path from the directory
-                rel_path = os.path.relpath(os.path.join(root, filename), local_dir)
-                files.append(rel_path)
-    except (OSError, IOError):
-        pass
-    
-    # Create appropriate manifest
-    manifest = create_manifest_from_files(repo_id, files, local_dir, old_metadata)
-    
-    # Save manifest
-    save_download_metadata(local_dir, manifest)

nexaai/utils/model_types.py

@@ -1,47 +0,0 @@
-"""
-Model type mappings for HuggingFace pipeline tags to our internal model types.
-
-This module provides centralized model type mapping functionality to avoid
-circular imports between other utility modules.
-"""
-
-from enum import Enum
-from typing import Dict
-
-
-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")
-    
-    def __init__(self, pipeline_tag: str, model_type: str):
-        self.pipeline_tag = pipeline_tag
-        self.model_type = model_type
-
-
-# Create mapping dictionaries from the enum
-PIPELINE_TO_MODEL_TYPE: Dict[str, str] = {
-    mapping.pipeline_tag: mapping.model_type 
-    for mapping in ModelTypeMapping
-}
-
-MODEL_TYPE_TO_PIPELINE: Dict[str, str] = {
-    mapping.model_type: mapping.pipeline_tag 
-    for mapping in ModelTypeMapping
-}
-
-
-def map_pipeline_tag_to_model_type(pipeline_tag: str) -> str:
-    """Map HuggingFace pipeline_tag to our ModelType."""
-    if not pipeline_tag:
-        return "other"
-    
-    return PIPELINE_TO_MODEL_TYPE.get(pipeline_tag, "other")
-
-
-def map_model_type_to_pipeline_tag(model_type: str) -> str:
-    """Reverse map ModelType back to HuggingFace pipeline_tag."""
-    if not model_type:
-        return None
-    
-    return MODEL_TYPE_TO_PIPELINE.get(model_type)

nexaai/utils/quantization_utils.py

@@ -1,239 +0,0 @@
-"""
-Quantization utilities for extracting quantization types from model files and configurations.
-
-This module provides utilities to extract quantization information from:
-- GGUF model filenames
-- MLX model repository IDs  
-- MLX model config.json files
-"""
-
-import os
-import json
-import re
-import logging
-from enum import Enum
-from typing import Optional
-
-# Set up logger
-logger = logging.getLogger(__name__)
-
-
-class QuantizationType(str, Enum):
-    """Enum for GGUF and MLX model quantization types."""
-    # GGUF quantization types
-    BF16 = "BF16"
-    F16 = "F16"
-    Q2_K = "Q2_K"
-    Q2_K_L = "Q2_K_L"
-    Q3_K_M = "Q3_K_M"
-    Q3_K_S = "Q3_K_S"
-    Q4_0 = "Q4_0"
-    Q4_1 = "Q4_1"
-    Q4_K_M = "Q4_K_M"
-    Q4_K_S = "Q4_K_S"
-    Q5_K_M = "Q5_K_M"
-    Q5_K_S = "Q5_K_S"
-    Q6_K = "Q6_K"
-    Q8_0 = "Q8_0"
-    MXFP4 = "MXFP4"
-    MXFP8 = "MXFP8"
-    
-    # MLX bit-based quantization types
-    BIT_1 = "1BIT"
-    BIT_2 = "2BIT"
-    BIT_3 = "3BIT"
-    BIT_4 = "4BIT"
-    BIT_5 = "5BIT"
-    BIT_6 = "6BIT"
-    BIT_7 = "7BIT"
-    BIT_8 = "8BIT"
-    BIT_16 = "16BIT"
-
-
-def extract_quantization_from_filename(filename: str) -> Optional[QuantizationType]:
-    """
-    Extract quantization type from filename.
-    
-    Args:
-        filename: The filename to extract quantization from
-        
-    Returns:
-        QuantizationType enum value or None if not found
-    """
-    # Define mapping from lowercase patterns to enum values
-    # Include "." to ensure precise matching (e.g., "q4_0." not "q4_0_xl")
-    pattern_to_enum = {
-        'bf16.': QuantizationType.BF16,
-        'f16.': QuantizationType.F16,  # Add F16 support
-        'q2_k_l.': QuantizationType.Q2_K_L,  # Check Q2_K_L before Q2_K to avoid partial match
-        'q2_k.': QuantizationType.Q2_K,
-        'q3_k_m.': QuantizationType.Q3_K_M,
-        'q3_ks.': QuantizationType.Q3_K_S,
-        'q4_k_m.': QuantizationType.Q4_K_M,
-        'q4_k_s.': QuantizationType.Q4_K_S,
-        'q4_0.': QuantizationType.Q4_0,
-        'q4_1.': QuantizationType.Q4_1,
-        'q5_k_m.': QuantizationType.Q5_K_M,
-        'q5_k_s.': QuantizationType.Q5_K_S,
-        'q6_k.': QuantizationType.Q6_K,
-        'q8_0.': QuantizationType.Q8_0,
-        'mxfp4.': QuantizationType.MXFP4,
-        'mxfp8.': QuantizationType.MXFP8,
-    }
-    
-    filename_lower = filename.lower()
-    
-    # Check longer patterns first to avoid partial matches
-    # Sort by length descending to check q2_k_l before q2_k, q4_k_m before q4_0, etc.
-    for pattern in sorted(pattern_to_enum.keys(), key=len, reverse=True):
-        if pattern in filename_lower:
-            return pattern_to_enum[pattern]
-    
-    return None
-
-
-def extract_quantization_from_repo_id(repo_id: str) -> Optional[QuantizationType]:
-    """
-    Extract quantization type from repo_id for MLX models by looking for bit patterns.
-    
-    Args:
-        repo_id: The repository ID to extract quantization from
-        
-    Returns:
-        QuantizationType enum value or None if not found
-    """
-    # Define mapping from bit numbers to enum values
-    bit_to_enum = {
-        1: QuantizationType.BIT_1,
-        2: QuantizationType.BIT_2,
-        3: QuantizationType.BIT_3,
-        4: QuantizationType.BIT_4,
-        5: QuantizationType.BIT_5,
-        6: QuantizationType.BIT_6,
-        7: QuantizationType.BIT_7,
-        8: QuantizationType.BIT_8,
-        16: QuantizationType.BIT_16,
-    }
-    
-    # First check for patterns like "4bit", "8bit" etc. (case insensitive)
-    pattern = r'(\d+)bit'
-    matches = re.findall(pattern, repo_id.lower())
-    
-    for match in matches:
-        try:
-            bit_number = int(match)
-            if bit_number in bit_to_enum:
-                logger.debug(f"Found {bit_number}bit quantization in repo_id: {repo_id}")
-                return bit_to_enum[bit_number]
-        except ValueError:
-            continue
-    
-    # Also check for patterns like "-q8", "_Q4" etc.
-    q_pattern = r'[-_]q(\d+)'
-    q_matches = re.findall(q_pattern, repo_id.lower())
-    
-    for match in q_matches:
-        try:
-            bit_number = int(match)
-            if bit_number in bit_to_enum:
-                logger.debug(f"Found Q{bit_number} quantization in repo_id: {repo_id}")
-                return bit_to_enum[bit_number]
-        except ValueError:
-            continue
-    
-    return None
-
-
-def extract_quantization_from_mlx_config(mlx_folder_path: str) -> Optional[QuantizationType]:
-    """
-    Extract quantization type from MLX model's config.json file.
-    
-    Args:
-        mlx_folder_path: Path to the MLX model folder
-        
-    Returns:
-        QuantizationType enum value or None if not found
-    """
-    config_path = os.path.join(mlx_folder_path, "config.json")
-    
-    if not os.path.exists(config_path):
-        logger.debug(f"Config file not found: {config_path}")
-        return None
-    
-    try:
-        with open(config_path, 'r', encoding='utf-8') as f:
-            config = json.load(f)
-        
-        # Look for quantization.bits field
-        quantization_config = config.get("quantization", {})
-        if isinstance(quantization_config, dict):
-            bits = quantization_config.get("bits")
-            if isinstance(bits, int):
-                # Define mapping from bit numbers to enum values
-                bit_to_enum = {
-                    1: QuantizationType.BIT_1,
-                    2: QuantizationType.BIT_2,
-                    3: QuantizationType.BIT_3,
-                    4: QuantizationType.BIT_4,
-                    5: QuantizationType.BIT_5,
-                    6: QuantizationType.BIT_6,
-                    7: QuantizationType.BIT_7,
-                    8: QuantizationType.BIT_8,
-                    16: QuantizationType.BIT_16,
-                }
-                
-                if bits in bit_to_enum:
-                    logger.debug(f"Found {bits}bit quantization in config.json: {config_path}")
-                    return bit_to_enum[bits]
-                else:
-                    logger.debug(f"Unsupported quantization bits value: {bits}")
-        
-    except (json.JSONDecodeError, IOError) as e:
-        logger.warning(f"Error reading config.json from {config_path}: {e}")
-    except Exception as e:
-        logger.warning(f"Unexpected error reading config.json from {config_path}: {e}")
-    
-    return None
-
-
-def extract_gguf_quantization(filename: str) -> str:
-    """
-    Extract quantization level from GGUF filename using the enum-based approach.
-    
-    This function provides backward compatibility by returning a string representation
-    of the quantization type.
-    
-    Args:
-        filename: The GGUF filename
-        
-    Returns:
-        String representation of the quantization type or "UNKNOWN" if not found
-    """
-    quantization_type = extract_quantization_from_filename(filename)
-    if quantization_type:
-        return quantization_type.value
-    return "UNKNOWN"
-
-
-def detect_quantization_for_mlx(repo_id: str, directory_path: str) -> Optional[QuantizationType]:
-    """
-    Detect quantization for MLX models using multiple methods in priority order.
-    
-    Args:
-        repo_id: The repository ID
-        directory_path: Path to the model directory
-        
-    Returns:
-        QuantizationType enum value or None if not found
-    """
-    # Method 1: Extract from repo_id
-    quantization_type = extract_quantization_from_repo_id(repo_id)
-    if quantization_type:
-        return quantization_type
-    
-    # Method 2: Extract from config.json if available
-    quantization_type = extract_quantization_from_mlx_config(directory_path)
-    if quantization_type:
-        return quantization_type
-    
-    return None