lollms-client 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

lollms_client/tti_bindings/gemini/__init__.py

@@ -1,96 +1,149 @@
 # lollms_client/tti_bindings/gemini/__init__.py
 import sys
 from typing import Optional, List, Dict, Any, Union
+import os
 
 from lollms_client.lollms_tti_binding import LollmsTTIBinding
 from ascii_colors import trace_exception, ASCIIColors
-import json
+import math
 
+# --- SDK & Dependency Management ---
 try:
     import pipmaster as pm
-    # google-cloud-aiplatform is the main dependency for Vertex AI
-    pm.ensure_packages(['google-cloud-aiplatform', 'Pillow'])
+    # Ensure both potential SDKs and Pillow are available
+    pm.ensure_packages(['google-cloud-aiplatform', 'google-generativeai', 'Pillow'])
+except ImportError:
+    pass # pipmaster is optional
+
+# Attempt to import Vertex AI (google-cloud-aiplatform)
+try:
     import vertexai
     from vertexai.preview.vision_models import ImageGenerationModel
     from google.api_core import exceptions as google_exceptions
-    GEMINI_AVAILABLE = True
-except ImportError as e:
-    GEMINI_AVAILABLE = False
-    _gemini_installation_error = e
+    VERTEX_AI_AVAILABLE = True
+except ImportError:
+    VERTEX_AI_AVAILABLE = False
+
+# Attempt to import Gemini API (google-generativeai)
+try:
+    from google import genai
+    from google.genai import types as genai_types
+    GEMINI_API_AVAILABLE = True
+except ImportError:
+    GEMINI_API_AVAILABLE = False
 
 # Defines the binding name for the manager
 BindingName = "GeminiTTIBinding_Impl"
 
-# Known Imagen models on Vertex AI
-IMAGEN_MODELS = ["imagegeneration@006", "imagegeneration@005", "imagegeneration@002"]
+# Known Imagen models for each service
+IMAGEN_VERTEX_MODELS = ["imagegeneration@006", "imagegeneration@005", "imagegeneration@002"]
+IMAGEN_GEMINI_API_MODELS = ["imagen-3", "gemini-1.5-flash-preview-0514"] # Short names are often aliases
+GEMINI_API_KEY_ENV_VAR = "GEMINI_API_KEY"
 
 class GeminiTTIBinding_Impl(LollmsTTIBinding):
     """
-    Concrete implementation of LollmsTTIBinding for Google's Imagen models via Vertex AI.
+    Concrete implementation of LollmsTTIBinding for Google's Imagen models.
+    Supports both Vertex AI (project_id) and Gemini API (api_key) authentication.
     """
-    DEFAULT_CONFIG = {
-        "project_id": None,
-        "location": "us-central1",
-        "model_name": IMAGEN_MODELS[0],
-        "seed": -1, # -1 for random
-        "guidance_scale": 7.5,
-        "number_of_images": 1
-    }
-
-    def __init__(self, config: Optional[Dict[str, Any]] = None, **kwargs):
+    def __init__(self, **kwargs):
         """
-        Initialize the Gemini (Vertex AI Imagen) TTI binding.
+        Initialize the Gemini (Vertex AI / API) TTI binding.
 
         Args:
-            config (Optional[Dict[str, Any]]): Configuration dictionary. Overrides DEFAULT_CONFIG.
-            **kwargs: Catches other potential parameters.
+            **kwargs: Configuration parameters.
+                      - auth_method (str): "vertex_ai" or "api_key". (Required)
+                      - project_id (str): Google Cloud project ID (for vertex_ai).
+                      - location (str): Google Cloud region (for vertex_ai).
+                      - service_key (str): Gemini API Key (for api_key).
+                      - model_name (str): The Imagen model to use.
+                      - default_seed (int): Default seed for generation (-1 for random).
+                      - default_guidance_scale (float): Default guidance scale (CFG).
         """
         super().__init__(binding_name="gemini")
 
-        if not GEMINI_AVAILABLE:
-            raise ImportError(
-                "Gemini (Vertex AI) binding dependencies are not met. "
-                "Please ensure 'google-cloud-aiplatform' is installed. "
-                f"Error: {_gemini_installation_error}"
-            )
+        # Core settings
+        self.auth_method = kwargs.get("auth_method", "vertex_ai") # Default to vertex_ai for backward compatibility
+
+        # Vertex AI specific settings
+        self.project_id = kwargs.get("project_id")
+        self.location = kwargs.get("location", "us-central1")
+
+        # Gemini API specific settings
+        self.gemini_api_key = kwargs.get("service_key")
+
+        # Common settings
+        self.model_name = kwargs.get("model_name")
+        self.default_seed = int(kwargs.get("default_seed", -1))
+        self.default_guidance_scale = float(kwargs.get("default_guidance_scale", 7.5))
+        self.client_id = kwargs.get("client_id", "gemini_client_user")
         
-        self.config = {**self.DEFAULT_CONFIG, **(config or {}), **kwargs}
-        self.model: Optional[ImageGenerationModel] = None
+        # The actual client/model instance
+        self.client: Optional[Any] = None
+
+        # --- Validation and Initialization ---
+        if self.auth_method == "vertex_ai":
+            if not VERTEX_AI_AVAILABLE:
+                raise ImportError("Vertex AI authentication selected, but 'google-cloud-aiplatform' is not installed.")
+            if not self.project_id:
+                raise ValueError("For 'vertex_ai' auth, a Google Cloud 'project_id' is required.")
+            if not self.model_name:
+                self.model_name = IMAGEN_VERTEX_MODELS[0]
+        elif self.auth_method == "api_key":
+            if not GEMINI_API_AVAILABLE:
+                raise ImportError("API Key authentication selected, but 'google-generativeai' is not installed.")
+            
+            # Resolve API key from kwargs or environment variable
+            if not self.gemini_api_key:
+                ASCIIColors.info(f"API key not provided directly, checking environment variable '{GEMINI_API_KEY_ENV_VAR}'...")
+                self.gemini_api_key = os.environ.get(GEMINI_API_KEY_ENV_VAR)
+
+            if not self.gemini_api_key:
+                raise ValueError(f"For 'api_key' auth, a Gemini API Key is required. Provide it as 'service_key' or set the '{GEMINI_API_KEY_ENV_VAR}' environment variable.")
+
+            if not self.model_name:
+                self.model_name = IMAGEN_GEMINI_API_MODELS[0]
+        else:
+            raise ValueError(f"Invalid auth_method: '{self.auth_method}'. Must be 'vertex_ai' or 'api_key'.")
 
         self._initialize_client()
 
     def _initialize_client(self):
-        """Initializes the Vertex AI client and loads the model."""
-        project_id = self.config.get("project_id")
-        location = self.config.get("location")
-        model_name = self.config.get("model_name")
-
-        if not project_id:
-            raise ValueError("Google Cloud 'project_id' is required for the Gemini (Vertex AI) binding.")
-        
-        ASCIIColors.info("Initializing Vertex AI client...")
+        """Initializes the appropriate client based on the selected auth_method."""
+        ASCIIColors.info(f"Initializing Google client with auth method: '{self.auth_method}'...")
         try:
-            vertexai.init(project=project_id, location=location)
-            self.model = ImageGenerationModel.from_pretrained(model_name)
-            ASCIIColors.green(f"Vertex AI initialized successfully. Loaded model: {model_name}")
+            if self.auth_method == "vertex_ai":
+                vertexai.init(project=self.project_id, location=self.location)
+                self.client = ImageGenerationModel.from_pretrained(self.model_name)
+                ASCIIColors.green(f"Vertex AI initialized successfully. Project: '{self.project_id}', Model: '{self.model_name}'")
+            elif self.auth_method == "api_key":
+                genai.configure(api_key=self.gemini_api_key)
+                # For the genai SDK, the "client" is the configured module itself,
+                # and we specify the model per-call. Let's store the genai module.
+                self.client = genai
+                ASCIIColors.green(f"Gemini API configured successfully. Model to be used: '{self.model_name}'")
         except google_exceptions.PermissionDenied as e:
             trace_exception(e)
             raise Exception(
-                "Authentication failed. Ensure you have run 'gcloud auth application-default login' "
-                "and that the Vertex AI API is enabled for your project."
+                "Authentication failed. For Vertex AI, run 'gcloud auth application-default login'. For API Key, check if the key is valid and has permissions."
             ) from e
         except Exception as e:
             trace_exception(e)
-            raise Exception(f"Failed to initialize Vertex AI client: {e}") from e
+            raise Exception(f"Failed to initialize Google client: {e}") from e
+
+    def _validate_dimensions_vertex(self, width: int, height: int) -> None:
+        """Validates image dimensions against Vertex AI Imagen constraints."""
+        if not (256 <= width <= 1536 and width % 8 == 0):
+            raise ValueError(f"Invalid width for Vertex AI: {width}. Must be 256-1536 and a multiple of 8.")
+        if not (256 <= height <= 1536 and height % 8 == 0):
+            raise ValueError(f"Invalid height for Vertex AI: {height}. Must be 256-1536 and a multiple of 8.")
 
-    def _validate_dimensions(self, width: int, height: int) -> None:
-        """Validates image dimensions against Imagen 2 constraints."""
-        if not (256 <= width <= 1536 and width % 64 == 0):
-            raise ValueError(f"Invalid width: {width}. Must be between 256 and 1536 and a multiple of 64.")
-        if not (256 <= height <= 1536 and height % 64 == 0):
-            raise ValueError(f"Invalid height: {height}. Must be between 256 and 1536 and a multiple of 64.")
-        if width * height > 1536 * 1536: # Max pixels might be more constrained, 1536*1536 is a safe upper bound.
-             raise ValueError(f"Invalid dimensions: {width}x{height}. The total number of pixels cannot exceed 1536*1536.")
+    def _get_aspect_ratio_for_api(self, width: int, height: int) -> str:
+        """Finds the closest supported aspect ratio string for the Gemini API."""
+        ratios = {"1:1": 1.0, "16:9": 16/9, "9:16": 9/16, "4:3": 4/3, "3:4": 3/4}
+        target_ratio = width / height
+        closest_ratio_name = min(ratios, key=lambda r: abs(ratios[r] - target_ratio))
+        ASCIIColors.info(f"Converted {width}x{height} to closest aspect ratio: '{closest_ratio_name}' for Gemini API.")
+        return closest_ratio_name
 
     def generate_image(self,
                        prompt: str,
@@ -99,117 +152,169 @@ class GeminiTTIBinding_Impl(LollmsTTIBinding):
                        height: int = 1024,
                        **kwargs) -> bytes:
         """
-        Generates image data using the Vertex AI Imagen model.
-
-        Args:
-            prompt (str): The positive text prompt.
-            negative_prompt (Optional[str]): The negative prompt.
-            width (int): Image width. Must be 256-1536 and a multiple of 64.
-            height (int): Image height. Must be 256-1536 and a multiple of 64.
-            **kwargs: Additional parameters:
-                      - seed (int)
-                      - guidance_scale (float)
-        Returns:
-            bytes: The generated image data (PNG format).
-        Raises:
-            Exception: If the request fails or image generation fails.
+        Generates image data using the configured Google Imagen model.
         """
-        if not self.model:
-            raise RuntimeError("Vertex AI model is not loaded. Cannot generate image.")
-
-        self._validate_dimensions(width, height)
+        if not self.client:
+            raise RuntimeError("Google client is not initialized. Cannot generate image.")
 
-        seed = kwargs.get("seed", self.config["seed"])
-        guidance_scale = kwargs.get("guidance_scale", self.config["guidance_scale"])
-        
-        # Use -1 for random seed, otherwise pass the integer value.
+        # Use overrides from kwargs, otherwise instance defaults
+        seed = kwargs.get("seed", self.default_seed)
+        guidance_scale = kwargs.get("guidance_scale", self.default_guidance_scale)
         gen_seed = seed if seed != -1 else None
 
-        gen_params = {
-            "prompt": prompt,
-            "negative_prompt": negative_prompt,
-            "number_of_images": 1, # This binding returns one image
-            "width": width,
-            "height": height,
-            "guidance_scale": guidance_scale,
-        }
-        if gen_seed is not None:
-            gen_params["seed"] = gen_seed
+        final_prompt = prompt
+        if negative_prompt:
+            final_prompt = f"{prompt}. Do not include: {negative_prompt}."
 
-        ASCIIColors.info(f"Generating image with prompt: '{prompt[:100]}...'")
-        ASCIIColors.debug(f"Imagen generation parameters: {gen_params}")
+        ASCIIColors.info(f"Generating image with prompt: '{final_prompt[:100]}...'")
 
         try:
-            response = self.model.generate_images(**gen_params)
-            
-            if not response.images:
-                raise Exception("Image generation resulted in no images. This may be due to safety filters.")
+            if self.auth_method == "vertex_ai":
+                self._validate_dimensions_vertex(width, height)
+                gen_params = {
+                    "prompt": final_prompt,
+                    "number_of_images": 1,
+                    "width": width,
+                    "height": height,
+                    "guidance_scale": guidance_scale,
+                }
+                if gen_seed is not None:
+                    gen_params["seed"] = gen_seed
+                
+                ASCIIColors.debug(f"Vertex AI generation parameters: {gen_params}")
+                response = self.client.generate_images(**gen_params)
+                
+                if not response.images:
+                    raise Exception("Image generation resulted in no images (Vertex AI). Check safety filters.")
+                
+                return response.images[0]._image_bytes
 
-            img_bytes = response.images[0]._image_bytes
-            return img_bytes
+            elif self.auth_method == "api_key":
+                aspect_ratio = self._get_aspect_ratio_for_api(width, height)
+                gen_params = {
+                    "model": self.model_name,
+                    "prompt": final_prompt,
+                    "number_of_images": 1,
+                    "aspect_ratio": aspect_ratio
+                    # Note: seed and guidance_scale are not standard in this simpler API call
+                }
+                ASCIIColors.debug(f"Gemini API generation parameters: {gen_params}")
+                response = self.client.generate_image(**gen_params)
 
-        except google_exceptions.InvalidArgument as e:
+                if not response.images:
+                    raise Exception("Image generation resulted in no images (Gemini API). Check safety filters.")
+
+                return response.images[0].image_bytes
+
+        except (google_exceptions.InvalidArgument, AttributeError) as e:
             trace_exception(e)
-            raise ValueError(f"Invalid argument sent to Vertex AI API: {e.message}") from e
+            raise ValueError(f"Invalid argument sent to Google API: {e}") from e
         except google_exceptions.GoogleAPICallError as e:
             trace_exception(e)
-            raise Exception(f"A Google API call error occurred: {e.message}") from e
+            raise Exception(f"A Google API call error occurred: {e}") from e
         except Exception as e:
             trace_exception(e)
             raise Exception(f"Imagen image generation failed: {e}") from e
 
     def list_services(self, **kwargs) -> List[Dict[str, str]]:
-        """
-        Lists available Imagen models supported by this binding.
-        """
-        services = []
-        for model_name in IMAGEN_MODELS:
-            services.append({
-                "name": model_name,
-                "caption": f"Google Imagen 2 ({model_name})",
-                "help": "High-quality text-to-image model from Google, available on Vertex AI."
-            })
-        return services
+        """Lists available Imagen models for the current auth method."""
+        models = IMAGEN_VERTEX_MODELS if self.auth_method == "vertex_ai" else IMAGEN_GEMINI_API_MODELS
+        service_name = "Vertex AI" if self.auth_method == "vertex_ai" else "Gemini API"
+        return [
+            {
+                "name": name,
+                "caption": f"Google Imagen ({name}) via {service_name}",
+                "help": "High-quality text-to-image model from Google."
+            } for name in models
+        ]
 
     def get_settings(self, **kwargs) -> List[Dict[str, Any]]:
-        """
-        Retrieves the current configurable settings for the binding.
-        """
-        return [
-            {"name": "project_id", "type": "str", "value": self.config["project_id"], "description": "Your Google Cloud project ID."},
-            {"name": "location", "type": "str", "value": self.config["location"], "description": "Google Cloud region for the project (e.g., 'us-central1')."},
-            {"name": "model_name", "type": "str", "value": self.config["model_name"], "description": "The Imagen model version to use.", "options": IMAGEN_MODELS},
-            {"name": "seed", "type": "int", "value": self.config["seed"], "description": "Default seed for generation (-1 for random)."},
-            {"name": "guidance_scale", "type": "float", "value": self.config["guidance_scale"], "description": "Default guidance scale (CFG). Higher values follow the prompt more strictly."},
+        """Retrieves the current configurable settings for the binding."""
+        settings = [
+            {"name": "auth_method", "type": "str", "value": self.auth_method, "description": "Authentication method to use.", "options": ["vertex_ai", "api_key"], "category": "Authentication"},
         ]
+        if self.auth_method == "vertex_ai":
+            settings.extend([
+                {"name": "project_id", "type": "str", "value": self.project_id, "description": "Your Google Cloud project ID.", "category": "Authentication"},
+                {"name": "location", "type": "str", "value": self.location, "description": "Google Cloud region (e.g., 'us-central1').", "category": "Authentication"},
+                {"name": "model_name", "type": "str", "value": self.model_name, "description": "Default Imagen model for generation.", "options": IMAGEN_VERTEX_MODELS, "category": "Model Configuration"},
+            ])
+        elif self.auth_method == "api_key":
+            settings.extend([
+                {"name": "api_key_status", "type": "str", "value": "Set" if self.gemini_api_key else "Not Set", "description": f"Gemini API Key status (set at initialization via service_key or '{GEMINI_API_KEY_ENV_VAR}').", "category": "Authentication", "read_only": True},
+                {"name": "model_name", "type": "str", "value": self.model_name, "description": "Default Imagen model for generation.", "options": IMAGEN_GEMINI_API_MODELS, "category": "Model Configuration"},
+            ])
+        
+        settings.extend([
+            {"name": "default_seed", "type": "int", "value": self.default_seed, "description": "Default seed (-1 for random).", "category": "Image Generation Defaults"},
+            {"name": "default_guidance_scale", "type": "float", "value": self.default_guidance_scale, "description": "Default guidance scale (CFG). (Vertex AI only)", "category": "Image Generation Defaults"},
+        ])
+        return settings
 
     def set_settings(self, settings: Union[Dict[str, Any], List[Dict[str, Any]]], **kwargs) -> bool:
-        """
-        Applies new settings to the binding. Re-initializes the client if needed.
-        """
-        if isinstance(settings, list):
-            parsed_settings = {item["name"]: item["value"] for item in settings if "name" in item and "value" in item}
-        elif isinstance(settings, dict):
-            parsed_settings = settings
-        else:
-            ASCIIColors.error("Invalid settings format. Expected a dictionary or list of dictionaries.")
-            return False
+        """Applies new settings. Re-initializes the client if core settings change."""
+        applied_some_settings = False
+        settings_dict = {item["name"]: item["value"] for item in settings} if isinstance(settings, list) else settings
 
         needs_reinit = False
-        for key, value in parsed_settings.items():
-            if key in self.config and self.config[key] != value:
-                self.config[key] = value
-                ASCIIColors.info(f"Setting '{key}' changed to: {value}")
-                if key in ["project_id", "location", "model_name"]:
-                    needs_reinit = True
         
+        # Phase 1: Check for auth_method or core credential changes
+        if "auth_method" in settings_dict and self.auth_method != settings_dict["auth_method"]:
+            self.auth_method = settings_dict["auth_method"]
+            ASCIIColors.info(f"Authentication method changed to: {self.auth_method}")
+            # Reset model to a valid default for the new method
+            if self.auth_method == "vertex_ai":
+                self.model_name = IMAGEN_VERTEX_MODELS[0]
+            else:
+                self.model_name = IMAGEN_GEMINI_API_MODELS[0]
+            ASCIIColors.info(f"Model name reset to default for new auth method: {self.model_name}")
+            needs_reinit = True
+            applied_some_settings = True
+        
+        if self.auth_method == "vertex_ai":
+            if "project_id" in settings_dict and self.project_id != settings_dict["project_id"]:
+                self.project_id = settings_dict["project_id"]
+                needs_reinit = True; applied_some_settings = True
+            if "location" in settings_dict and self.location != settings_dict["location"]:
+                self.location = settings_dict["location"]
+                needs_reinit = True; applied_some_settings = True
+        # API key is not settable after init, so we don't check for it here.
+
+        # Phase 2: Apply other settings
+        current_models = IMAGEN_VERTEX_MODELS if self.auth_method == "vertex_ai" else IMAGEN_GEMINI_API_MODELS
+        if "model_name" in settings_dict:
+            new_model = settings_dict["model_name"]
+            if new_model not in current_models:
+                ASCIIColors.warning(f"Invalid model '{new_model}' for auth method '{self.auth_method}'. Keeping '{self.model_name}'.")
+            elif self.model_name != new_model:
+                self.model_name = new_model
+                needs_reinit = True; applied_some_settings = True
+
+        if "default_seed" in settings_dict and self.default_seed != int(settings_dict["default_seed"]):
+            self.default_seed = int(settings_dict["default_seed"])
+            applied_some_settings = True
+        if "default_guidance_scale" in settings_dict and self.default_guidance_scale != float(settings_dict["default_guidance_scale"]):
+            self.default_guidance_scale = float(settings_dict["default_guidance_scale"])
+            applied_some_settings = True
+
+        # Phase 3: Re-initialize if needed
         if needs_reinit:
             try:
                 self._initialize_client()
-                ASCIIColors.green("Vertex AI client re-initialized successfully with new settings.")
             except Exception as e:
                 ASCIIColors.error(f"Failed to re-initialize client with new settings: {e}")
-                # Optionally, revert to old config here to maintain a working state
                 return False
         
-        return True
+        return applied_some_settings
+
+    def listModels(self) -> list:
+        """Lists available Imagen models in a standardized format."""
+        models = IMAGEN_VERTEX_MODELS if self.auth_method == "vertex_ai" else IMAGEN_GEMINI_API_MODELS
+        return [
+            {
+                'model_name': name,
+                'display_name': f"Imagen ({name})",
+                'description': f"Google's Imagen model, version {name}",
+                'owned_by': 'Google'
+            } for name in models
+        ]

{lollms_client-1.0.0.dist-info → lollms_client-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.0.0
+Version: 1.1.0
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License

{lollms_client-1.0.0.dist-info → lollms_client-1.1.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
-lollms_client/__init__.py,sha256=TB277pr7BJ2eH1ezWZ-B0_8lxMBqjQYPhc2jUJLOASg,1146
+lollms_client/__init__.py,sha256=FmmUQyLm9hgGyCc71AtEoRRxx-YfI8Gl_4H7k3VRFpI,1146
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=68EFgqGyw0cpJQOhJZrRzogd20j1zSghwLBie6kyJGI,167221
+lollms_client/lollms_core.py,sha256=zqaxEJJDXiwpDd3E-PFDLJOnmG1d9cOiL_CrYRUa7Z0,167361
 lollms_client/lollms_discussion.py,sha256=wkadV6qiegxOzukMVn5vukdeJivnlyygSzZBkzOi9Gc,106714
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
-lollms_client/lollms_llm_binding.py,sha256=TBdFNNktpIUSUd4mlUHeNUPUQeLRWKBj80UTJ-YdwBg,24940
+lollms_client/lollms_llm_binding.py,sha256=EJGIKb_a3sVEia5zxs_EcOl21xmfJV8JzyY3sfymSBw,24984
 lollms_client/lollms_mcp_binding.py,sha256=psb27A23VFWDfZsR2WUbQXQxiZDW5yfOak6ZtbMfszI,10222
 lollms_client/lollms_mcp_security.py,sha256=FhVTDhSBjksGEZnopVnjFmEF5dv7D8bBTqoaj4BiF0E,3562
 lollms_client/lollms_personality.py,sha256=O-9nqZhazcITOkxjT24ENTxTmIoZLgqIsQ9WtWs0Id0,8719
 lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
 lollms_client/lollms_stt_binding.py,sha256=jAUhLouEhh2hmm1bK76ianfw_6B59EHfY3FmLv6DU-g,5111
-lollms_client/lollms_tti_binding.py,sha256=afO0-d-Kqsmh8UHTijTvy6dZAt-XDB6R-IHmdbf-_fs,5928
+lollms_client/lollms_tti_binding.py,sha256=zsKA8K4E54n_60wKjRIwLxEetKAI_IAggQUzkpip5YE,10406
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
 lollms_client/lollms_tts_binding.py,sha256=5cJYECj8PYLJAyB6SEH7_fhHYK3Om-Y3arkygCnZ24o,4342
 lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7DjOsjWQ,4131
@@ -47,9 +47,9 @@ lollms_client/stt_bindings/lollms/__init__.py,sha256=9Vmn1sQQZKLGLe7nZnc-0LnNeSY
 lollms_client/stt_bindings/whisper/__init__.py,sha256=1Ej67GdRKBy1bba14jMaYDYHiZkxJASkWm5eF07ztDQ,15363
 lollms_client/stt_bindings/whispercpp/__init__.py,sha256=xSAQRjAhljak3vWCpkP0Vmdb6WmwTzPjXyaIB85KLGU,21439
 lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client/tti_bindings/dalle/__init__.py,sha256=KWUow9z-xR_am_gHg3kGZ_5u_nnF88BB_0JvyfuOG_s,23456
-lollms_client/tti_bindings/diffusers/__init__.py,sha256=vjzuJfOAIhoiwomuIZvWpxmcM5UxpTwqTbD04E-zi3Y,37786
-lollms_client/tti_bindings/gemini/__init__.py,sha256=iFJMAR944nRDhXA7SdFjsCOqJ1dPSqyTG4eMFNg6Vwc,9734
+lollms_client/tti_bindings/dalle/__init__.py,sha256=1nE36XamKEJOMpm6QUow8OyM1KdpejCLM0KUSXlcePo,24135
+lollms_client/tti_bindings/diffusers/__init__.py,sha256=OQOHE1WtB4TamsWd17EEL4NOdxIIonDqDMS_xaONUSI,23510
+lollms_client/tti_bindings/gemini/__init__.py,sha256=f9fPuqnrBZ1Z-obcoP6EVvbEXNbNCSg21cd5efLCk8U,16707
 lollms_client/tti_bindings/lollms/__init__.py,sha256=5Tnsn4b17djvieQkcjtIDBm3qf0pg5ZWWov-4_2wmo0,8762
 lollms_client/ttm_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/ttm_bindings/audiocraft/__init__.py,sha256=a0k6wTrHth6GaVOiNnVboeFY3oKVvCQPbQlqO38XEyc,14328
@@ -62,8 +62,8 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5
 lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-1.0.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.0.0.dist-info/METADATA,sha256=qqfmnRtnMRYdgvQTzwjlh8v_lAaOGPJ5H0Sf-X3j1dk,58549
-lollms_client-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.0.0.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.0.0.dist-info/RECORD,,
+lollms_client-1.1.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.1.0.dist-info/METADATA,sha256=_frP9CKjj2dGhIX57fY7NLo9z0-Bfc449rznQMOUSGs,58549
+lollms_client-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.1.0.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.1.0.dist-info/RECORD,,