nexaai 1.0.11rc2__cp310-cp310-win_amd64.whl → 1.0.11rc3__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.11-rc2" 
+__version__ = "1.0.11-rc3" 

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 Embedder as MLXEmbedderInterface
+from nexaai.mlx_backend.embedding.interface import create_embedder
 from nexaai.mlx_backend.ml import ModelConfig as MLXModelConfig, SamplerConfig as MLXSamplerConfig, GenerationConfig as MLXGenerationConfig, EmbeddingConfig
 
 
@@ -27,11 +27,12 @@ class MLXEmbedderImpl(Embedder):
             MLXEmbedderImpl instance
         """
         try:
-            # MLX interface is already imported
-            
-            # Create instance and load MLX embedder
+            # Create instance
             instance = cls()
-            instance._mlx_embedder = MLXEmbedderInterface(
+            
+            # 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(
                 model_path=model_path,
                 tokenizer_path=tokenizer_file
             )

nexaai/utils/manifest_utils.py

@@ -0,0 +1,280 @@
+"""
+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_manager.py

@@ -5,17 +5,22 @@ 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."""
@@ -88,30 +93,6 @@ 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
@@ -137,6 +118,13 @@ 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 = []
@@ -162,24 +150,27 @@ 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
-                        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')
-                            ))
+                        # 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')
+                                ))
                     else:
                         direct_files.append(subitem)
             except (OSError, IOError):
@@ -188,24 +179,27 @@ def _scan_for_repo_folders(base_path: str) -> List[DownloadedModel]:
             
             # Direct repo folder (no owner structure)
             if not has_subdirs and direct_files:
-                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')
-                    ))
+                # 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')
+                        ))
     
     except (OSError, IOError):
         # Skip if base path can't be accessed
@@ -735,27 +729,57 @@ 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)
-            pipeline_tag = info.pipeline_tag if hasattr(info, 'pipeline_tag') else None
-            
+            if hasattr(info, 'pipeline_tag') and 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:
             # Get avatar URL
             avatar_url = get_avatar_url_for_repo(repo_id, custom_endpoint=self.endpoint)
-            
-            # 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
+            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}")
     
     def _download_single_file(
         self,
@@ -772,7 +796,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"✓ File already exists, skipping: {file_name}")
+            print(f"[SKIP] File already exists: {file_name}")
             # Stop progress tracking
             if progress_tracker:
                 progress_tracker.stop_tracking()
@@ -820,14 +844,6 @@ 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,
@@ -887,7 +903,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"✓ File already exists, skipping: {file_name}")
+                    print(f"[SKIP] File already exists: {file_name}")
                     overall_progress.update(1)
                     continue
                 

nexaai/utils/model_types.py

@@ -0,0 +1,47 @@
+"""
+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/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.5:  # At least 500ms between measurements
+            if time_diff > 0.1:  # At least 100ms between measurements
                 bytes_diff = current_downloaded - self.last_downloaded
                 
                 # Only calculate speed if bytes actually changed
@@ -118,6 +118,14 @@ 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
@@ -157,13 +165,9 @@ class DownloadProgressTracker:
                 total_file_sizes += data['total']
                 active_file_count += 1
         
-        # Calculate speed
+        # Calculate speed (tracking variables are updated internally)
         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
@@ -245,11 +249,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/utils/quantization_utils.py

@@ -0,0 +1,239 @@
+"""
+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

{nexaai-1.0.11rc2.dist-info → nexaai-1.0.11rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexaai
-Version: 1.0.11rc2
+Version: 1.0.11rc3
 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,6 +21,7 @@ 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.11rc2.dist-info → nexaai-1.0.11rc3.dist-info}/RECORD

@@ -1,6 +1,6 @@
 nexaai/__init__.py,sha256=Lt8NU57eTMtWrDYzpFeYR9XtGAPXqizynP83TPU0UW0,2105
-nexaai/_stub.cp310-win_amd64.pyd,sha256=FqMCKrC7l_vwKGs-klebDg3vARpmx_IazBGgluIOEIA,10752
-nexaai/_version.py,sha256=4cVrGwuwpvVG8jdKkixeJgbvLT1LCTGdQ7iDCXnieVM,147
+nexaai/_stub.cp310-win_amd64.pyd,sha256=8U1mDahk9v-NHZESrelFBA1lDLkxwNadcu3f2pJokUo,10752
+nexaai/_version.py,sha256=hKqV3hg0JHr9xpCxcO2OfmBulQjXNCTnMfanY0L2JLI,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=DRvM4paABLIncnm20K7sgk0JFlyN1UXyMwlIs47kMxA,201216
-nexaai/binds/embedder_bind.cp310-win_amd64.pyd,sha256=DB5h3spbmxixrrVbYNnpfIZP7bRIJeNCZG8T0uSTMCc,182784
+nexaai/binds/common_bind.cp310-win_amd64.pyd,sha256=o9pL1RANEmxgU4yXAd7nzJQE903B-9mWgc1oSTj88-U,201216
+nexaai/binds/embedder_bind.cp310-win_amd64.pyd,sha256=BSsSrHpWNNOsCy2d4BPWxnPaKMYysxxCNx22En9DaEY,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=4FW1bsKy5NPvaIXcJ8xyhrqjxhRicLFKLJ1mGS_5x0w,162816
-nexaai/binds/nexa_bridge.dll,sha256=KH_O7_tYHRKzCKi_tFYLffk9_AAiGwGyBbpXiam8Zx0,166912
-nexaai/binds/nexa_llama_cpp/ggml-base.dll,sha256=I3RE_twv8ES-Hhm6DtHkG65gmux9dXo5oI7RCr8ZlV0,514560
-nexaai/binds/nexa_llama_cpp/ggml-cpu.dll,sha256=Lpk_HAaWfz5g8TtAQvCeRJOuuzwuRr6ujUyfS2_9B0Y,663552
-nexaai/binds/nexa_llama_cpp/ggml-cuda.dll,sha256=vwbuDBqadLJxy0JEitUJEowYdaiMZhH6A0Z6q2xTVt4,315100160
-nexaai/binds/nexa_llama_cpp/ggml-vulkan.dll,sha256=K4x5qAOWkfNRatg4aOEptSFuXf36L5CCNEaJ0CSz0Jk,26204160
-nexaai/binds/nexa_llama_cpp/ggml.dll,sha256=PaTUZfzao-Odcruowp5Fgaxvmca96JR2CjPjPSV3p5Y,66560
-nexaai/binds/nexa_llama_cpp/llama.dll,sha256=C9f9VPFjijh55eG8rW3tUhbY3kZUuLE22zsvRK9osaI,1587712
-nexaai/binds/nexa_llama_cpp/mtmd.dll,sha256=fqQIptyxjH3-oRQBv3QZ9F087nCpb2YcpCJNkciVB_U,560128
-nexaai/binds/nexa_llama_cpp/nexa_plugin.dll,sha256=MloGzhkP5x1KyBLJVT56wIMcnQmd0EDh4lHa5MyPdWY,1384448
+nexaai/binds/llm_bind.cp310-win_amd64.pyd,sha256=BnnQIQIHmnOYw92u9UIFkTsLZsyGD8d2VJdEHmzLJrw,162816
+nexaai/binds/nexa_bridge.dll,sha256=5_uc337Pr2ehh15Gd7Wb64JtzSSlHWtpm8vvZwveqko,166912
+nexaai/binds/nexa_llama_cpp/ggml-base.dll,sha256=htrK0lg-D16900VTUjt1b-aJmzVxDeG67dKR3Xp-wkA,532480
+nexaai/binds/nexa_llama_cpp/ggml-cpu.dll,sha256=kU5PQd_XgBvnQsYAsMb_vsDLOaOPcfkn_1uYBKfW6dk,672768
+nexaai/binds/nexa_llama_cpp/ggml-cuda.dll,sha256=r6yRWG_L4XphB8IeNCXYgAthr8AjyoWV6MLm3Dwr_94,313528832
+nexaai/binds/nexa_llama_cpp/ggml-vulkan.dll,sha256=ElXCkQysoGtFxWQCAmHw-jRV7g_wNuUceM5iB4suUL4,36627456
+nexaai/binds/nexa_llama_cpp/ggml.dll,sha256=ylVOqiG4WlaeUTDGwbaM5LSI-TOS7bOF8h-ixfpZLas,66560
+nexaai/binds/nexa_llama_cpp/llama.dll,sha256=-He-aE6e70FC6e4fg5tdp8WNt7Dha_Oz8avDGHVpuw4,1611776
+nexaai/binds/nexa_llama_cpp/mtmd.dll,sha256=T2thFe6POAuTFGhnH58LWiGhTZwAmbmMOYQANPbwaK0,561152
+nexaai/binds/nexa_llama_cpp/nexa_plugin.dll,sha256=jzJQuM7LKdZSPy-Ktya-D76waYVg3yErp3I08btMRrc,1405440
 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=MN5vAGohgyEreLn3H7dg2JeWp2v8emLhrfIDGndk-us,4498
+nexaai/embedder_impl/mlx_embedder_impl.py,sha256=Kzd-veLNl95FbI2oEJMtr6qKbjtPDDajzsGUVjJfTRA,4598
 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,12 +50,15 @@ 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/model_manager.py,sha256=Ksl-tKq-a3miTUxEn6-SSOC_KVdn6RPjcUdkWmDDwCk,49767
-nexaai/utils/progress_tracker.py,sha256=FmJBoOlzfQdc-TmccEav0cBR_iSNrrcskG3Fm1OrEJA,15482
+nexaai/utils/manifest_utils.py,sha256=zMgQpf5dAgF2RjGhk73zBggxRDGMRKDGxh2a8m8kmYg,10045
+nexaai/utils/model_manager.py,sha256=TmaT1fFculHgfAdutpNXP4d07HIhEMPVTfPvFKE-zR0,51480
+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/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.11rc2.dist-info/METADATA,sha256=mDcTUe8Csg5kjcoiakYMSMWZ2LzZi4RjtN0ZmiT_U5g,1186
-nexaai-1.0.11rc2.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
-nexaai-1.0.11rc2.dist-info/top_level.txt,sha256=LRE2YERlrZk2vfuygnSzsEeqSknnZbz3Z1MHyNmBU4w,7
-nexaai-1.0.11rc2.dist-info/RECORD,,
+nexaai-1.0.11rc3.dist-info/METADATA,sha256=gKzlZBx0TKjkNlDRT7Hw6nlOH6Ou0sOWxCEY-aO5JwY,1233
+nexaai-1.0.11rc3.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
+nexaai-1.0.11rc3.dist-info/top_level.txt,sha256=LRE2YERlrZk2vfuygnSzsEeqSknnZbz3Z1MHyNmBU4w,7
+nexaai-1.0.11rc3.dist-info/RECORD,,