indoxrouter 0.1.18__tar.gz → 0.1.21__tar.gz

{indoxrouter-0.1.18/indoxrouter.egg-info → indoxrouter-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: indoxrouter
-Version: 0.1.18
+Version: 0.1.21
 Summary: A unified client for various AI providers
 Author-email: indoxRouter Team <ashkan.eskandari.dev@gmail.com>
 License: MIT

indoxrouter-0.1.21/examples/google_image_generation.py

@@ -0,0 +1,159 @@
+"""
+Example script demonstrating image generation with Google's Imagen model through indoxRouter.
+
+This script shows how to properly format parameters for Google's image generation API,
+including the special handling of aspect ratios and other Google-specific parameters.
+
+Requirements:
+- Install indoxRouter: pip install indoxrouter
+- Set INDOX_ROUTER_API_KEY environment variable with your API key
+"""
+
+import os
+import base64
+from io import BytesIO
+import requests
+from datetime import datetime
+
+from indoxrouter import Client
+
+# For displaying images in notebooks
+try:
+    from IPython.display import Image, display
+
+    in_notebook = True
+except ImportError:
+    in_notebook = False
+
+# Initialize client with API key from environment variable
+api_key = os.environ.get("INDOX_ROUTER_API_KEY")
+if not api_key:
+    print("Please set the INDOX_ROUTER_API_KEY environment variable")
+    exit(1)
+
+client = Client(api_key=api_key)
+
+
+def save_image_from_url(url, filename):
+    """Download and save an image from a URL."""
+    response = requests.get(url)
+    if response.status_code == 200:
+        with open(filename, "wb") as f:
+            f.write(response.content)
+        print(f"Image saved to {filename}")
+    else:
+        print(f"Failed to download image: {response.status_code}")
+
+
+def save_image_from_b64(b64_data, filename):
+    """Save an image from base64 data."""
+    image_data = base64.b64decode(b64_data)
+    with open(filename, "wb") as f:
+        f.write(image_data)
+    print(f"Image saved to {filename}")
+
+
+def generate_google_image(prompt, aspect_ratio="1:1", **kwargs):
+    """
+    Generate an image using Google's Imagen model.
+
+    Args:
+        prompt: The text prompt to generate an image from
+        aspect_ratio: The aspect ratio of the image (e.g., "1:1", "4:3", "16:9")
+        **kwargs: Additional parameters to pass to the API
+    """
+    print(f"\n=== Generating image with Google Imagen ===")
+    print(f"Prompt: {prompt}")
+    print(f"Aspect ratio: {aspect_ratio}")
+
+    try:
+        # Generate the image
+        # Note: The client will automatically convert "1024x1024" to "1:1" for Google models,
+        # but it's more explicit to use the correct format directly
+        response = client.images(
+            prompt=prompt,
+            model="google/imagen-3.0-generate-002",
+            size=aspect_ratio,  # Google uses aspect ratios instead of pixel dimensions
+            **kwargs,
+        )
+
+        print(f"Response received from Google:")
+        print(f"- Success: {response['success']}")
+        print(f"- Cost: ${response['usage']['cost']:.4f}")
+
+        # Check if we have image data
+        if "data" in response and response["data"]:
+            image_data = response["data"][0]
+
+            # Create a timestamp for unique filenames
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+            if "url" in image_data and image_data["url"]:
+                filename = (
+                    f"google_imagen_{aspect_ratio.replace(':', 'x')}_{timestamp}.png"
+                )
+                save_image_from_url(image_data["url"], filename)
+
+                # Display in notebook if possible
+                if in_notebook:
+                    display(Image(url=image_data["url"]))
+
+            elif "b64_json" in image_data and image_data["b64_json"]:
+                filename = (
+                    f"google_imagen_{aspect_ratio.replace(':', 'x')}_{timestamp}.png"
+                )
+                save_image_from_b64(image_data["b64_json"], filename)
+
+                # Display in notebook if possible
+                if in_notebook:
+                    display(Image(data=base64.b64decode(image_data["b64_json"])))
+        else:
+            print("No image data found in response")
+            print("Response:", response)
+
+    except Exception as e:
+        print(f"Error generating image with Google Imagen: {str(e)}")
+
+
+def main():
+    """Main function demonstrating Google Imagen image generation."""
+
+    # Basic example with 1:1 aspect ratio (square image)
+    generate_google_image(
+        prompt="A tranquil zen garden with cherry blossoms and a small pond"
+    )
+
+    # Example with 16:9 aspect ratio (widescreen)
+    generate_google_image(
+        prompt="A wide panoramic view of a futuristic city skyline at sunset with flying vehicles",
+        aspect_ratio="16:9",
+    )
+
+    # Example with 9:16 aspect ratio (portrait/mobile)
+    generate_google_image(
+        prompt="A tall waterfall surrounded by lush greenery in a tropical forest",
+        aspect_ratio="9:16",
+    )
+
+    # Example with negative prompt to influence the generation
+    generate_google_image(
+        prompt="A detailed watercolor painting of a coastal village with boats in the harbor",
+        negative_prompt="dark, moody, sketch, black and white, blurry",
+    )
+
+    # Example with more parameters
+    generate_google_image(
+        prompt="A beautiful tiger resting in a lush jungle environment",
+        aspect_ratio="4:3",
+        negative_prompt="cartoon, illustration, low quality",
+        seed=123456,  # Consistent results with the same seed
+        guidance_scale=7.5,  # Controls how closely the model follows the prompt (usually between 1-20)
+        safety_filter_level="block_none",  # Less restrictive safety filter
+    )
+
+    # Close the client when done
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

indoxrouter-0.1.21/examples/image_generation.py

@@ -0,0 +1,141 @@
+"""
+Example script demonstrating image generation with various providers through indoxRouter.
+
+This script shows how to generate images using different providers (OpenAI, xAI, Google)
+and how to handle the responses to display or save the generated images.
+
+Requirements:
+- Install indoxRouter: pip install indoxrouter
+- Set INDOX_ROUTER_API_KEY environment variable with your API key
+"""
+
+import os
+import base64
+from io import BytesIO
+import requests
+from datetime import datetime
+
+from indoxrouter import Client
+
+# For displaying images in notebooks
+try:
+    from IPython.display import Image, display
+
+    in_notebook = True
+except ImportError:
+    in_notebook = False
+
+# Initialize client with API key from environment variable
+client = Client()
+
+
+def save_image_from_url(url, filename):
+    """Download and save an image from a URL."""
+    response = requests.get(url)
+    if response.status_code == 200:
+        with open(filename, "wb") as f:
+            f.write(response.content)
+        print(f"Image saved to {filename}")
+    else:
+        print(f"Failed to download image: {response.status_code}")
+
+
+def save_image_from_b64(b64_data, filename):
+    """Save an image from base64 data."""
+    image_data = base64.b64decode(b64_data)
+    with open(filename, "wb") as f:
+        f.write(image_data)
+    print(f"Image saved to {filename}")
+
+
+def generate_and_save_image(provider, model, prompt):
+    """Generate an image and save it to a file."""
+    print(f"\n=== Generating image with {provider}/{model} ===")
+    print(f"Prompt: {prompt}")
+
+    try:
+        # Generate the image
+        response = client.images(
+            prompt=prompt,
+            model=f"{provider}/{model}",
+            size="1024x1024",
+        )
+
+        print(f"Response received from {provider}:")
+        print(f"- Success: {response['success']}")
+        print(f"- Cost: ${response['usage']['cost']:.4f}")
+
+        # Check if we have image data
+        if "data" in response and response["data"]:
+            image_data = response["data"][0]
+
+            # Create a timestamp for unique filenames
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+            if "url" in image_data and image_data["url"]:
+                filename = f"{provider}_{model}_{timestamp}.png"
+                save_image_from_url(image_data["url"], filename)
+
+                # Display in notebook if possible
+                if in_notebook:
+                    display(Image(url=image_data["url"]))
+
+            elif "b64_json" in image_data and image_data["b64_json"]:
+                filename = f"{provider}_{model}_{timestamp}.png"
+                save_image_from_b64(image_data["b64_json"], filename)
+
+                # Display in notebook if possible
+                if in_notebook:
+                    display(Image(data=base64.b64decode(image_data["b64_json"])))
+
+            # Check for revised prompt (DALL-E 3 often revises prompts)
+            if "revised_prompt" in image_data and image_data["revised_prompt"]:
+                print(f"Revised prompt: {image_data['revised_prompt']}")
+        else:
+            print("No image data found in response")
+            print("Response:", response)
+
+    except Exception as e:
+        print(f"Error generating image with {provider}/{model}: {str(e)}")
+
+
+# Example prompts
+prompts = {
+    "landscape": "A beautiful mountain landscape with a lake at sunset",
+    "animal": "A cute puppy playing with a ball in a garden",
+    "abstract": "An abstract digital art piece with vibrant colors and geometric shapes",
+    "space": "A realistic view of Earth from space with the moon in the background",
+}
+
+
+def main():
+    # Test OpenAI models
+    generate_and_save_image("openai", "dall-e-2", prompts["landscape"])
+    generate_and_save_image("openai", "dall-e-3", prompts["animal"])
+
+    # Test with gpt-image-1 if available
+    try:
+        generate_and_save_image("openai", "gpt-image-1", prompts["abstract"])
+    except Exception as e:
+        print(f"gpt-image-1 test skipped: {str(e)}")
+
+    # Test xAI models
+    try:
+        generate_and_save_image("xai", "grok-2-image", prompts["space"])
+    except Exception as e:
+        print(f"xAI test skipped: {str(e)}")
+
+    # Test Google models
+    try:
+        generate_and_save_image(
+            "google", "imagen-3.0-generate-002", prompts["abstract"]
+        )
+    except Exception as e:
+        print(f"Google test skipped: {str(e)}")
+
+    # Close the client
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

indoxrouter-0.1.21/examples/provider_specific_image_generation.py

@@ -0,0 +1,163 @@
+"""
+Example script demonstrating image generation with different providers through indoxRouter.
+
+This script shows how to generate images using different providers (OpenAI, Google, xAI)
+with their provider-specific parameters and handling.
+
+Requirements:
+- Install indoxRouter: pip install indoxrouter
+- Set INDOX_ROUTER_API_KEY environment variable with your API key
+"""
+
+import os
+import base64
+from io import BytesIO
+import requests
+from datetime import datetime
+
+from indoxrouter import Client
+
+# For displaying images in notebooks
+try:
+    from IPython.display import Image, display
+
+    in_notebook = True
+except ImportError:
+    in_notebook = False
+
+# Initialize client with API key from environment variable
+api_key = os.environ.get("INDOX_ROUTER_API_KEY")
+if not api_key:
+    print("Please set the INDOX_ROUTER_API_KEY environment variable")
+    exit(1)
+
+client = Client(api_key=api_key)
+
+
+def save_image_from_url(url, filename):
+    """Download and save an image from a URL."""
+    response = requests.get(url)
+    if response.status_code == 200:
+        with open(filename, "wb") as f:
+            f.write(response.content)
+        print(f"Image saved to {filename}")
+    else:
+        print(f"Failed to download image: {response.status_code}")
+
+
+def save_image_from_b64(b64_data, filename):
+    """Save an image from base64 data."""
+    image_data = base64.b64decode(b64_data)
+    with open(filename, "wb") as f:
+        f.write(image_data)
+    print(f"Image saved to {filename}")
+
+
+def display_response_image(response, provider, model):
+    """Display image from response and save it."""
+    try:
+        if "data" in response and response["data"]:
+            image_data = response["data"][0]
+
+            # Create a timestamp for unique filenames
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+            if "url" in image_data and image_data["url"]:
+                filename = f"{provider}_{model}_{timestamp}.png"
+                save_image_from_url(image_data["url"], filename)
+
+                # Display in notebook if possible
+                if in_notebook:
+                    display(Image(url=image_data["url"]))
+
+            elif "b64_json" in image_data and image_data["b64_json"]:
+                filename = f"{provider}_{model}_{timestamp}.png"
+                save_image_from_b64(image_data["b64_json"], filename)
+
+                # Display in notebook if possible
+                if in_notebook:
+                    display(Image(data=base64.b64decode(image_data["b64_json"])))
+
+            # Check for revised prompt (DALL-E 3 often revises prompts)
+            if "revised_prompt" in image_data and image_data["revised_prompt"]:
+                print(f"Revised prompt: {image_data['revised_prompt']}")
+        else:
+            print("No image data found in response")
+    except Exception as e:
+        print(f"Error displaying/saving image: {str(e)}")
+
+
+def main():
+    """Main function demonstrating image generation with different providers."""
+
+    # Example prompt for all providers
+    prompt = "A tranquil zen garden with cherry blossoms and a small pond"
+
+    print("\n=== OpenAI (DALL-E 2) ===")
+    print("Uses pixel dimensions (e.g., '1024x1024')")
+    try:
+        openai_response = client.images(
+            prompt=prompt,
+            model="openai/dall-e-2",
+            size="1024x1024",  # OpenAI uses pixel dimensions
+        )
+        print(f"Response received - Success: {openai_response.get('success', False)}")
+        print(f"Cost: ${openai_response.get('usage', {}).get('cost', 0):.4f}")
+        display_response_image(openai_response, "openai", "dall-e-2")
+    except Exception as e:
+        print(f"Error with OpenAI: {str(e)}")
+
+    print("\n=== Google (Imagen) ===")
+    print("Uses aspect ratios (e.g., '1:1', '16:9') instead of pixel dimensions")
+    try:
+        google_response = client.images(
+            prompt=prompt,
+            model="google/imagen-3.0-generate-002",
+            # Note: Use 'aspect_ratio' instead of 'size' for Google
+            aspect_ratio="1:1",  # Google uses aspect ratios
+            negative_prompt="cartoon, illustration, drawing, painting",
+        )
+        print(f"Response received - Success: {google_response.get('success', False)}")
+        print(f"Cost: ${google_response.get('usage', {}).get('cost', 0):.4f}")
+        display_response_image(google_response, "google", "imagen")
+    except Exception as e:
+        print(f"Error with Google: {str(e)}")
+
+    print("\n=== xAI (Grok) ===")
+    print("Does not use size parameter, only supports specific parameters")
+    try:
+        xai_response = client.images(
+            prompt=prompt,
+            model="xai/grok-2-image",
+            # Note: xAI doesn't support size parameter, so we don't include it
+            response_format="url",  # xAI supports response_format
+        )
+        print(f"Response received - Success: {xai_response.get('success', False)}")
+        print(f"Cost: ${xai_response.get('usage', {}).get('cost', 0):.4f}")
+        display_response_image(xai_response, "xai", "grok-2-image")
+    except Exception as e:
+        print(f"Error with xAI: {str(e)}")
+
+    # Advanced example with DALL-E 3
+    print("\n=== OpenAI (DALL-E 3) with Advanced Parameters ===")
+    try:
+        dalle3_response = client.images(
+            prompt="A beautiful underwater scene with coral reef and tropical fish",
+            model="openai/dall-e-3",
+            size="1024x1024",
+            quality="standard",  # 'standard' or 'hd'
+            style="vivid",  # 'vivid' or 'natural'
+            response_format="url",
+        )
+        print(f"Response received - Success: {dalle3_response.get('success', False)}")
+        print(f"Cost: ${dalle3_response.get('usage', {}).get('cost', 0):.4f}")
+        display_response_image(dalle3_response, "openai", "dall-e-3")
+    except Exception as e:
+        print(f"Error with DALL-E 3: {str(e)}")
+
+    # Close the client when done
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

{indoxrouter-0.1.18 → indoxrouter-0.1.21}/indoxrouter/client.py

@@ -399,6 +399,48 @@ class Client:
         # is having issues with JSON formatted model strings
         return model
 
+    def _format_image_size_for_provider(
+        self, size: str, provider: str, model: str
+    ) -> str:
+        """
+        Format the image size parameter based on the provider's requirements.
+
+        Google requires aspect ratios like "1:1", "4:3", etc. while OpenAI uses pixel dimensions
+        like "1024x1024", "512x512", etc.
+
+        Args:
+            size: The size parameter (e.g., "1024x1024")
+            provider: The provider name (e.g., "google", "openai")
+            model: The model name
+
+        Returns:
+            Formatted size parameter appropriate for the provider
+        """
+        if provider.lower() == "google":
+            # Google uses aspect ratios instead of pixel dimensions
+            # Convert common pixel dimensions to aspect ratios
+            size_to_aspect_ratio = {
+                "1024x1024": "1:1",
+                "512x512": "1:1",
+                "256x256": "1:1",
+                "1024x768": "4:3",
+                "768x1024": "3:4",
+                "1024x1536": "2:3",
+                "1536x1024": "3:2",
+                "1792x1024": "16:9",
+                "1024x1792": "9:16",
+            }
+
+            # Check if size is already in aspect ratio format (contains a colon)
+            if ":" in size:
+                return size
+
+            # Convert to aspect ratio if we have a mapping, otherwise use default 1:1
+            return size_to_aspect_ratio.get(size, "1:1")
+
+        # For other providers, return the original size
+        return size
+
     def chat(
         self,
         messages: List[Dict[str, str]],
@@ -555,6 +597,8 @@ class Client:
         output_mime_type: Optional[str] = None,
         add_watermark: Optional[bool] = None,
         enhance_prompt: Optional[bool] = None,
+        # Google-specific direct parameters
+        aspect_ratio: Optional[str] = None,
         **kwargs,
     ) -> Dict[str, Any]:
         """
@@ -566,7 +610,7 @@ class Client:
 
             # Provider-specific parameters - will only be included if explicitly provided
             # Note: Different providers support different parameters
-            size: Image size - For OpenAI: "1024x1024", "512x512", etc. For Google: "1:1", "4:3", etc.
+            size: Image size - For OpenAI: "1024x1024", "512x512", etc. For Google: use aspect_ratio instead
             n: Number of images to generate
             quality: Image quality (e.g., "standard", "hd") - supported by some providers
             style: Image style (e.g., "vivid", "natural") - supported by some providers
@@ -593,6 +637,7 @@ class Client:
             output_mime_type: MIME type of the generated image
             add_watermark: Whether to add a watermark to the generated images
             enhance_prompt: Whether to use prompt rewriting logic
+            aspect_ratio: Aspect ratio for Google models (e.g., "1:1", "16:9") - preferred over size
 
             **kwargs: Additional parameters to pass to the API
 
@@ -602,6 +647,11 @@ class Client:
         # Format the model string
         formatted_model = self._format_model_string(model)
 
+        # Extract provider from model string if present
+        provider = "openai"  # Default provider
+        if "/" in model:
+            provider, _ = model.split("/", 1)
+
         # Filter out problematic parameters
         filtered_kwargs = {}
         for key, value in kwargs.items():
@@ -617,8 +667,28 @@ class Client:
         # Add optional parameters only if they are explicitly provided
         if n is not None:
             data["n"] = n
-        if size is not None:
+
+        # Handle size/aspect_ratio parameters based on provider
+        if provider.lower() == "google":
+            # For Google, use aspect_ratio instead of size
+            if aspect_ratio is not None:
+                data["aspect_ratio"] = aspect_ratio
+            elif size is not None:
+                # Convert size to aspect_ratio
+                formatted_size = self._format_image_size_for_provider(
+                    size, provider, model
+                )
+                data["aspect_ratio"] = formatted_size
+            else:
+                # Default aspect_ratio for Google
+                data["aspect_ratio"] = "1:1"
+        elif provider.lower() == "xai":
+            # xAI doesn't support size parameter
+            pass
+        elif size is not None:
+            # For other providers (like OpenAI), use size as is
             data["size"] = size
+
         if quality is not None:
             data["quality"] = quality
         if style is not None:

{indoxrouter-0.1.18 → indoxrouter-0.1.21/indoxrouter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: indoxrouter
-Version: 0.1.18
+Version: 0.1.21
 Summary: A unified client for various AI providers
 Author-email: indoxRouter Team <ashkan.eskandari.dev@gmail.com>
 License: MIT

{indoxrouter-0.1.18 → indoxrouter-0.1.21}/indoxrouter.egg-info/SOURCES.txt

@@ -3,6 +3,9 @@ README.md
 pyproject.toml
 cookbook/README.md
 cookbook/indoxRouter_cookbook.ipynb
+examples/google_image_generation.py
+examples/image_generation.py
+examples/provider_specific_image_generation.py
 indoxrouter/__init__.py
 indoxrouter/client.py
 indoxrouter/constants.py
@@ -11,4 +14,5 @@ indoxrouter.egg-info/PKG-INFO
 indoxrouter.egg-info/SOURCES.txt
 indoxrouter.egg-info/dependency_links.txt
 indoxrouter.egg-info/requires.txt
-indoxrouter.egg-info/top_level.txt
+indoxrouter.egg-info/top_level.txt
+tests/test_image.py

{indoxrouter-0.1.18 → indoxrouter-0.1.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "indoxrouter"
-version = "0.1.18"
+version = "0.1.21"
 authors = [
     {name = "indoxRouter Team", email = "ashkan.eskandari.dev@gmail.com"},
 ]

indoxrouter-0.1.21/tests/test_image.py

@@ -0,0 +1,93 @@
+"""
+Test the image generation functionality of the IndoxRouter client.
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+from indoxrouter import Client
+
+
+class TestImageGeneration(unittest.TestCase):
+    """Test the image generation functionality."""
+
+    def setUp(self):
+        """Set up the test case."""
+        # Use a mock API key for testing
+        self.api_key = "test_api_key"
+
+        # Create a patched client that doesn't make real API calls
+        with patch("indoxrouter.client.requests.Session") as mock_session:
+            # Mock successful authentication response
+            mock_response = MagicMock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {"access_token": "mock_token"}
+            mock_session.return_value.post.return_value = mock_response
+
+            # Create client with mocked session
+            self.client = Client(api_key=self.api_key)
+            self.client._request = MagicMock()  # Replace _request with mock
+
+    def test_image_generation_response_format(self):
+        """Test that the image generation response format is correct."""
+        # Mock response data that matches what we expect from the server
+        mock_response = {
+            "request_id": "test-request-id",
+            "created_at": "2025-05-29T11:39:24.621706",
+            "duration_ms": 12340.412378311157,
+            "provider": "openai",
+            "model": "dall-e-2",
+            "success": True,
+            "message": "",
+            "usage": {
+                "tokens_prompt": 0,
+                "tokens_completion": 0,
+                "tokens_total": 0,
+                "cost": 0.016,
+                "latency": 12.240789651870728,
+                "timestamp": "2025-05-29T11:39:24.612377",
+            },
+            "data": [
+                {
+                    "url": "https://example.com/generated-image.png",
+                    "revised_prompt": "A beautiful sunset over the ocean with clouds.",
+                }
+            ],
+        }
+
+        # Set the mock response for the _request method
+        self.client._request.return_value = mock_response
+
+        # Call the images method
+        response = self.client.images(
+            prompt="A beautiful sunset over the ocean",
+            model="openai/dall-e-2",
+            size="1024x1024",
+        )
+
+        # Verify the client made the request with the correct parameters
+        self.client._request.assert_called_once()
+        call_args = self.client._request.call_args[0]
+
+        # Verify the response format
+        self.assertEqual(response["success"], True)
+        self.assertEqual(response["provider"], "openai")
+        self.assertEqual(response["model"], "dall-e-2")
+
+        # Verify the data contains the image URL
+        self.assertIn("data", response)
+        self.assertIsInstance(response["data"], list)
+        self.assertEqual(len(response["data"]), 1)
+        self.assertIn("url", response["data"][0])
+        self.assertEqual(
+            response["data"][0]["url"], "https://example.com/generated-image.png"
+        )
+
+        # Verify usage information
+        self.assertIn("usage", response)
+        self.assertIn("cost", response["usage"])
+        self.assertGreater(response["usage"]["cost"], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()