indoxrouter 0.1.17__tar.gz → 0.1.19__tar.gz

{indoxrouter-0.1.17/indoxrouter.egg-info → indoxrouter-0.1.19}/PKG-INFO

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

indoxrouter-0.1.19/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.19/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.17 → indoxrouter-0.1.19}/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]],
@@ -531,10 +573,10 @@ class Client:
         self,
         prompt: str,
         model: str = DEFAULT_IMAGE_MODEL,
-        size: str = "1024x1024",
-        n: int = 1,
-        quality: str = "standard",
-        style: str = "vivid",
+        size: Optional[str] = None,
+        n: Optional[int] = None,
+        quality: Optional[str] = None,
+        style: Optional[str] = None,
         # Standard parameters
         response_format: Optional[str] = None,
         user: Optional[str] = None,
@@ -563,10 +605,13 @@ class Client:
         Args:
             prompt: Text prompt
             model: Model to use in the format "provider/model" (e.g., "openai/dall-e-3", "google/imagen-3.0-generate-002")
-            size: Image size (e.g., "1024x1024")
+
+            # 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.
             n: Number of images to generate
-            quality: Image quality (e.g., "standard", "hd")
-            style: Image style (e.g., "vivid", "natural")
+            quality: Image quality (e.g., "standard", "hd") - supported by some providers
+            style: Image style (e.g., "vivid", "natural") - supported by some providers
 
             # Standard parameters
             response_format: Format of the response - "url" or "b64_json"
@@ -599,22 +644,40 @@ 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():
             if key not in ["return_generator"]:  # List of parameters to exclude
                 filtered_kwargs[key] = value
 
-        # Create the base request data
+        # Create the base request data with only the required parameters
         data = {
             "prompt": prompt,
             "model": formatted_model,
-            "n": n,
-            "size": size,
-            "quality": quality,
-            "style": style,
         }
 
+        # Add optional parameters only if they are explicitly provided
+        if n is not None:
+            data["n"] = n
+
+        # Handle size parameter with provider-specific formatting
+        if size is not None:
+            formatted_size = self._format_image_size_for_provider(size, provider, model)
+            data["size"] = formatted_size
+        elif provider.lower() == "google":
+            # Default size for Google if not provided
+            data["size"] = "1:1"
+
+        if quality is not None:
+            data["quality"] = quality
+        if style is not None:
+            data["style"] = style
+
         # Add standard parameters if provided
         if response_format is not None:
             data["response_format"] = response_format

{indoxrouter-0.1.17 → indoxrouter-0.1.19/indoxrouter.egg-info}/PKG-INFO

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

{indoxrouter-0.1.17 → indoxrouter-0.1.19}/indoxrouter.egg-info/SOURCES.txt

@@ -3,6 +3,8 @@ README.md
 pyproject.toml
 cookbook/README.md
 cookbook/indoxRouter_cookbook.ipynb
+examples/google_image_generation.py
+examples/image_generation.py
 indoxrouter/__init__.py
 indoxrouter/client.py
 indoxrouter/constants.py
@@ -11,4 +13,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.17 → indoxrouter-0.1.19}/pyproject.toml

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

indoxrouter-0.1.19/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()