autobyteus 1.1.5__py3-none-any.whl → 1.1.7__py3-none-any.whl

autobyteus/multimedia/image/api/autobyteus_image_client.py

@@ -0,0 +1,97 @@
+import logging
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+from autobyteus_llm_client import AutobyteusClient
+from autobyteus.multimedia.image.base_image_client import BaseImageClient
+from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.image.image_model import ImageModel
+    from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+logger = logging.getLogger(__name__)
+
+class AutobyteusImageClient(BaseImageClient):
+    """
+    An image client that connects to an Autobyteus LLM server instance for image tasks.
+    """
+
+    def __init__(self, model: "ImageModel", config: "MultimediaConfig"):
+        super().__init__(model, config)
+        if not model.host_url:
+            raise ValueError("AutobyteusImageClient requires a host_url in its ImageModel.")
+        
+        self.autobyteus_client = AutobyteusClient(server_url=model.host_url)
+        logger.info(f"AutobyteusImageClient initialized for model '{self.model.name}' on host '{model.host_url}'.")
+
+    async def generate_image(
+        self,
+        prompt: str,
+        input_image_urls: Optional[List[str]] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Generates an image by calling the generate_image endpoint on the remote Autobyteus server.
+        """
+        # The remote server handles both generation and editing through one endpoint.
+        # This method is a unified entry point.
+        return await self._call_remote_generate(
+            prompt=prompt,
+            input_image_urls=input_image_urls,
+            mask_url=None, # Not used in pure generation
+            generation_config=generation_config
+        )
+
+    async def edit_image(
+        self,
+        prompt: str,
+        input_image_urls: List[str],
+        mask_url: Optional[str] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Edits an image by calling the generate_image endpoint on the remote Autobyteus server.
+        """
+        return await self._call_remote_generate(
+            prompt=prompt,
+            input_image_urls=input_image_urls,
+            mask_url=mask_url,
+            generation_config=generation_config
+        )
+    
+    async def _call_remote_generate(
+        self,
+        prompt: str,
+        input_image_urls: Optional[List[str]],
+        mask_url: Optional[str],
+        generation_config: Optional[Dict[str, Any]]
+    ) -> ImageGenerationResponse:
+        """Internal helper to call the remote server."""
+        try:
+            logger.info(f"Sending image generation request for model '{self.model.name}' to {self.model.host_url}")
+            
+            # The model name for the remote server is the `value`, not the unique `model_identifier`
+            model_name_for_server = self.model.name
+
+            response_data = await self.autobyteus_client.generate_image(
+                model_name=model_name_for_server,
+                prompt=prompt,
+                input_image_urls=input_image_urls,
+                mask_url=mask_url,
+                generation_config=generation_config
+            )
+            
+            image_urls = response_data.get("image_urls", [])
+            if not image_urls:
+                raise ValueError("Remote Autobyteus server did not return any image URLs.")
+                
+            return ImageGenerationResponse(image_urls=image_urls)
+            
+        except Exception as e:
+            logger.error(f"Error calling Autobyteus server for image generation: {e}")
+            raise
+
+    async def cleanup(self):
+        """Closes the underlying AutobyteusClient."""
+        if self.autobyteus_client:
+            await self.autobyteus_client.close()
+        logger.debug("AutobyteusImageClient cleaned up.")

autobyteus/multimedia/image/api/gemini_image_client.py

@@ -0,0 +1,188 @@
+import asyncio
+import base64
+import logging
+import mimetypes
+import os
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+
+# ✅ Legacy Gemini SDK (as requested)
+import google.generativeai as genai
+import requests
+
+from autobyteus.multimedia.image.base_image_client import BaseImageClient
+from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.image.image_model import ImageModel
+    from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+logger = logging.getLogger(__name__)
+
+
+def _data_uri(mime_type: str, raw: bytes) -> str:
+    """Convert raw bytes to a data URI."""
+    b64 = base64.b64encode(raw).decode("utf-8")
+    return f"data:{mime_type};base64,{b64}"
+
+
+def _guess_mime_from_url(url: str) -> str:
+    """Best-effort MIME guess from URL; fall back to image/jpeg."""
+    mime, _ = mimetypes.guess_type(url)
+    return mime or "image/jpeg"
+
+
+def _fetch_image_part(url: str) -> Dict[str, Any]:
+    """
+    Download an image and return an inline-data Part compatible with the legacy SDK:
+    { "mime_type": "...", "data": <bytes> }
+    """
+    resp = requests.get(url, timeout=30)
+    resp.raise_for_status()
+    mime = resp.headers.get("Content-Type") or _guess_mime_from_url(url)
+    return {"mime_type": mime.split(";")[0], "data": resp.content}
+
+
+def _extract_inline_images(response) -> List[Dict[str, bytes]]:
+    """
+    Collect inline image parts from the legacy SDK response.
+    Returns list of { "mime_type": str, "data": bytes }.
+    """
+    images = []
+    try:
+        candidates = getattr(response, "candidates", []) or []
+        if not candidates:
+            return images
+
+        parts = candidates[0].content.parts if candidates[0].content else []
+        for p in parts:
+            inline = getattr(p, "inline_data", None)
+            if not inline:
+                continue
+            mime = getattr(inline, "mime_type", "") or ""
+            if not mime.startswith("image/"):
+                continue
+
+            data = getattr(inline, "data", None)
+            if isinstance(data, bytes):
+                images.append({"mime_type": mime, "data": data})
+            elif isinstance(data, str):
+                # Some bindings expose base64 text
+                images.append({"mime_type": mime, "data": base64.b64decode(data)})
+    except Exception as e:
+        logger.error("Failed to parse inline image(s): %s", e)
+        raise
+    return images
+
+
+class GeminiImageClient(BaseImageClient):
+    """
+    Image generation client using Google's legacy SDK (`google.generativeai`).
+
+    Notes:
+      - We configure `response_mime_type='image/png'` to request image output.
+      - You can guide generation with input images by passing URLs; they’re added as inline image Parts.
+      - This runs the blocking SDK call in a worker thread to keep your async API.
+    """
+
+    def __init__(self, model: "ImageModel", config: "MultimediaConfig"):
+        super().__init__(model, config)
+
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("Please set the GEMINI_API_KEY environment variable.")
+
+        try:
+            genai.configure(api_key=api_key)
+            # `self.model.value` should be an image-capable model.
+            # Examples (subject to availability): "imagen-3.0-generate", "imagen-3.0-fast",
+            # or Gemini image-preview models that support image output.
+            model_name = self.model.value or "imagen-3.0-generate"
+            self._model = genai.GenerativeModel(model_name)
+            logger.info("GeminiImageClient (legacy SDK) initialized for model '%s'.", model_name)
+        except Exception as e:
+            logger.error("Failed to initialize Gemini image client: %s", e)
+            raise RuntimeError(f"Failed to initialize Gemini image client: {e}")
+
+    async def generate_image(
+        self,
+        prompt: str,
+        input_image_urls: Optional[List[str]] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Generate an image (text→image or image-guided).
+
+        `generation_config` supports common fields; we always ensure
+        `response_mime_type='image/png'` so the SDK returns inline image bytes.
+        """
+        try:
+            logger.info("Generating image with model '%s'...", self._model.model_name)
+
+            # Build contents array: [text, (optional) image parts...]
+            contents: List[Any] = [prompt]
+
+            if input_image_urls:
+                logger.info("Loading %d input image(s) for guidance...", len(input_image_urls))
+                for url in input_image_urls:
+                    try:
+                        contents.append(_fetch_image_part(url))
+                    except Exception as e:
+                        logger.error("Skipping image '%s' due to error: %s", url, e)
+
+            # Merge config and force image output
+            gen_cfg: Dict[str, Any] = (generation_config or {}).copy()
+            gen_cfg["response_mime_type"] = gen_cfg.get("response_mime_type", "image/png")
+
+            # Call the (sync) SDK in a worker thread
+            response = await asyncio.to_thread(
+                self._model.generate_content,
+                contents,
+                generation_config=gen_cfg,
+            )
+
+            # Handle safety blocks if present
+            feedback = getattr(response, "prompt_feedback", None)
+            block_reason = getattr(feedback, "block_reason", None)
+            if block_reason:
+                reason = getattr(block_reason, "name", str(block_reason))
+                logger.error("Image generation blocked by safety settings: %s", reason)
+                raise ValueError(f"Image generation failed due to safety settings: {reason}")
+
+            images = _extract_inline_images(response)
+            if not images:
+                logger.warning("No image parts returned for prompt: '%.100s...'", prompt)
+                raise ValueError("Gemini API did not return any images.")
+
+            image_urls = [_data_uri(img["mime_type"], img["data"]) for img in images]
+            logger.info("Successfully generated %d image(s).", len(image_urls))
+
+            return ImageGenerationResponse(
+                image_urls=image_urls,
+                revised_prompt=None  # legacy SDK does not provide a revised prompt here
+            )
+
+        except Exception as e:
+            logger.error("Error during Gemini image generation (legacy SDK): %s", e)
+            # Region support / feature gating errors sometimes include 'Unsupported' hints.
+            if "Unsupported" in str(e) and "location" in str(e):
+                raise ValueError(
+                    "Image generation may not be supported in your configured region or project. "
+                    "Check your API access and region settings."
+                )
+            raise ValueError(f"Google Gemini image generation failed: {str(e)}")
+
+    async def edit_image(
+        self,
+        prompt: str,
+        input_image_urls: List[str],
+        mask_url: Optional[str] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Image editing/redraw with masks isn’t exposed via this legacy path here.
+        """
+        logger.error("Image editing is not supported by the GeminiImageClient (legacy SDK).")
+        raise NotImplementedError("The GeminiImageClient does not support the edit_image method.")
+
+    async def cleanup(self):
+        logger.debug("GeminiImageClient cleanup called (legacy SDK; nothing to release).")

autobyteus/multimedia/image/api/openai_image_client.py

@@ -0,0 +1,142 @@
+import logging
+import os
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+from openai import OpenAI
+from autobyteus.multimedia.image.base_image_client import BaseImageClient
+from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.image.image_model import ImageModel
+    from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+logger = logging.getLogger(__name__)
+
+class OpenAIImageClient(BaseImageClient):
+    """
+    An image client that uses OpenAI's DALL-E models.
+    """
+
+    def __init__(self, model: "ImageModel", config: "MultimediaConfig"):
+        super().__init__(model, config)
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            logger.error("OPENAI_API_KEY environment variable is not set.")
+            raise ValueError("OPENAI_API_KEY environment variable is not set.")
+
+        self.client = OpenAI(api_key=api_key, base_url="https://api.openai.com/v1")
+        logger.info(f"OpenAIImageClient initialized for model '{self.model.name}'.")
+
+    async def generate_image(
+        self,
+        prompt: str,
+        input_image_urls: Optional[List[str]] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Generates an image using an OpenAI DALL-E model via the v1/images/generations endpoint.
+        Note: This endpoint does not support image inputs, even for multimodal models like gpt-image-1.
+        """
+        if input_image_urls:
+            logger.warning(
+                f"The OpenAI `images.generate` API used by this client does not support input images. "
+                f"The images provided for model '{self.model.value}' will be ignored. "
+                f"To use image inputs, a client based on the Chat Completions API is required."
+            )
+
+        try:
+            image_model = self.model.value
+            logger.info(f"Generating image with OpenAI model '{image_model}' and prompt: '{prompt[:50]}...'")
+
+            # Combine default config with any overrides
+            final_config = self.config.to_dict().copy()
+            if generation_config:
+                final_config.update(generation_config)
+
+            response = self.client.images.generate(
+                model=image_model,
+                prompt=prompt,
+                n=final_config.get("n", 1),
+                size=final_config.get("size", "1024x1024"),
+                quality=final_config.get("quality", "standard"),
+                style=final_config.get("style", "vivid"),
+                response_format="url"
+            )
+
+            image_urls_list: List[str] = [img.url for img in response.data if img.url]
+            revised_prompt: Optional[str] = response.data[0].revised_prompt if response.data and hasattr(response.data[0], 'revised_prompt') else None
+
+            if not image_urls_list:
+                raise ValueError("OpenAI API did not return any image URLs.")
+
+            logger.info(f"Successfully generated {len(image_urls_list)} image(s).")
+
+            return ImageGenerationResponse(
+                image_urls=image_urls_list,
+                revised_prompt=revised_prompt
+            )
+        except Exception as e:
+            logger.error(f"Error during OpenAI image generation: {str(e)}")
+            raise ValueError(f"OpenAI image generation failed: {str(e)}")
+
+    async def edit_image(
+        self,
+        prompt: str,
+        input_image_urls: List[str],
+        mask_url: Optional[str] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Edits an image using an OpenAI model that supports the v1/images/edits endpoint.
+        """
+        if not input_image_urls:
+            raise ValueError("At least one input image URL must be provided for editing.")
+
+        source_image_url = input_image_urls[0]
+        if len(input_image_urls) > 1:
+            logger.warning(f"OpenAI edit endpoint only supports one input image. Using '{source_image_url}' and ignoring the rest.")
+
+        try:
+            logger.info(f"Editing image '{source_image_url}' with prompt: '{prompt[:50]}...'")
+
+            # Combine default config with any overrides
+            final_config = self.config.to_dict().copy()
+            if generation_config:
+                final_config.update(generation_config)
+
+            with open(source_image_url, "rb") as image_file:
+                mask_file = open(mask_url, "rb") if mask_url else None
+                try:
+                    response = self.client.images.edit(
+                        image=image_file,
+                        mask=mask_file,
+                        prompt=prompt,
+                        model=self.model.value,
+                        n=final_config.get("n", 1),
+                        size=final_config.get("size", "1024x1024"),
+                        response_format="url"
+                    )
+                finally:
+                    if mask_file:
+                        mask_file.close()
+
+            image_urls_list: List[str] = [img.url for img in response.data if img.url]
+            if not image_urls_list:
+                raise ValueError("OpenAI API did not return any edited image URLs.")
+
+            logger.info(f"Successfully edited image, generated {len(image_urls_list)} version(s).")
+            return ImageGenerationResponse(image_urls=image_urls_list)
+
+        except FileNotFoundError as e:
+            logger.error(f"Image file not found for editing: {e.filename}")
+            raise
+        except Exception as e:
+            logger.error(f"Error during OpenAI image editing: {str(e)}")
+            # The API might return a 400 Bad Request if the model doesn't support edits
+            if "does not support image editing" in str(e):
+                raise ValueError(f"The model '{self.model.value}' does not support the image editing endpoint.")
+            raise ValueError(f"OpenAI image editing failed: {str(e)}")
+
+
+    async def cleanup(self):
+        # The OpenAI client does not require explicit cleanup of a session.
+        logger.debug("OpenAIImageClient cleanup called.")

autobyteus/multimedia/image/autobyteus_image_provider.py

@@ -0,0 +1,109 @@
+import logging
+from typing import Dict, Any, List
+import os
+from urllib.parse import urlparse
+
+from autobyteus_llm_client import AutobyteusClient
+from autobyteus.multimedia.image.api.autobyteus_image_client import AutobyteusImageClient
+from autobyteus.multimedia.image.image_model import ImageModel
+from autobyteus.multimedia.providers import MultimediaProvider
+from autobyteus.multimedia.runtimes import MultimediaRuntime
+
+logger = logging.getLogger(__name__)
+
+class AutobyteusImageModelProvider:
+    """
+    Discovers and registers image models from remote Autobyteus server instances.
+    """
+    DEFAULT_SERVER_URL = 'http://localhost:8000'
+
+    @staticmethod
+    def _get_hosts() -> List[str]:
+        """Gets Autobyteus server hosts from env vars."""
+        hosts_str = os.getenv('AUTOBYTEUS_LLM_SERVER_HOSTS')
+        if hosts_str:
+            return [host.strip() for host in hosts_str.split(',')]
+        
+        legacy_host = os.getenv('AUTOBYTEUS_LLM_SERVER_URL')
+        if legacy_host:
+            return [legacy_host]
+            
+        return [AutobyteusImageModelProvider.DEFAULT_SERVER_URL]
+
+    @staticmethod
+    def discover_and_register():
+        """Discover and register image models from all configured hosts."""
+        try:
+            from autobyteus.multimedia.image.image_client_factory import ImageClientFactory
+
+            hosts = AutobyteusImageModelProvider._get_hosts()
+            total_registered_count = 0
+
+            for host_url in hosts:
+                if not AutobyteusImageModelProvider.is_valid_url(host_url):
+                    logger.error(f"Invalid Autobyteus host URL for image model discovery: {host_url}, skipping.")
+                    continue
+                
+                logger.info(f"Discovering image models from host: {host_url}")
+                client = None
+                try:
+                    client = AutobyteusClient(server_url=host_url)
+                    response = client.get_available_image_models_sync()
+                except Exception as e:
+                    logger.warning(f"Could not fetch models from Autobyteus server at {host_url}: {e}")
+                    continue
+                finally:
+                    if client:
+                        client.sync_client.close()
+
+                if not response.get('models'):
+                    logger.info(f"No image models found on host {host_url}.")
+                    continue
+
+                models = response.get('models', [])
+                host_registered_count = 0
+                for model_info in models:
+                    try:
+                        if not all(k in model_info for k in ["name", "value", "provider"]):
+                            logger.warning(f"Skipping malformed image model from {host_url}: {model_info}")
+                            continue
+
+                        # Heuristic to ensure it's an image model if the server doesn't specify modality
+                        if "parameter_schema" not in model_info:
+                             logger.debug(f"Skipping model from {host_url} as it lacks a parameter schema, likely not an image model: {model_info.get('name')}")
+                             continue
+
+                        image_model = ImageModel(
+                            name=model_info["name"],
+                            value=model_info["value"],
+                            provider=MultimediaProvider(model_info["provider"]),
+                            client_class=AutobyteusImageClient,
+                            runtime=MultimediaRuntime.AUTOBYTEUS,
+                            host_url=host_url,
+                            parameter_schema=model_info.get("parameter_schema")
+                        )
+                        
+                        ImageClientFactory.register_model(image_model)
+                        host_registered_count += 1
+                        
+                    except Exception as e:
+                        logger.error(f"Failed to register image model '{model_info.get('name')}' from {host_url}: {e}")
+                
+                if host_registered_count > 0:
+                    logger.info(f"Registered {host_registered_count} image models from Autobyteus host {host_url}")
+                total_registered_count += host_registered_count
+            
+            if total_registered_count > 0:
+                 logger.info(f"Finished Autobyteus image model discovery. Total models registered: {total_registered_count}")
+
+        except Exception as e:
+            logger.error(f"An unexpected error occurred during Autobyteus image model discovery: {e}", exc_info=True)
+
+    @staticmethod
+    def is_valid_url(url: str) -> bool:
+        """Validate URL format"""
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False

autobyteus/multimedia/image/base_image_client.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.image.image_model import ImageModel
+    from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+
+class BaseImageClient(ABC):
+    """
+    Abstract base class for image clients that connect to models for image generation and editing.
+    """
+    def __init__(self, model: "ImageModel", config: "MultimediaConfig"):
+        self.model = model
+        self.config = config
+
+    @abstractmethod
+    async def generate_image(
+        self,
+        prompt: str,
+        input_image_urls: Optional[List[str]] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Generates an image based on a textual prompt.
+
+        Args:
+            prompt (str): The text prompt describing the image to generate.
+            input_image_urls (Optional[List[str]]): A list of URLs or local paths to input images
+                                                    for image-to-image generation.
+            generation_config (Optional[Dict[str, Any]]): Provider-specific parameters for image generation
+                                                        to override defaults.
+                                                        (e.g., n, size, quality, style).
+
+        Returns:
+            ImageGenerationResponse: An object containing URLs to the generated images.
+        """
+        pass
+
+    @abstractmethod
+    async def edit_image(
+        self,
+        prompt: str,
+        input_image_urls: List[str],
+        mask_url: Optional[str] = None,
+        generation_config: Optional[Dict[str, Any]] = None
+    ) -> ImageGenerationResponse:
+        """
+        Edits an existing image based on a textual prompt.
+
+        Args:
+            prompt (str): A text prompt describing the desired edits.
+            input_image_urls (List[str]): The path(s) or URL(s) to the source image(s) to edit.
+            mask_url (Optional[str]): The path to a mask image. The transparent areas of the mask
+                                       indicate where the image should be edited.
+            generation_config (Optional[Dict[str, Any]]): Provider-specific parameters.
+
+        Returns:
+            ImageGenerationResponse: An object containing URLs to the edited images.
+        """
+        pass
+
+    async def cleanup(self):
+        """Optional cleanup method for resources like network clients."""
+        pass