nexaai 1.0.5__cp310-cp310-macosx_13_0_x86_64.whl → 1.0.6__cp310-cp310-macosx_13_0_x86_64.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.5" 
+__version__ = "1.0.6" 

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/mlx_backend/embedding/generate.py

@@ -23,11 +23,46 @@ from .modeling.nexa_jina_v2 import Model, ModelArgs
 from tokenizers import Tokenizer
 from huggingface_hub import snapshot_download
 
-def load_model(model_id):
+# Try to import mlx_embeddings for general embedding support
+try:
+    import mlx_embeddings
+    MLX_EMBEDDINGS_AVAILABLE = True
+except ImportError:
+    MLX_EMBEDDINGS_AVAILABLE = False
+    # Suppress warning during import to avoid interfering with C++ tests
+    # The warning will be shown when actually trying to use mlx_embeddings functionality
+    pass
+
+def detect_model_type(model_path):
+    """Detect if the model is Jina V2 or generic mlx_embeddings model."""
+    config_path = os.path.join(model_path, "config.json") if os.path.isdir(model_path) else f"{model_path}/config.json"
+    
+    if not os.path.exists(config_path):
+        # Try default modelfiles directory
+        config_path = f"{curr_dir}/modelfiles/config.json"
+        if not os.path.exists(config_path):
+            return "generic"
+    
+    try:
+        with open(config_path, "r") as f:
+            config = json.load(f)
+        
+        # Check if it's a Jina V2 model
+        architectures = config.get("architectures", [])
+        if "JinaBertModel" in architectures:
+            return "jina_v2"
+        
+        return "generic"
+    except Exception:
+        return "generic"
+
+# ========== Jina V2 Direct Implementation ==========
+
+def load_jina_model(model_id):
     """Initialize and load the Jina V2 model with FP16 weights."""
     # Load configuration from config.json
     if not os.path.exists(f"{curr_dir}/modelfiles/config.json"):
-        print(f"📥 Downloading model {model_id}...")
+        print(f"📥 Downloading Jina V2 model {model_id}...")
         
         # Ensure modelfiles directory exists
         os.makedirs(f"{curr_dir}/modelfiles", exist_ok=True)
@@ -82,15 +117,15 @@ def load_model(model_id):
     
     return model
 
-def load_tokenizer():
-    """Load and configure the tokenizer."""
+def load_jina_tokenizer():
+    """Load and configure the tokenizer for Jina V2."""
     tokenizer = Tokenizer.from_file(f"{curr_dir}/modelfiles/tokenizer.json")
     tokenizer.enable_padding(pad_id=0, pad_token="[PAD]")
     tokenizer.enable_truncation(max_length=512)
     return tokenizer
 
-def encode_text(model, tokenizer, text):
-    """Encode a single text and return its embedding."""
+def encode_jina_text(model, tokenizer, text):
+    """Encode a single text using Jina V2 and return its embedding."""
     # Tokenize the text
     encoding = tokenizer.encode(text)
     
@@ -113,18 +148,186 @@ def encode_text(model, tokenizer, text):
     
     return embeddings
 
+# ========== MLX Embeddings Direct Implementation ==========
+
+def load_mlx_embeddings_model(model_id):
+    """Load model using mlx_embeddings package."""
+    if not MLX_EMBEDDINGS_AVAILABLE:
+        print("Warning: mlx_embeddings not available. Please install it to use general embedding models.")
+        raise ImportError("mlx_embeddings package is not available. Please install it first.")
+    
+    # Download model if needed
+    model_path = f"{curr_dir}/modelfiles"
+    
+    if not os.path.exists(f"{model_path}/config.json"):
+        print(f"📥 Downloading model {model_id}...")
+        os.makedirs(model_path, exist_ok=True)
+        
+        try:
+            snapshot_download(
+                repo_id=model_id,
+                local_dir=model_path,
+                resume_download=True,
+                local_dir_use_symlinks=False
+            )
+            print("✅ Model download completed!")
+        except Exception as e:
+            print(f"❌ Failed to download model: {e}")
+            raise
+    
+    # Load model and tokenizer using mlx_embeddings
+    model, tokenizer = mlx_embeddings.load(model_path)
+    return model, tokenizer
+
+def encode_mlx_embeddings_text(model, tokenizer, texts, model_path=None):
+    """Generate embeddings using mlx_embeddings."""
+    if isinstance(texts, str):
+        texts = [texts]
+    
+    # Check if this is a Gemma3TextModel by checking config
+    # WORKAROUND: Gemma3TextModel has a bug where it expects 'inputs' as positional arg
+    # but mlx_embeddings.generate passes 'input_ids' as keyword arg
+    # See: https://github.com/ml-explore/mlx-examples/issues/... (bug report pending)
+    is_gemma = False
+    if model_path:
+        config_path = os.path.join(model_path, "config.json") if os.path.isdir(model_path) else f"{model_path}/config.json"
+    else:
+        config_path = f"{curr_dir}/modelfiles/config.json"
+    
+    if os.path.exists(config_path):
+        try:
+            with open(config_path, "r") as f:
+                config = json.load(f)
+                architectures = config.get("architectures", [])
+                is_gemma = "Gemma3TextModel" in architectures
+        except Exception:
+            pass
+    
+    if is_gemma:
+        # HARDCODED WORKAROUND for Gemma3TextModel bug
+        # Use direct tokenization and model call instead of mlx_embeddings.generate
+        # This avoids the bug where generate passes 'input_ids' as keyword arg
+        # but Gemma3TextModel.__call__ expects 'inputs' as positional arg
+        
+        # Tokenize using batch_encode_plus for Gemma models
+        encoded_input = tokenizer.batch_encode_plus(
+            texts,
+            padding=True,
+            truncation=True,
+            return_tensors='mlx',
+            max_length=512
+        )
+        
+        # Get input tensors
+        input_ids = encoded_input['input_ids']
+        attention_mask = encoded_input.get('attention_mask', None)
+        
+        # Call model with positional input_ids and keyword attention_mask
+        # This matches Gemma3TextModel's expected signature:
+        # def __call__(self, inputs: mx.array, attention_mask: Optional[mx.array] = None)
+        output = model(input_ids, attention_mask=attention_mask)
+        
+        # Get the normalized embeddings
+        return output.text_embeds
+    else:
+        # Normal path for non-Gemma models
+        # Use standard mlx_embeddings.generate approach
+        output = mlx_embeddings.generate(
+            model,
+            tokenizer,
+            texts=texts,
+            max_length=512,
+            padding=True,
+            truncation=True
+        )
+        
+        return output.text_embeds
+
 def main(model_id):
     """Main function to handle user input and generate embeddings."""
     
-    # Load model and tokenizer
-    model = load_model(model_id)
-    tokenizer = load_tokenizer()
-    user_input = "Hello, how are you?"
-    embedding = encode_text(model, tokenizer, user_input)
-    print(f"Embedding shape: {embedding.shape}")
-    print(f"Embedding sample values: {embedding.flatten()[:5].tolist()}")
-    print(f"Embedding min: {embedding.min()}, Max: {embedding.max()}, Mean: {embedding.mean()}, Std: {embedding.std()}")
+    print(f"🔍 Loading model: {model_id}")
+    
+    # Detect model type
+    model_type = detect_model_type(f"{curr_dir}/modelfiles")
+    
+    # First try to download/check if model exists
+    if not os.path.exists(f"{curr_dir}/modelfiles/config.json"):
+        # Download the model first to detect its type
+        print(f"Model not found locally. Downloading...")
+        os.makedirs(f"{curr_dir}/modelfiles", exist_ok=True)
+        try:
+            snapshot_download(
+                repo_id=model_id, 
+                local_dir=f"{curr_dir}/modelfiles",
+                resume_download=True,
+                local_dir_use_symlinks=False
+            )
+            print("✅ Model download completed!")
+            # Re-detect model type after download
+            model_type = detect_model_type(f"{curr_dir}/modelfiles")
+        except Exception as e:
+            print(f"❌ Failed to download model: {e}")
+            raise
+    
+    print(f"📦 Detected model type: {model_type}")
+    
+    # Test texts
+    test_texts = [
+        "Hello, how are you?",
+        "What is machine learning?",
+        "The weather is nice today."
+    ]
+    
+    if model_type == "jina_v2":
+        print("Using Jina V2 direct implementation")
+        
+        # Load Jina V2 model
+        model = load_jina_model(model_id)
+        tokenizer = load_jina_tokenizer()
+        
+        print("\nGenerating embeddings for test texts:")
+        for text in test_texts:
+            embedding = encode_jina_text(model, tokenizer, text)
+            print(f"\nText: '{text}'")
+            print(f"  Embedding shape: {embedding.shape}")
+            print(f"  Sample values (first 5): {embedding.flatten()[:5].tolist()}")
+            print(f"  Stats - Min: {embedding.min():.4f}, Max: {embedding.max():.4f}, Mean: {embedding.mean():.4f}")
+    
+    else:
+        print("Using mlx_embeddings direct implementation")
+        
+        if not MLX_EMBEDDINGS_AVAILABLE:
+            print("❌ mlx_embeddings is not installed. Please install it to use generic models.")
+            return
+        
+        # Load generic model using mlx_embeddings
+        model, tokenizer = load_mlx_embeddings_model(model_id)
+        
+        print("\nGenerating embeddings for test texts:")
+        # Pass model_path to handle Gemma workaround if needed
+        embeddings = encode_mlx_embeddings_text(model, tokenizer, test_texts, model_path=f"{curr_dir}/modelfiles")
+        
+        for i, text in enumerate(test_texts):
+            embedding = embeddings[i]
+            print(f"\nText: '{text}'")
+            print(f"  Embedding shape: {embedding.shape}")
+            print(f"  Sample values (first 5): {embedding[:5].tolist()}")
+            
+            # Calculate stats
+            emb_array = mx.array(embedding) if not isinstance(embedding, mx.array) else embedding
+            print(f"  Stats - Min: {emb_array.min():.4f}, Max: {emb_array.max():.4f}, Mean: {emb_array.mean():.4f}")
+    
+    print("\n✅ Direct embedding generation completed!")
 
 if __name__ == "__main__":
-    model_id = "nexaml/jina-v2-fp16-mlx"
-    main(model_id)
+    import argparse
+    parser = argparse.ArgumentParser(description="Generate embeddings using direct implementation")
+    parser.add_argument(
+        "--model_id", 
+        type=str, 
+        default="nexaml/jina-v2-fp16-mlx",
+        help="Model ID from Hugging Face Hub (e.g., 'nexaml/jina-v2-fp16-mlx' or 'mlx-community/embeddinggemma-300m-bf16')"
+    )
+    args = parser.parse_args()
+    main(args.model_id)

nexaai/mlx_backend/embedding/interface.py

@@ -20,11 +20,16 @@ import mlx.core as mx
 import numpy as np
 from pathlib import Path
 from typing import Any, List, Optional, Sequence
+from abc import ABC, abstractmethod
 
 # Import necessary modules 
 from tokenizers import Tokenizer
 
 # Import from ml.py for API alignment
+import sys
+from pathlib import Path as PathLib
+sys.path.insert(0, str(PathLib(__file__).parent.parent))
+
 from ml import (
     Embedder as BaseEmbedder,
     EmbeddingConfig,
@@ -34,13 +39,24 @@ from ml import (
 # Import profiling module
 from profiling import ProfilingMixin, StopReason
 
-# Import the model implementation
-from .modeling.nexa_jina_v2 import Model, ModelArgs
+# Import the model implementation for Jina
+try:
+    from .modeling.nexa_jina_v2 import Model, ModelArgs
+except ImportError:
+    # Fallback for when module is run directly
+    from modeling.nexa_jina_v2 import Model, ModelArgs
+
+# Import mlx_embeddings for general embedding support
+try:
+    import mlx_embeddings
+    MLX_EMBEDDINGS_AVAILABLE = True
+except ImportError:
+    MLX_EMBEDDINGS_AVAILABLE = False
 
 
-class Embedder(BaseEmbedder, ProfilingMixin):
+class BaseMLXEmbedder(BaseEmbedder, ProfilingMixin, ABC):
     """
-    Embedder interface for MLX embedding models.
+    Abstract base embedder interface for MLX embedding models.
     API aligned with ml.py Embedder abstract base class.
     """
 
@@ -64,7 +80,7 @@ class Embedder(BaseEmbedder, ProfilingMixin):
         
         self.model_path = model_path
         self.tokenizer_path = tokenizer_path
-        self.device = device if device is not None else "cpu" # TODO: This device field is never used
+        self.device = device if device is not None else "cpu"
         
         # Initialize model and tokenizer as None
         self.model = None
@@ -78,6 +94,69 @@ class Embedder(BaseEmbedder, ProfilingMixin):
         self.config = None
         self.reset_profiling()
 
+    @abstractmethod
+    def load_model(self, model_path: PathType) -> bool:
+        """Load model from path."""
+        pass
+
+    def close(self) -> None:
+        """Close the model."""
+        self.destroy()
+
+    @abstractmethod
+    def embed(
+        self,
+        texts: Sequence[str],
+        config: Optional[EmbeddingConfig] = None,
+        clear_cache: bool = True,
+    ) -> List[List[float]]:
+        """Generate embeddings for texts."""
+        pass
+
+    @abstractmethod
+    def embedding_dim(self) -> int:
+        """Get embedding dimension."""
+        pass
+
+    def set_lora(self, lora_id: int) -> None:
+        """Set active LoRA adapter. (Disabled for embedding models)"""
+        raise NotImplementedError("LoRA is not supported for embedding models")
+
+    def add_lora(self, lora_path: PathType) -> int:
+        """Add LoRA adapter and return its ID. (Disabled for embedding models)"""
+        raise NotImplementedError("LoRA is not supported for embedding models")
+
+    def remove_lora(self, lora_id: int) -> None:
+        """Remove LoRA adapter. (Disabled for embedding models)"""
+        raise NotImplementedError("LoRA is not supported for embedding models")
+
+    def list_loras(self) -> List[int]:
+        """List available LoRA adapters. (Disabled for embedding models)"""
+        raise NotImplementedError("LoRA is not supported for embedding models")
+
+    def _normalize_embedding(self, embedding: List[float], method: str) -> List[float]:
+        """Normalize embedding using specified method."""
+        if method == "none":
+            return embedding
+        
+        embedding_array = np.array(embedding)
+        
+        if method == "l2":
+            norm = np.linalg.norm(embedding_array)
+            if norm > 0:
+                embedding_array = embedding_array / norm
+        elif method == "mean":
+            mean_val = np.mean(embedding_array)
+            embedding_array = embedding_array - mean_val
+        
+        return embedding_array.tolist()
+
+
+class JinaV2Embedder(BaseMLXEmbedder):
+    """
+    Embedder implementation specifically for Jina V2 models.
+    """
+
     def load_model(self, model_path: PathType) -> bool:
         """Load model from path."""
         try:
@@ -97,10 +176,6 @@ class Embedder(BaseEmbedder, ProfilingMixin):
             print(f"Failed to load model: {e}")
             return False
 
-    def close(self) -> None:
-        """Close the model."""
-        self.destroy()
-
     def embed(
         self,
         texts: Sequence[str],
@@ -158,22 +233,6 @@ class Embedder(BaseEmbedder, ProfilingMixin):
             return 768  # Default dimension for Jina v2
         return self.config.hidden_size
 
-    def set_lora(self, lora_id: int) -> None:
-        """Set active LoRA adapter. (Disabled for embedding models)"""
-        raise NotImplementedError("LoRA is not supported for embedding models")
-
-    def add_lora(self, lora_path: PathType) -> int:
-        """Add LoRA adapter and return its ID. (Disabled for embedding models)"""
-        raise NotImplementedError("LoRA is not supported for embedding models")
-
-    def remove_lora(self, lora_id: int) -> None:
-        """Remove LoRA adapter. (Disabled for embedding models)"""
-        raise NotImplementedError("LoRA is not supported for embedding models")
-
-    def list_loras(self) -> List[int]:
-        """List available LoRA adapters. (Disabled for embedding models)"""
-        raise NotImplementedError("LoRA is not supported for embedding models")
-    
     def _load_jina_model(self, model_dir: str) -> Model:
         """Initialize and load the Jina V2 model with FP16 weights."""
         
@@ -281,22 +340,267 @@ class Embedder(BaseEmbedder, ProfilingMixin):
         
         return embedding_list
 
-    def _normalize_embedding(self, embedding: List[float], method: str) -> List[float]:
-        """Normalize embedding using specified method."""
-        if method == "none":
-            return embedding
+
+class MlxEmbeddingEmbedder(BaseMLXEmbedder):
+    """
+    Embedder implementation using mlx_embeddings package for general embedding models.
+    """
+
+    def load_model(self, model_path: PathType) -> bool:
+        """Load model from path using mlx_embeddings."""
+        if not MLX_EMBEDDINGS_AVAILABLE:
+            print("Warning: mlx_embeddings not available. Please install it to use general embedding models.")
+            raise ImportError("mlx_embeddings package is not available. Please install it first.")
         
-        embedding_array = np.array(embedding)
+        try:
+            # Use the provided model_path or fall back to instance path
+            if model_path:
+                if os.path.isfile(model_path):
+                    model_path = os.path.dirname(model_path)
+                self.model_path = model_path
+            
+            # Load model and tokenizer using mlx_embeddings
+            self.model, self.tokenizer = mlx_embeddings.load(self.model_path)
+            
+            # Load config to get dimensions
+            config_path = os.path.join(self.model_path, "config.json")
+            if os.path.exists(config_path):
+                with open(config_path, "r") as f:
+                    self.config = json.load(f)
+            
+            return True
+        except Exception as e:
+            print(f"Failed to load model: {e}")
+            return False
+
+    def embed(
+        self,
+        texts: Sequence[str],
+        config: Optional[EmbeddingConfig] = None,
+        clear_cache: bool = True,
+    ) -> List[List[float]]:
+        """Generate embeddings for texts using mlx_embeddings."""
+        if self.model is None or self.tokenizer is None:
+            raise RuntimeError("Model not loaded. Call load_model() first.")
         
-        if method == "l2":
-            norm = np.linalg.norm(embedding_array)
-            if norm > 0:
-                embedding_array = embedding_array / norm
-        elif method == "mean":
-            mean_val = np.mean(embedding_array)
-            embedding_array = embedding_array - mean_val
+        if config is None:
+            config = EmbeddingConfig()
         
-        return embedding_array.tolist()
+        # Start profiling
+        self._start_profiling()
+        
+        try:
+            # Calculate total tokens for profiling
+            if hasattr(self.tokenizer, 'encode'):
+                total_tokens = sum(len(self.tokenizer.encode(text)) for text in texts)
+            else:
+                # For tokenizers that don't have simple encode method
+                total_tokens = len(texts) * 50  # Rough estimate
+            
+            self._update_prompt_tokens(total_tokens)
+            
+            # End prompt processing, start decode
+            self._prompt_end()
+            self._decode_start()
+            
+            # Check if this is a Gemma3TextModel
+            # WORKAROUND: Gemma3TextModel has a bug where it expects 'inputs' as positional arg
+            # but mlx_embeddings.generate passes 'input_ids' as keyword arg
+            # See: https://github.com/ml-explore/mlx-examples/issues/... (bug report pending)
+            is_gemma = False
+            if self.config and "architectures" in self.config:
+                architectures = self.config.get("architectures", [])
+                is_gemma = "Gemma3TextModel" in architectures
+            
+            if is_gemma:
+                # HARDCODED WORKAROUND for Gemma3TextModel bug
+                # Use direct tokenization and model call instead of mlx_embeddings.generate
+                max_length = config.max_length if hasattr(config, 'max_length') else 512
+                
+                # Tokenize using batch_encode_plus
+                encoded_input = self.tokenizer.batch_encode_plus(
+                    list(texts),
+                    padding=True,
+                    truncation=True,
+                    return_tensors='mlx',
+                    max_length=max_length
+                )
+                
+                # Get input tensors
+                input_ids = encoded_input['input_ids']
+                attention_mask = encoded_input.get('attention_mask', None)
+                
+                # Call model with positional input_ids and keyword attention_mask
+                # This matches Gemma3TextModel's expected signature
+                output = self.model(input_ids, attention_mask=attention_mask)
+                
+                # Extract embeddings
+                embeddings_tensor = output.text_embeds
+            else:
+                # Normal path for non-Gemma models
+                # Generate embeddings using mlx_embeddings standard approach
+                output = mlx_embeddings.generate(
+                    self.model,
+                    self.tokenizer,
+                    texts=list(texts),
+                    max_length=config.max_length if hasattr(config, 'max_length') else 512,
+                    padding=True,
+                    truncation=True
+                )
+                
+                # Extract embeddings
+                embeddings_tensor = output.text_embeds
+            
+            # Convert to list format
+            embeddings = []
+            for i in range(embeddings_tensor.shape[0]):
+                embedding = embeddings_tensor[i].tolist()
+                
+                # Apply normalization if requested
+                if config.normalize:
+                    embedding = self._normalize_embedding(embedding, config.normalize_method)
+                
+                embeddings.append(embedding)
+            
+            if clear_cache:
+                mx.clear_cache()
+            
+            # End timing and finalize profiling data
+            self._update_generated_tokens(0)  # No generation in embedding
+            self._set_stop_reason(StopReason.ML_STOP_REASON_COMPLETED)
+            self._decode_end()
+            self._end_profiling()
+            
+            return embeddings
+            
+        except Exception as e:
+            self._set_stop_reason(StopReason.ML_STOP_REASON_UNKNOWN)
+            self._decode_end()
+            self._end_profiling()
+            raise RuntimeError(f"Error generating embeddings: {str(e)}")
+
+    def embedding_dim(self) -> int:
+        """Get embedding dimension."""
+        if self.config is None:
+            return 768  # Default dimension
+        
+        # Try different config keys that might contain the dimension
+        if "hidden_size" in self.config:
+            return self.config["hidden_size"]
+        elif "d_model" in self.config:
+            return self.config["d_model"]
+        elif "dim" in self.config:
+            return self.config["dim"]
+        else:
+            return 768  # Fallback default
+
+
+class MLXEmbedder(BaseMLXEmbedder):
+    """
+    Concrete embedder class that routes to the appropriate implementation.
+    This class can be instantiated directly (for C++ compatibility) and will
+    automatically delegate to JinaV2Embedder or MlxEmbeddingEmbedder based on model type.
+    """
+    
+    def __init__(
+        self,
+        model_path: PathType,
+        tokenizer_path: PathType,
+        device: Optional[str] = None,
+    ) -> None:
+        """Initialize the Embedder model."""
+        super().__init__(model_path, tokenizer_path, device)
+        self._impl = None  # Will hold the actual implementation
+    
+    def _get_implementation(self) -> BaseMLXEmbedder:
+        """Get or create the appropriate implementation based on model type."""
+        if self._impl is None:
+            # Detect model type and create appropriate implementation
+            model_type = _detect_model_type(self.model_path)
+            
+            if model_type == "jina_v2":
+                self._impl = JinaV2Embedder(self.model_path, self.tokenizer_path, self.device)
+            else:
+                self._impl = MlxEmbeddingEmbedder(self.model_path, self.tokenizer_path, self.device)
+            
+            # Copy over any existing state
+            if self.model is not None:
+                self._impl.model = self.model
+            if self.tokenizer is not None:
+                self._impl.tokenizer = self.tokenizer
+            if self.config is not None:
+                self._impl.config = self.config
+        
+        return self._impl
+    
+    def load_model(self, model_path: PathType) -> bool:
+        """Load model from path."""
+        # Get the appropriate implementation and delegate
+        impl = self._get_implementation()
+        result = impl.load_model(model_path)
+        
+        # Sync state back
+        self.model = impl.model
+        self.tokenizer = impl.tokenizer
+        self.config = impl.config
+        
+        return result
+    
+    def embed(
+        self,
+        texts: Sequence[str],
+        config: Optional[EmbeddingConfig] = None,
+        clear_cache: bool = True,
+    ) -> List[List[float]]:
+        """Generate embeddings for texts."""
+        # Get the appropriate implementation and delegate
+        impl = self._get_implementation()
+        return impl.embed(texts, config, clear_cache)
+    
+    def embedding_dim(self) -> int:
+        """Get embedding dimension."""
+        # Get the appropriate implementation and delegate
+        impl = self._get_implementation()
+        return impl.embedding_dim()
+    
+    def destroy(self) -> None:
+        """Destroy the model and free resources."""
+        super().destroy()
+        if self._impl is not None:
+            self._impl.destroy()
+            self._impl = None
+
+
+# Backward compatibility alias
+Embedder = MLXEmbedder
+
+
+def _detect_model_type(model_path: PathType) -> str:
+    """Detect the model type from config.json."""
+    if os.path.isfile(model_path):
+        model_path = os.path.dirname(model_path)
+    
+    config_path = os.path.join(model_path, "config.json")
+    
+    if not os.path.exists(config_path):
+        # If no config.json, assume it's a generic model
+        return "generic"
+    
+    try:
+        with open(config_path, "r") as f:
+            config = json.load(f)
+        
+        # Check architectures field for JinaBertModel
+        architectures = config.get("architectures", [])
+        if "JinaBertModel" in architectures:
+            return "jina_v2"
+        
+        # Default to generic mlx_embeddings for other models
+        return "generic"
+    
+    except Exception as e:
+        print(f"Warning: Could not parse config.json: {e}")
+        return "generic"
 
 
 # Factory function for creating embedder instances
@@ -304,9 +608,10 @@ def create_embedder(
     model_path: PathType,
     tokenizer_path: Optional[PathType] = None,
     device: Optional[str] = None,
-) -> Embedder:
-    """Create and return an Embedder instance."""
+) -> MLXEmbedder:
+    """Create and return an MLXEmbedder instance that automatically routes to the appropriate implementation."""
     if tokenizer_path is None:
         tokenizer_path = model_path
     
-    return Embedder(model_path, tokenizer_path, device)
+    # Return the concrete MLXEmbedder which will handle routing internally
+    return MLXEmbedder(model_path, tokenizer_path, device)

nexaai/mlx_backend/embedding/main.py

@@ -12,71 +12,162 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .interface import create_embedder, EmbeddingConfig
+import os
+import sys
+import numpy as np
+from pathlib import Path
 
+# Add parent path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
 
-def test_embedding(model_path):
-    """Test embedding model functionality."""
+# Import from interface (uses the factory pattern with routing)
+from .interface import create_embedder
+from .interface import EmbeddingConfig
+from huggingface_hub import snapshot_download
+
+
+def download_model_if_needed(model_id, local_dir):
+    """Download model from Hugging Face Hub if not present locally."""
+    if not os.path.exists(os.path.join(local_dir, "config.json")):
+        print(f"📥 Model not found locally. Downloading {model_id}...")
+        os.makedirs(local_dir, exist_ok=True)
+        try:
+            snapshot_download(
+                repo_id=model_id,
+                local_dir=local_dir,
+                resume_download=True,
+                local_dir_use_symlinks=False
+            )
+            print("✅ Model download completed!")
+        except Exception as e:
+            print(f"❌ Failed to download model: {e}")
+            raise
+
+
+def test_embedding_interface(model_path, is_local=False):
+    """Test embedding model functionality using the interface."""
+    
+    print("=" * 70)
+    print("TESTING EMBEDDING MODEL VIA INTERFACE")
+    print("=" * 70)
+    
+    # Handle model path - download if it's a HF model ID
+    if not is_local and "/" in model_path:
+        # It's a HuggingFace model ID
+        local_dir = f"./modelfiles/{model_path.replace('/', '_')}"
+        download_model_if_needed(model_path, local_dir)
+        model_path = local_dir
+    
+    # Create embedder using factory function (will auto-detect model type)
+    print(f"\n🔍 Creating embedder for: {model_path}")
     embedder = create_embedder(model_path=model_path)
+    print(f"✅ Created embedder type: {type(embedder).__name__}")
     
     # Load the model
-    print("Loading embedding model...")
+    print("\n📚 Loading embedding model...")
     success = embedder.load_model(model_path)
     
     if not success:
-        print("Failed to load model!")
+        print("❌ Failed to load model!")
         return
     
     print("✅ Model loaded successfully!")
-    print(f"Embedding dimension: {embedder.embedding_dim()}")
+    print(f"📏 Embedding dimension: {embedder.embedding_dim()}")
     
     # Test texts
     test_texts = [
         "Hello, how are you?",
         "What is machine learning?",
         "The weather is nice today.",
-        "Python is a programming language."
+        "Python is a programming language.",
+        "Artificial intelligence is changing the world."
     ]
     
-    # Configure embedding
-    config = EmbeddingConfig(
-        batch_size=2,
-        normalize=True,
-        normalize_method="l2"
-    )
+    # Configure embedding with different settings
+    configs = [
+        EmbeddingConfig(batch_size=2, normalize=True, normalize_method="l2"),
+        EmbeddingConfig(batch_size=3, normalize=False),
+    ]
+    
+    for config_idx, config in enumerate(configs):
+        print(f"\n{'='*50}")
+        print(f"TEST {config_idx + 1}: Config - Batch: {config.batch_size}, "
+              f"Normalize: {config.normalize}, Method: {config.normalize_method}")
+        print('='*50)
+        
+        # Generate embeddings
+        embeddings = embedder.embed(test_texts, config)
+        
+        # Display results
+        print(f"\n📊 Generated {len(embeddings)} embeddings")
+        
+        for i, (text, embedding) in enumerate(zip(test_texts[:3], embeddings[:3])):
+            print(f"\n  Text {i+1}: '{text}'")
+            print(f"    Dimension: {len(embedding)}")
+            print(f"    First 5 values: {[f'{v:.4f}' for v in embedding[:5]]}")
+            
+            # Calculate magnitude
+            magnitude = np.linalg.norm(embedding)
+            print(f"    Magnitude: {magnitude:.6f}")
     
-    print(f"\nGenerating embeddings for {len(test_texts)} texts...")
+    # Compute similarity matrix for normalized embeddings
+    print("\n" + "="*50)
+    print("SIMILARITY MATRIX (L2 Normalized)")
+    print("="*50)
     
-    # Generate embeddings
+    config = EmbeddingConfig(batch_size=len(test_texts), normalize=True, normalize_method="l2")
     embeddings = embedder.embed(test_texts, config)
     
-    # Display results
-    print("\nEmbedding Results:")
-    print("=" * 50)
+    # Convert to numpy for easier computation
+    embeddings_np = np.array(embeddings)
+    similarity_matrix = np.dot(embeddings_np, embeddings_np.T)
     
-    for i, (text, embedding) in enumerate(zip(test_texts, embeddings)):
-        print(f"\nText {i+1}: '{text}'")
-        print(f"Embedding shape: {len(embedding)}")
-        print(f"First 5 values: {embedding[:5]}")
-        
-        # Calculate magnitude for normalized embeddings
-        magnitude = sum(x*x for x in embedding) ** 0.5
-        print(f"Magnitude: {magnitude:.6f}")
+    print("\nTexts:")
+    for i, text in enumerate(test_texts):
+        print(f"  [{i}] {text[:30]}...")
+    
+    print("\nSimilarity Matrix:")
+    print("     ", end="")
+    for i in range(len(test_texts)):
+        print(f"  [{i}] ", end="")
+    print()
     
-    # Test similarity between first two embeddings
-    if len(embeddings) >= 2:
-        emb1, emb2 = embeddings[0], embeddings[1]
-        similarity = sum(a*b for a, b in zip(emb1, emb2))
-        print(f"\nCosine similarity between text 1 and 2: {similarity:.6f}")
+    for i in range(len(test_texts)):
+        print(f"  [{i}]", end="")
+        for j in range(len(test_texts)):
+            print(f" {similarity_matrix[i, j]:5.2f}", end="")
+        print()
+    
+    # Find most similar pairs
+    print("\n🔍 Most Similar Pairs (excluding self-similarity):")
+    similarities = []
+    for i in range(len(test_texts)):
+        for j in range(i+1, len(test_texts)):
+            similarities.append((similarity_matrix[i, j], i, j))
+    
+    similarities.sort(reverse=True)
+    for sim, i, j in similarities[:3]:
+        print(f"  • Texts [{i}] and [{j}]: {sim:.4f}")
     
     # Cleanup
     embedder.close()
-    print("\n✅ Embedding test completed!")
+    print("\n✅ Interface test completed successfully!")
 
 
 if __name__ == "__main__":
     import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model_path", type=str, default="nexaml/jina-v2-fp16-mlx")
+    parser = argparse.ArgumentParser(description="Test embedding models via interface")
+    parser.add_argument(
+        "--model_path", 
+        type=str, 
+        default="nexaml/jina-v2-fp16-mlx",
+        help="Model path (local) or HuggingFace model ID"
+    )
+    parser.add_argument(
+        "--local",
+        action="store_true",
+        help="Indicate if model_path is a local directory"
+    )
     args = parser.parse_args()
-    test_embedding(args.model_path)
+    
+    test_embedding_interface(args.model_path, args.local)

nexaai/utils/model_manager.py

@@ -820,14 +820,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,

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

{nexaai-1.0.5.dist-info → nexaai-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexaai
-Version: 1.0.5
+Version: 1.0.6
 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.5.dist-info → nexaai-1.0.6.dist-info}/RECORD

@@ -1,6 +1,6 @@
 nexaai/__init__.py,sha256=jXdC4vv6DBK1fVewYTYSUhOOYfvf_Mk81UIeMGGIKUg,2029
-nexaai/_stub.cpython-310-darwin.so,sha256=gtvKibntbpP3fkgDxJkE-KiP2C6mkCRYQcHlzFlsqiw,49832
-nexaai/_version.py,sha256=j-3XhaOQERPf3uculltVeo9djhrsUyWzi1EY_j4wPEc,138
+nexaai/_stub.cpython-310-darwin.so,sha256=B2vHaw7BNJAnmEiz8ExY-vseaXkK_yDGI950dxdbRQ4,49832
+nexaai/_version.py,sha256=jSTrJA7aO22uaIWjegon7bkFN2WNt7W4are37-C1cqg,138
 nexaai/asr.py,sha256=NljMXDErwPNMOPaRkJZMEDka9Nk8xyur7L8i924TStY,2054
 nexaai/base.py,sha256=N8PRgDFA-XPku2vWnQIofQ7ipz3pPlO6f8YZGnuhquE,982
 nexaai/common.py,sha256=yBnIbqYaQYnfrl7IczOBh6MDibYZVxwaRJEglYcKgGs,3422
@@ -19,21 +19,21 @@ nexaai/binds/__init__.py,sha256=T9Ua7SzHNglSeEqXlfH5ymYXRyXhNKkC9z_y_bWCNMo,80
 nexaai/binds/common_bind.cpython-310-darwin.so,sha256=FF5WuJj0fNCim_HjseBQu38vL-1M5zI_7EVTD7Bs-Bc,233960
 nexaai/binds/embedder_bind.cpython-310-darwin.so,sha256=mU6hP0SyH8vcmPpC2GIr7ioK7539dsg_YbmrBdmj7l0,202032
 nexaai/binds/libcrypto.dylib,sha256=ysW8ydmDPnnNRy3AHESjJwMTFfmGDKU9eLIaiR37ca0,5091432
-nexaai/binds/libnexa_bridge.dylib,sha256=xALttGYPxTLArRgVSt5sKB2zFBWaL9UspLeO_7jutY4,250712
+nexaai/binds/libnexa_bridge.dylib,sha256=oCAhLh6CIncKS4oO5_xAcvtLniIY8inRuN0S7iRfCM4,250712
 nexaai/binds/libssl.dylib,sha256=JHPTSbRFnImmoWDO9rFdiKb0lJMT3q78VEsx-5-S0sk,889520
 nexaai/binds/llm_bind.cpython-310-darwin.so,sha256=aYqMs5VhC07RNZZgyS9JeYJJgWCl-toZOmt6vXu5yp0,183008
-nexaai/binds/nexa_llama_cpp/libggml-base.dylib,sha256=ChIX99NoLhsYVXJvv8iGMIpx-5Rst2gYwux-bEektB4,626992
-nexaai/binds/nexa_llama_cpp/libggml-cpu.so,sha256=tZcQGr6aWSQmTN12ieC2nIJ0lID5-mTkqoGjxJh07b4,1039744
-nexaai/binds/nexa_llama_cpp/libggml-metal.so,sha256=eDWuZ4ui8LsahlU05sNEMZ7lTtZfswKtcGcGvWTB0ro,713680
+nexaai/binds/nexa_llama_cpp/libggml-base.dylib,sha256=oikz7Qxzx6A0mPROq7uHTUwWn66LvvOjcdVstG-M8Fw,629528
+nexaai/binds/nexa_llama_cpp/libggml-cpu.so,sha256=WepzOOeElmdOlsoMv7loLHsj8-Qx2O9ZJPlNnX11KJI,1039800
+nexaai/binds/nexa_llama_cpp/libggml-metal.so,sha256=ssn3Bqmnu7YA_FKL513Y18gbxG8WP9Udw71DNKV34eo,713680
 nexaai/binds/nexa_llama_cpp/libggml.dylib,sha256=Z2ZvkyEEpPtHhMYap-44p9Q0M6TXJbLcMy-smR2X5sk,58336
-nexaai/binds/nexa_llama_cpp/libllama.dylib,sha256=9pJFMHFlKHiQgLzi8YXextf5dPCYylQkpDv0EvCEssM,1958384
-nexaai/binds/nexa_llama_cpp/libmtmd.dylib,sha256=Etc0ZuYVNo9l1OTQRjZY4cTkgH2S2EL84DpxpWJeoJ4,682480
-nexaai/binds/nexa_llama_cpp/libnexa_plugin.dylib,sha256=-ms3BC2P2zFhxPBan6akvLf55JBx_gYzst789WXZALY,2590008
+nexaai/binds/nexa_llama_cpp/libllama.dylib,sha256=QZBn_w32g8NAJLE1unC_qx1BCVM531LeqTUqWipt9ks,1982280
+nexaai/binds/nexa_llama_cpp/libmtmd.dylib,sha256=F1QLNlfjiECRssUtEZeuqNqej-8COYcQjMZKPAB0CGk,701504
+nexaai/binds/nexa_llama_cpp/libnexa_plugin.dylib,sha256=csMdM6l21qpj-3_4z0xGsYM1snOBg4cJPfLXOQ8oTcI,2644752
 nexaai/cv_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/cv_impl/mlx_cv_impl.py,sha256=gKECQOv8iaWwG3bl7xeqVy2NN_9K7tYerIFzfn4eLo4,3228
 nexaai/cv_impl/pybind_cv_impl.py,sha256=uSmwBste4cT7c8DQmXzRLmzwDf773PAbXNYWW1UzVls,1064
 nexaai/embedder_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nexaai/embedder_impl/mlx_embedder_impl.py,sha256=OsDzsc_2wZkSoWu6yCOZadMkaYdBW3uyjF11hDKTaX8,4383
+nexaai/embedder_impl/mlx_embedder_impl.py,sha256=dTjOC1VJ9ypIgCvkK_jKNSWpswbg132rDcTzWcL5oFA,4482
 nexaai/embedder_impl/pybind_embedder_impl.py,sha256=Ga1JYauVkRq6jwAGL7Xx5HDaIx483_v9gZVoTyd3xNU,3495
 nexaai/image_gen_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/image_gen_impl/mlx_image_gen_impl.py,sha256=BuDkksvXyb4J02GsdnbGAmYckfUU0Eah6BimoMD3QqY,11219
@@ -53,9 +53,9 @@ nexaai/mlx_backend/cv/interface.py,sha256=qE51ApUETEZxDMPZB4VdV098fsXcIiEg4Hj9za
 nexaai/mlx_backend/cv/main.py,sha256=hYaF2C36hKTyy7kGMNkzLrdczPiFVS73H320klzzpVM,2856
 nexaai/mlx_backend/cv/modeling/pp_ocr_v4.py,sha256=Vpa-QTy7N5oFfGI7Emldx1dOYJWv_4nAFNRDz_5vHBI,58593
 nexaai/mlx_backend/embedding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nexaai/mlx_backend/embedding/generate.py,sha256=irAbc_nBD9wMqe5z1eFgp6Gf_mONow2I3z3g-DAAbtY,5018
-nexaai/mlx_backend/embedding/interface.py,sha256=hW0yrtD55ol0hB-X5glcXMc4TiyKuT4U5GaI8SP-kAU,11508
-nexaai/mlx_backend/embedding/main.py,sha256=_kIwz69A7UXA_u0VNP6eqM2W-LH_1_1hlJtro6U_FjI,2620
+nexaai/mlx_backend/embedding/generate.py,sha256=leZA0Ir78-5GV3jloPKYSAKgb04Wr5jORFJlSSVyKs0,12855
+nexaai/mlx_backend/embedding/interface.py,sha256=M7AGiq_UVLNIi2Ie6H08ySnMxIjIhUlNgmV9I_rKYt4,22742
+nexaai/mlx_backend/embedding/main.py,sha256=xKRebBcooKuf8DzWKwCicftes3MAcYAd1QvcT9_AAPQ,6003
 nexaai/mlx_backend/embedding/modeling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/mlx_backend/embedding/modeling/nexa_jina_v2.py,sha256=F9Z_9r-Dh0wNThiMp5W5hqE2dt5bf4ps5_c6h4BuWGw,15218
 nexaai/mlx_backend/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -358,12 +358,12 @@ nexaai/tts_impl/mlx_tts_impl.py,sha256=i_uNPdvlXYtL3e01oKjDlP9jgkWCRt1bBHsExaaiJ
 nexaai/tts_impl/pybind_tts_impl.py,sha256=mpn44r6pfYLIl-NrEy2dXHjGtWtNCmM7HRyxiANxUI4,1444
 nexaai/utils/avatar_fetcher.py,sha256=bWy8ujgbOiTHFCjFxTwkn3uXbZ84PgEGUkXkR3MH4bI,3821
 nexaai/utils/decode.py,sha256=61n4Zf6c5QLyqGoctEitlI9BX3tPlP2a5aaKNHbw3T4,404
-nexaai/utils/model_manager.py,sha256=c07ocxxw1IHCQw6esbmYK0dX2R2OajfEIGsC_2teHXo,48572
-nexaai/utils/progress_tracker.py,sha256=76HlPkyN41IMHSsH56-qdlN_aY_oBfJz50J16Cx67R0,15102
+nexaai/utils/model_manager.py,sha256=QJlE-VvkAy38-8hhPYDu8NVHZqpF_HygXU189qd4Wkg,48157
+nexaai/utils/progress_tracker.py,sha256=mTw7kaKH8BkmecYm7iBMqRHd9uUH4Ch0S8CzbpARDCk,15404
 nexaai/vlm_impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nexaai/vlm_impl/mlx_vlm_impl.py,sha256=od1R1mRoIgPG3NHC7JiDlcB_YJY8aklX8Em3ZkeHNpE,10734
 nexaai/vlm_impl/pybind_vlm_impl.py,sha256=5ZMFgDATthmMzjrd-vE5KX5ZAMoWPYbF_FTLz8DBKIk,8908
-nexaai-1.0.5.dist-info/METADATA,sha256=fxZuww9PtpWooTJNDcf04tzwKi7AEThWyD0Z9O5a0rY,1151
-nexaai-1.0.5.dist-info/WHEEL,sha256=0KYp5feZ1CMUhsfFXKpSQTbSmQbXy4mv6yPPVBXg2EM,110
-nexaai-1.0.5.dist-info/top_level.txt,sha256=LRE2YERlrZk2vfuygnSzsEeqSknnZbz3Z1MHyNmBU4w,7
-nexaai-1.0.5.dist-info/RECORD,,
+nexaai-1.0.6.dist-info/METADATA,sha256=A27rUPomOEG4fxgVqRitNGDw71-HoGLvlphrhjkebrU,1197
+nexaai-1.0.6.dist-info/WHEEL,sha256=0KYp5feZ1CMUhsfFXKpSQTbSmQbXy4mv6yPPVBXg2EM,110
+nexaai-1.0.6.dist-info/top_level.txt,sha256=LRE2YERlrZk2vfuygnSzsEeqSknnZbz3Z1MHyNmBU4w,7
+nexaai-1.0.6.dist-info/RECORD,,