lollms-client 0.12.2__tar.gz → 0.12.4__tar.gz

{lollms_client-0.12.2 → lollms_client-0.12.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.12.2
+Version: 0.12.4
 Summary: A client library for LoLLMs generate endpoint
 Home-page: https://github.com/ParisNeo/lollms_client
 Author: ParisNeo

{lollms_client-0.12.2 → lollms_client-0.12.4}/lollms_client/llm_bindings/lollms/__init__.py

@@ -10,6 +10,7 @@ import json
 
 BindingName = "LollmsLLMBinding"
 
+
 class LollmsLLMBinding(LollmsLLMBinding):
     """LOLLMS-specific binding implementation"""
     
@@ -215,7 +216,18 @@ class LollmsLLMBinding(LollmsLLMBinding):
         except Exception as ex:
             return {"status": False, "error": str(ex)}
 
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
 
+        Args:
+            tokens (list): List of tokens to detokenize.
+
+        Returns:
+            int: Number of tokens in text.
+        """        
+        return len(self.tokenize(text))
+    
     def embed(self, text: str, **kwargs) -> list:
         """
         Get embeddings for the input text using Ollama API

lollms_client-0.12.4/lollms_client/llm_bindings/ollama/__init__.py

@@ -0,0 +1,578 @@
+# bindings/ollama/binding.py
+import requests
+import json
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+# encode_image is not strictly needed if ollama-python handles paths, but kept for consistency if ever needed.
+# from lollms_client.lollms_utilities import encode_image 
+from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
+from typing import Optional, Callable, List, Union, Dict
+
+from ascii_colors import ASCIIColors, trace_exception
+
+try:
+    import ollama
+except ImportError:
+    ASCIIColors.warning("Ollama library not found. Please install it using 'pip install ollama'")
+    ollama = None
+
+BindingName = "OllamaBinding"
+
+
+def count_tokens_ollama(
+    text_to_tokenize: str,
+    model_name: str,
+    ollama_host: str = "http://localhost:11434",
+    timeout: int = 30,
+    verify_ssl_certificate: bool = True,
+    headers: Optional[Dict[str, str]] = None
+) -> int:
+    """
+    Counts the number of tokens in a given text using a specified Ollama model
+    by calling the Ollama server's /api/tokenize endpoint.
+
+    Args:
+        text_to_tokenize (str): The text to be tokenized.
+        model_name (str): The name of the Ollama model to use (e.g., "llama3", "mistral").
+        ollama_host (str): The base URL of the Ollama server (default: "http://localhost:11434").
+        timeout (int): Timeout for the request in seconds (default: 30).
+        verify_ssl_certificate (bool): Whether to verify SSL.
+        headers (Optional[Dict[str, str]]): Optional headers for the request.
+
+    Returns:
+        int: The number of tokens. Returns -1 if an error occurs.
+    """
+    api_url = f"{ollama_host.rstrip('/')}/api/tokenize"
+    payload = {
+        "model": model_name,
+        "prompt": text_to_tokenize
+    }
+    request_headers = headers if headers else {}
+
+    try:
+        response = requests.post(api_url, json=payload, timeout=timeout, verify=verify_ssl_certificate, headers=request_headers)
+        response.raise_for_status()  # Raises HTTPError for bad responses (4xx or 5xx)
+
+        response_data = response.json()
+
+        if "tokens" in response_data and isinstance(response_data["tokens"], list):
+            return len(response_data["tokens"])
+        else:
+            ASCIIColors.warning(
+                f"Ollama response for token count did not contain a 'tokens' list. Response: {response_data}"
+            )
+            return -1 # Or raise ValueError
+
+    except requests.exceptions.HTTPError as http_err:
+        ASCIIColors.error(f"HTTP error occurred during token count: {http_err} - {http_err.response.text if http_err.response else 'No response text'}")
+        return -1
+    except requests.exceptions.RequestException as req_err:
+        ASCIIColors.error(f"Request error occurred during token count: {req_err}")
+        return -1
+    except json.JSONDecodeError as json_err:
+        ASCIIColors.error(
+            f"Failed to decode JSON response from Ollama during token count: {json_err}. Response text: {response.text if hasattr(response, 'text') else 'No response object'}"
+        )
+        return -1
+    except Exception as e:
+        ASCIIColors.error(f"An unexpected error occurred during token count: {e}")
+        return -1
+
+class OllamaBinding(LollmsLLMBinding):
+    """Ollama-specific binding implementation using the ollama-python library."""
+    
+    DEFAULT_HOST_ADDRESS = "http://localhost:11434"
+    
+    def __init__(self,
+                 host_address: str = None,
+                 model_name: str = "",
+                 service_key: str = None,
+                 verify_ssl_certificate: bool = True,
+                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat
+                 ):
+        """
+        Initialize the Ollama binding.
+
+        Args:
+            host_address (str): Host address for the Ollama service. Defaults to DEFAULT_HOST_ADDRESS.
+            model_name (str): Name of the model to use. Defaults to empty string.
+            service_key (str): Authentication key for the service (used in Authorization header). Defaults to None.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
+            default_completion_format (ELF_COMPLETION_FORMAT): Default completion format.
+        """
+        _host_address = host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS
+        super().__init__(
+            binding_name=BindingName, # Use the module-level BindingName
+            host_address=_host_address,
+            model_name=model_name,
+            service_key=service_key,
+            verify_ssl_certificate=verify_ssl_certificate,
+            default_completion_format=default_completion_format
+        )
+        if ollama is None:
+            raise ImportError("Ollama library is not installed. Please run 'pip install ollama'.")
+
+        self.ollama_client_headers = {}
+        if self.service_key:
+            self.ollama_client_headers['Authorization'] = f'Bearer {self.service_key}'
+
+        try:
+            self.ollama_client = ollama.Client(
+                host=self.host_address,
+                headers=self.ollama_client_headers if self.ollama_client_headers else None,
+                verify=self.verify_ssl_certificate # Passed to httpx.Client
+            )
+        except Exception as e:
+            ASCIIColors.error(f"Failed to initialize Ollama client: {e}")
+            self.ollama_client = None # Ensure it's None if initialization fails
+            # Optionally re-raise or handle so the binding is clearly unusable
+            raise ConnectionError(f"Could not connect or initialize Ollama client at {self.host_address}: {e}") from e
+    
+    def generate_text(self, 
+                     prompt: str,
+                     images: Optional[List[str]] = None, # List of image file paths
+                     n_predict: Optional[int] = None,
+                     stream: bool = False,
+                     temperature: float = 0.7, # Ollama default is 0.8, common default 0.7
+                     top_k: int = 40,          # Ollama default is 40
+                     top_p: float = 0.9,       # Ollama default is 0.9
+                     repeat_penalty: float = 1.1, # Ollama default is 1.1
+                     repeat_last_n: int = 64,  # Ollama default is 64
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None, # Ollama calls this num_thread
+                     ctx_size: Optional[int] = None,  # Ollama calls this num_ctx
+                     streaming_callback: Optional[Callable[[str, int], bool]] = None
+                     ) -> Union[str, Dict[str, any]]:
+        """
+        Generate text using the Ollama service, with optional image support.
+
+        Args:
+            prompt (str): The input prompt for text generation.
+            images (Optional[List[str]]): List of image file paths for multimodal generation.
+            n_predict (Optional[int]): Maximum number of tokens to generate (num_predict).
+            stream (bool): Whether to stream the output. Defaults to False.
+            temperature (float): Sampling temperature.
+            top_k (int): Top-k sampling parameter.
+            top_p (float): Top-p sampling parameter.
+            repeat_penalty (float): Penalty for repeated tokens.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty.
+            seed (Optional[int]): Random seed for generation.
+            n_threads (Optional[int]): Number of threads to use (num_thread).
+            ctx_size (Optional[int]): Context window size (num_ctx).
+            streaming_callback (Optional[Callable[[str, int], bool]]): Callback for streaming output.
+                - First parameter (str): The chunk of text received from the stream.
+                - Second parameter (int): The message type (typically MSG_TYPE.MSG_TYPE_CHUNK).
+                Return False to stop streaming.
+
+        Returns:
+            Union[str, Dict[str, any]]: Generated text if successful, or a dictionary with status and error if failed.
+        """
+        if not self.ollama_client:
+             return {"status": False, "error": "Ollama client not initialized."}
+
+        options = {}
+        if n_predict is not None: options['num_predict'] = n_predict
+        if temperature is not None: options['temperature'] = float(temperature)
+        if top_k is not None: options['top_k'] = top_k
+        if top_p is not None: options['top_p'] = top_p
+        if repeat_penalty is not None: options['repeat_penalty'] = repeat_penalty
+        if repeat_last_n is not None: options['repeat_last_n'] = repeat_last_n
+        if seed is not None: options['seed'] = seed
+        if n_threads is not None: options['num_thread'] = n_threads
+        if ctx_size is not None: options['num_ctx'] = ctx_size
+        
+        full_response_text = ""
+
+        try:
+            if images: # Multimodal
+                # ollama-python expects paths or bytes for images
+                processed_images = []
+                for img_path in images:
+                    # Assuming img_path is a file path. ollama-python will read and encode it.
+                    # If images were base64 strings, they would need decoding to bytes first.
+                    processed_images.append(img_path)
+
+                messages = [{'role': 'user', 'content': prompt, 'images': processed_images if processed_images else None}]
+                
+                if stream:
+                    response_stream = self.ollama_client.chat(
+                        model=self.model_name,
+                        messages=messages,
+                        stream=True,
+                        options=options if options else None
+                    )
+                    for chunk_dict in response_stream:
+                        chunk_content = chunk_dict.get('message', {}).get('content', '')
+                        if chunk_content: # Ensure there is content to process
+                            full_response_text += chunk_content
+                            if streaming_callback:
+                                if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                    break # Callback requested stop
+                    return full_response_text
+                else: # Not streaming
+                    response_dict = self.ollama_client.chat(
+                        model=self.model_name,
+                        messages=messages,
+                        stream=False,
+                        options=options if options else None
+                    )
+                    return response_dict.get('message', {}).get('content', '')
+            else: # Text-only
+                if stream:
+                    response_stream = self.ollama_client.generate(
+                        model=self.model_name,
+                        prompt=prompt,
+                        stream=True,
+                        options=options if options else None
+                    )
+                    for chunk_dict in response_stream:
+                        chunk_content = chunk_dict.get('response', '')
+                        if chunk_content:
+                            full_response_text += chunk_content
+                            if streaming_callback:
+                                if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                    break
+                    return full_response_text
+                else: # Not streaming
+                    response_dict = self.ollama_client.generate(
+                        model=self.model_name,
+                        prompt=prompt,
+                        stream=False,
+                        options=options if options else None
+                    )
+                    return response_dict.get('response', '')
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message, "status_code": e.status_code}
+        except ollama.RequestError as e: # Covers connection errors, timeouts during request
+            error_message = f"Ollama API RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
+    
+    def tokenize(self, text: str) -> List[Union[int, str]]:
+        """
+        Tokenize the input text. For Ollama, this is complex as tokenization is model-specific
+        and best done by the server. This method provides a basic character-level tokenization
+        as a fallback or placeholder, or one could attempt to call /api/tokenize if desired.
+        The `count_tokens` method is more accurate for Ollama.
+
+        Args:
+            text (str): The text to tokenize.
+
+        Returns:
+            list: List of tokens (characters or token IDs if /api/tokenize is used).
+        """
+        # Basic character-level tokenization
+        # return list(text)
+
+        # For actual token IDs (slower, makes a network request):
+        api_url = f"{self.host_address.rstrip('/')}/api/tokenize"
+        payload = {"model": self.model_name, "prompt": text}
+        try:
+            response = requests.post(api_url, json=payload, timeout=10, verify=self.verify_ssl_certificate, headers=self.ollama_client_headers)
+            response.raise_for_status()
+            return response.json().get("tokens", [])
+        except Exception as e:
+            ASCIIColors.warning(f"Failed to tokenize text with Ollama server, falling back to char tokens: {e}")
+            return list(text)
+
+    def detokenize(self, tokens: List[Union[int,str]]) -> str:
+        """
+        Convert a list of tokens back to text. If tokens are characters, joins them.
+        If tokens are IDs, this is non-trivial without the model's tokenizer.
+
+        Args:
+            tokens (list): List of tokens to detokenize.
+
+        Returns:
+            str: Detokenized text.
+        """
+        if not tokens:
+            return ""
+        if isinstance(tokens[0], str): # Assuming character tokens
+            return "".join(tokens)
+        else: 
+            # Detokenizing IDs from Ollama is not straightforward client-side without specific tokenizer.
+            # This is a placeholder. For Ollama, detokenization usually happens server-side.
+            ASCIIColors.warning("Detokenizing integer tokens is not accurately supported by this Ollama client binding. Returning joined string of token IDs.")
+            return "".join(map(str, tokens))
+    
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text using the Ollama server's /api/tokenize endpoint.
+
+        Args:
+            text (str): Text to count tokens from.
+
+        Returns:
+            int: Number of tokens in text. Returns -1 on error.
+        """        
+        if not self.model_name:
+            ASCIIColors.warning("Cannot count tokens, model_name is not set.")
+            return -1
+        return count_tokens_ollama(text, self.model_name, self.host_address, verify_ssl_certificate=self.verify_ssl_certificate, headers=self.ollama_client_headers)
+    
+    def embed(self, text: str, **kwargs) -> List[float]:
+        """
+        Get embeddings for the input text using Ollama API.
+        
+        Args:
+            text (str): Input text to embed.
+            **kwargs: Optional arguments. Can include 'model' to override self.model_name,
+                      and 'options' dictionary for Ollama embedding options.
+        
+        Returns:
+            List[float]: The embedding vector.
+        
+        Raises:
+            Exception: if embedding fails or Ollama client is not available.
+        """
+        if not self.ollama_client:
+             raise Exception("Ollama client not initialized.")
+
+        model_to_use = kwargs.get("model", self.model_name)
+        if not model_to_use:
+            raise ValueError("Model name for embedding must be specified either in init or via kwargs.")
+            
+        ollama_options = kwargs.get("options", None)
+        try:
+            response = self.ollama_client.embeddings(
+                model=model_to_use, 
+                prompt=text,
+                options=ollama_options
+            )
+            return response['embedding']
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API Embeddings ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            raise Exception(error_message) from e
+        except ollama.RequestError as e:
+            error_message = f"Ollama API Embeddings RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            raise Exception(error_message) from e
+        except Exception as ex:
+            trace_exception(ex)
+            raise Exception(f"Embedding failed: {str(ex)}") from ex
+        
+    def get_model_info(self) -> dict:
+        """
+        Return information about the current Ollama model setup.
+
+        Returns:
+            dict: Dictionary containing binding name, version, host address, and model name.
+        """
+        return {
+            "name": self.binding_name, # from super class
+            "version": ollama.__version__ if ollama else "unknown", # Ollama library version
+            "host_address": self.host_address,
+            "model_name": self.model_name,
+            "supports_structured_output": False, # Ollama primarily supports text/chat
+            "supports_vision": True # Many Ollama models (e.g. llava, bakllava) support vision
+        }
+
+    def listModels(self) -> List[Dict[str, str]]:
+        """
+        Lists available models from the Ollama service using the ollama-python library.
+        The returned list of dictionaries matches the format of the original template.
+        
+        Returns:
+            List[Dict[str, str]]: A list of model information dictionaries.
+                                  Each dict has 'model_name', 'owned_by', 'created_datetime'.
+        """
+        if not self.ollama_client:
+            ASCIIColors.error("Ollama client not initialized. Cannot list models.")
+            return []
+        try:
+            ASCIIColors.debug(f"Listing ollama models from {self.host_address}")
+            response_data = self.ollama_client.list() # This returns {'models': [{'name':..., 'modified_at':..., ...}]}
+            
+            model_info_list = []
+            if 'models' in response_data:
+                for model_entry in response_data['models']:
+                    model_info_list.append({
+                        'model_name': model_entry.get('model'),
+                        'owned_by': "", # Ollama API doesn't provide a direct "owned_by" field.
+                        'created_datetime': model_entry.get('modified_at') 
+                    })
+            return model_info_list
+        except ollama.ResponseError as e:
+            ASCIIColors.error(f"Ollama API listModels ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code}) from {self.host_address}")
+            return []
+        except ollama.RequestError as e: # Covers connection errors, timeouts during request
+            ASCIIColors.error(f"Ollama API listModels RequestError: {str(e)} from {self.host_address}")
+            return []
+        except Exception as ex:
+            trace_exception(ex)
+            return []
+
+    def load_model(self, model_name: str) -> bool:
+        """
+        Set the model name for subsequent operations. Ollama loads models on demand.
+        This method can be used to verify if a model exists by attempting a small operation,
+        but for now, it just sets the name.
+
+        Args:
+            model_name (str): Name of the model to set.
+
+        Returns:
+            bool: True if model name is set.
+        """
+        self.model_name = model_name
+        # Optionally, you could try a quick self.ollama_client.show(model_name) to verify existence.
+        # For simplicity, we just set it.
+        ASCIIColors.info(f"Ollama model set to: {model_name}. It will be loaded by the server on first use.")
+        return True
+
+if __name__ == '__main__':
+    global full_streamed_text
+    # Example Usage (requires an Ollama server running)
+    ASCIIColors.yellow("Testing OllamaBinding...")
+
+    # --- Configuration ---
+    # Replace with your Ollama server details if not localhost
+    ollama_host = "http://localhost:11434" 
+    # Common model, pull it first: `ollama pull llama3` or `ollama pull llava` for vision
+    test_model_name = "llama3" 
+    test_vision_model_name = "llava" # or another vision model you have
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = OllamaBinding(host_address=ollama_host, model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+        ASCIIColors.info(f"Using Ollama client version: {ollama.__version__ if ollama else 'N/A'}")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} models. First 5:")
+            for m in models[:5]:
+                print(m)
+        else:
+            ASCIIColors.warning("No models found or failed to list models. Ensure Ollama is running and has models.")
+
+        # --- Load Model (sets active model) ---
+        ASCIIColors.cyan(f"\n--- Setting model to: {test_model_name} ---")
+        binding.load_model(test_model_name)
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count}")
+
+        # --- Tokenize/Detokenize (using server for tokenize) ---
+        ASCIIColors.cyan("\n--- Tokenize/Detokenize ---")
+        tokens = binding.tokenize(sample_text)
+        ASCIIColors.green(f"Tokens for '{sample_text}': {tokens[:10]}...") # Print first 10
+        detokenized_text = binding.detokenize(tokens)
+        # Note: detokenize might not be perfect if tokens are IDs and not chars
+        ASCIIColors.green(f"Detokenized text (may vary based on tokenization type): {detokenized_text}")
+
+
+        # --- Text Generation (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Non-Streaming) ---")
+        prompt_text = "Why is the sky blue?"
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        generated_text = binding.generate_text(prompt_text, n_predict=50, stream=False)
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text: {generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Text Generation (Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Streaming) ---")
+        full_streamed_text = ""
+        def stream_callback(chunk: str, msg_type: int):
+            global full_streamed_text
+            print(f"{ASCIIColors.GREEN}Stream chunk: {chunk}{ASCIIColors.RESET}", end="", flush=True)
+            full_streamed_text += chunk
+            if len(full_streamed_text) > 100: # Example: stop after 100 chars for test
+                # print("\nStopping stream early for test.")
+                # return False # uncomment to test early stop
+                pass
+            return True
+        
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        result = binding.generate_text(prompt_text, n_predict=100, stream=True, streaming_callback=stream_callback)
+        print("\n--- End of Stream ---")
+        if isinstance(result, str):
+             ASCIIColors.green(f"Full streamed text: {result}") # 'result' is the full_streamed_text
+        else:
+            ASCIIColors.error(f"Streaming generation failed: {result}")
+
+
+        # --- Embeddings ---
+        ASCIIColors.cyan("\n--- Embeddings ---")
+        # Ensure you have an embedding model like 'mxbai-embed-large' or 'nomic-embed-text'
+        # Or use a general model if it supports embedding (some do implicitly)
+        # For this test, we'll try with the current test_model_name, 
+        # but ideally use a dedicated embedding model.
+        # binding.load_model("mxbai-embed-large") # if you have it
+        try:
+            embedding_text = "Lollms is a cool project."
+            embedding_vector = binding.embed(embedding_text) # Uses current self.model_name
+            ASCIIColors.green(f"Embedding for '{embedding_text}' (first 5 dims): {embedding_vector[:5]}...")
+            ASCIIColors.info(f"Embedding vector dimension: {len(embedding_vector)}")
+        except Exception as e:
+            ASCIIColors.warning(f"Could not get embedding with '{binding.model_name}': {e}. Some models don't support /api/embeddings or may need to be specified.")
+            ASCIIColors.warning("Try `ollama pull mxbai-embed-large` and set it as model for embedding.")
+
+
+        # --- Vision Model Test (if llava or similar is available) ---
+        # Create a dummy image file for testing
+        dummy_image_path = "dummy_test_image.png"
+        try:
+            from PIL import Image, ImageDraw
+            img = Image.new('RGB', (100, 30), color = ('red'))
+            d = ImageDraw.Draw(img)
+            d.text((10,10), "Hello", fill=('white'))
+            img.save(dummy_image_path)
+            ASCIIColors.info(f"Created dummy image: {dummy_image_path}")
+
+            ASCIIColors.cyan(f"\n--- Vision Generation (using {test_vision_model_name}) ---")
+            # Check if vision model exists
+            vision_model_exists = any(m['model_name'].startswith(test_vision_model_name) for m in models)
+            if not vision_model_exists:
+                ASCIIColors.warning(f"Vision model '{test_vision_model_name}' not found in pulled models. Skipping vision test.")
+                ASCIIColors.warning(f"Try: `ollama pull {test_vision_model_name}`")
+            else:
+                binding.load_model(test_vision_model_name) # Switch to vision model
+                vision_prompt = "What is written in this image?"
+                ASCIIColors.info(f"Vision Prompt: {vision_prompt} with image {dummy_image_path}")
+                
+                vision_response = binding.generate_text(
+                    prompt=vision_prompt,
+                    images=[dummy_image_path],
+                    n_predict=50,
+                    stream=False
+                )
+                if isinstance(vision_response, str):
+                    ASCIIColors.green(f"Vision model response: {vision_response}")
+                else:
+                    ASCIIColors.error(f"Vision generation failed: {vision_response}")
+        except ImportError:
+            ASCIIColors.warning("Pillow library not found. Cannot create dummy image for vision test. `pip install Pillow`")
+        except Exception as e:
+            ASCIIColors.error(f"Error during vision test: {e}")
+        finally:
+            import os
+            if os.path.exists(dummy_image_path):
+                os.remove(dummy_image_path)
+
+
+    except ConnectionRefusedError:
+        ASCIIColors.error("Connection to Ollama server refused. Is Ollama running?")
+    except ImportError as e:
+        ASCIIColors.error(f"Import error: {e}. Make sure 'ollama' library is installed ('pip install ollama').")
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nOllamaBinding test finished.")

{lollms_client-0.12.2 → lollms_client-0.12.4}/lollms_client/llm_bindings/openai/__init__.py

@@ -199,6 +199,19 @@ class OpenAIBinding(LollmsLLMBinding):
             return tiktoken.model.encoding_for_model(self.model_name).decode(tokens)
         except:
             return tiktoken.model.encoding_for_model("gpt-3.5-turbo").decode(tokens)
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
+
+        Args:
+            tokens (list): List of tokens to detokenize.
+
+        Returns:
+            int: Number of tokens in text.
+        """        
+        return len(self.tokenize(text))
+
         
     def embed(self, text: str, **kwargs) -> list:
         """

{lollms_client-0.12.2 → lollms_client-0.12.4}/lollms_client/llm_bindings/transformers/__init__.py

@@ -254,6 +254,19 @@ class TransformersBinding(LollmsLLMBinding):
         """Convert a list of tokens back to text."""
         return "".join(tokens)
     
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
+
+        Args:
+            tokens (list): List of tokens to detokenize.
+
+        Returns:
+            int: Number of tokens in text.
+        """        
+        return len(self.tokenize(text))
+
+    
     def embed(self, text: str, **kwargs) -> list:
         """Get embeddings for the input text (placeholder)."""
         pass

{lollms_client-0.12.2 → lollms_client-0.12.4}/lollms_client/lollms_llm_binding.py

@@ -103,6 +103,19 @@ class LollmsLLMBinding(ABC):
             str: Detokenized text.
         """
         pass
+    
+    @abstractmethod
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
+
+        Args:
+            tokens (list): List of tokens to detokenize.
+
+        Returns:
+            int: Number of tokens in text.
+        """        
+        pass
 
     @abstractmethod
     def embed(self, text: str, **kwargs) -> list:

{lollms_client-0.12.2 → lollms_client-0.12.4}/lollms_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.12.2
+Version: 0.12.4
 Summary: A client library for LoLLMs generate endpoint
 Home-page: https://github.com/ParisNeo/lollms_client
 Author: ParisNeo

{lollms_client-0.12.2 → lollms_client-0.12.4}/setup.py

@@ -8,7 +8,7 @@ with open('requirements.txt', 'r') as f:
     
 setuptools.setup(
     name="lollms_client",
-    version="0.12.2",
+    version="0.12.4",
     author="ParisNeo",
     author_email="parisneoai@gmail.com",
     description="A client library for LoLLMs generate endpoint",

lollms_client-0.12.2/lollms_client/llm_bindings/ollama/__init__.py

@@ -1,298 +0,0 @@
-# bindings/ollama/binding.py
-import requests
-import json
-from lollms_client.lollms_llm_binding import LollmsLLMBinding
-from lollms_client.lollms_types import MSG_TYPE
-from lollms_client.lollms_utilities import encode_image
-from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
-from typing import Optional, Callable, List, Union
-from ascii_colors import ASCIIColors, trace_exception
-
-BindingName = "OllamaBinding"
-
-
-class OllamaBinding(LollmsLLMBinding):
-    """Ollama-specific binding implementation"""
-    
-    DEFAULT_HOST_ADDRESS = "http://localhost:11434"
-    
-    def __init__(self,
-                 host_address: str = None,
-                 model_name: str = "",
-                 service_key: str = None,
-                 verify_ssl_certificate: bool = True,
-                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat
-                 ):
-        """
-        Initialize the Ollama binding.
-
-        Args:
-            host_address (str): Host address for the Ollama service. Defaults to DEFAULT_HOST_ADDRESS.
-            model_name (str): Name of the model to use. Defaults to empty string.
-            service_key (str): Authentication key for the service. Defaults to None.
-            verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
-            personality (Optional[int]): Ignored parameter for compatibility with LollmsLLMBinding.
-        """
-        super().__init__(
-            binding_name="ollama",
-            host_address=host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS,
-            model_name=model_name,
-            service_key=service_key,
-            verify_ssl_certificate=verify_ssl_certificate,
-            default_completion_format=default_completion_format
-        )
-        self.model = None
-    
-    def generate_text(self, 
-                     prompt: str,
-                     images: Optional[List[str]] = None,
-                     n_predict: Optional[int] = None,
-                     stream: bool = False,
-                     temperature: float = 0.1,
-                     top_k: int = 50,
-                     top_p: float = 0.95,
-                     repeat_penalty: float = 0.8,
-                     repeat_last_n: int = 40,
-                     seed: Optional[int] = None,
-                     n_threads: int = 8,
-                     ctx_size: int | None = None,
-                     streaming_callback: Optional[Callable[[str, str], None]] = None) -> Union[str, dict]:
-        """
-        Generate text using the Ollama service, with optional image support.
-
-        Args:
-            prompt (str): The input prompt for text generation.
-            images (Optional[List[str]]): List of image file paths for multimodal generation.
-                If provided, uses the /api endpoint with message format.
-            n_predict (Optional[int]): Maximum number of tokens to generate.
-            stream (bool): Whether to stream the output. Defaults to False.
-            temperature (float): Sampling temperature. Defaults to 0.1.
-            top_k (int): Top-k sampling parameter. Defaults to 50 (not used in Ollama API directly).
-            top_p (float): Top-p sampling parameter. Defaults to 0.95 (not used in Ollama API directly).
-            repeat_penalty (float): Penalty for repeated tokens. Defaults to 0.8 (not used in Ollama API directly).
-            repeat_last_n (int): Number of previous tokens to consider for repeat penalty. Defaults to 40 (not used).
-            seed (Optional[int]): Random seed for generation.
-            n_threads (int): Number of threads to use. Defaults to 8 (not used in Ollama API directly).
-            streaming_callback (Optional[Callable[[str, str], None]]): Callback for streaming output.
-                - First parameter (str): The chunk of text received from the stream.
-                - Second parameter (str): The message type (typically MSG_TYPE.MSG_TYPE_CHUNK).
-
-        Returns:
-            Union[str, dict]: Generated text if successful, or a dictionary with status and error if failed.
-
-        Note:
-            Some parameters (top_k, top_p, repeat_penalty, repeat_last_n, n_threads) are included for interface
-            consistency but are not directly used in the Ollama API implementation.
-        """
-        # Set headers
-        headers = {
-            'Content-Type': 'application/json',
-        }
-        if self.service_key:
-            headers['Authorization'] = f'Bearer {self.service_key}'
-
-        # Clean host address
-        host_address = self.host_address.rstrip('/')
-
-        # Prepare data based on whether images are provided
-        if images:
-            # Multimodal generation using /api endpoint
-            images_list = [encode_image(image_path) for image_path in images]
-            data = {
-                'model': self.model_name,
-                'messages': [{
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt}
-                    ] + [
-                        {
-                            "type": "image_url",
-                            "image_url": {"url": f"data:image/jpeg;base64,{img}"}
-                        } for img in images_list
-                    ]
-                }],
-                "stream": stream,
-                "temperature": float(temperature),
-                "max_tokens": n_predict,
-            }
-            if ctx_size is not None:
-                data["num_ctx"] = ctx_size            
-            url = f'{host_address}/api/chat'
-        else:
-            # Text-only generation using /api/generate endpoint
-            data = {
-                'model': self.model_name,
-                'prompt': prompt,
-                "stream": stream,
-                "temperature": float(temperature),
-                "max_tokens": n_predict
-            }
-            url = f'{host_address}/api/generate'
-
-        # Make the request
-        response = requests.post(url, json=data, headers=headers, stream=stream)
-
-        # Handle response
-        if not stream:
-            if response.status_code == 200:
-                try:
-                    if images:
-                        # For multimodal, response is in chat format
-                        return response.json()["message"]["content"]
-                    else:
-                        # For text-only
-                        return response.json()["response"]
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            elif response.status_code == 404:
-                ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-                return {"status": False, "error": "404 Not Found"}
-            else:
-                return {"status": False, "error": response.text}
-        else:
-            text = ""
-            if response.status_code == 200:
-                try:
-                    for line in response.iter_lines():
-                        decoded = line.decode("utf-8")
-                        if images:
-                            # Streaming with images (chat format)
-                            if decoded.startswith("data: "):
-                                json_data = json.loads(decoded[5:].strip())
-                                chunk = json_data["message"]["content"] if "message" in json_data else ""
-                            else:
-                                continue
-                        else:
-                            # Streaming without images (generate format)
-                            json_data = json.loads(decoded)
-                            chunk = json_data["response"]
-                        
-                        text += chunk
-                        if streaming_callback:
-                            if not streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK):
-                                break
-                    return text
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            elif response.status_code == 404:
-                ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-                return {"status": False, "error": "404 Not Found"}
-            elif response.status_code == 400:
-                try:
-                    content = json.loads(response.content.decode("utf8"))
-                    return {"status": False, "error": content.get("error", {}).get("message", content.get("message", "Unknown error"))}
-                except:
-                    return {"status": False, "error": response.content.decode("utf8")}
-            else:
-                return {"status": False, "error": response.text}
-    
-    def tokenize(self, text: str) -> list:
-        """
-        Tokenize the input text into a list of characters.
-
-        Args:
-            text (str): The text to tokenize.
-
-        Returns:
-            list: List of individual characters.
-        """
-        return list(text)
-    
-    def detokenize(self, tokens: list) -> str:
-        """
-        Convert a list of tokens back to text.
-
-        Args:
-            tokens (list): List of tokens (characters) to detokenize.
-
-        Returns:
-            str: Detokenized text.
-        """
-        return "".join(tokens)
-    
-    def embed(self, text: str, **kwargs) -> list:
-        """
-        Get embeddings for the input text using Ollama API
-        
-        Args:
-            text (str or List[str]): Input text to embed
-            **kwargs: Additional arguments like model, truncate, options, keep_alive
-        
-        Returns:
-            dict: Response containing embeddings
-        """
-        import requests
-        
-        url = f"{self.base_url}/api/embed"
-        
-        # Prepare the request payload
-        payload = {
-            "input": text,
-            "model": kwargs.get("model", "llama2")  # default model
-        }
-        
-        # Add optional parameters if provided
-        if "truncate" in kwargs:
-            payload["truncate"] = kwargs["truncate"]
-        if "options" in kwargs:
-            payload["options"] = kwargs["options"]
-        if "keep_alive" in kwargs:
-            payload["keep_alive"] = kwargs["keep_alive"]
-        
-        try:
-            response = requests.post(url, json=payload)
-            response.raise_for_status()  # Raise exception for bad status codes
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            raise Exception(f"Embedding request failed: {str(e)}")  
-        
-
-    def get_model_info(self) -> dict:
-        """
-        Return information about the current Ollama model.
-
-        Returns:
-            dict: Dictionary containing model name, version, and host address.
-        """
-        return {
-            "name": "ollama",
-            "version": "2.0",
-            "host_address": self.host_address,
-            "model_name": self.model_name
-        }
-    def listModels(self):
-        """ Lists available models """
-        url = f'{self.host_address}/api/tags'
-        headers = {
-                    'accept': 'application/json',
-                    'Authorization': f'Bearer {self.service_key}'
-                }
-        response = requests.get(url, headers=headers, verify= self.verify_ssl_certificate)
-        try:
-            ASCIIColors.debug("Listing ollama models")
-            data = response.json()
-            model_info = []
-
-            for model in data['models']:
-                model_name = model['name']
-                owned_by = ""
-                created_datetime = model["modified_at"]
-                model_info.append({'model_name': model_name, 'owned_by': owned_by, 'created_datetime': created_datetime})
-
-            return model_info
-        except Exception as ex:
-            trace_exception(ex)
-            return []
-    def load_model(self, model_name: str) -> bool:
-        """
-        Load a specific model into the Ollama binding.
-
-        Args:
-            model_name (str): Name of the model to load.
-
-        Returns:
-            bool: True if model loaded successfully.
-        """
-        self.model = model_name
-        self.model_name = model_name
-        return True