indoxrouter 0.1.19__tar.gz → 0.1.22__tar.gz

{indoxrouter-0.1.19 → indoxrouter-0.1.22}/PKG-INFO

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

indoxrouter-0.1.22/examples/google_image_generation.py

@@ -0,0 +1,89 @@
+"""
+Example script demonstrating Google image generation through indoxRouter.
+
+This script shows how to generate images using Google's Imagen models
+with their specific parameters, especially aspect_ratio instead of size.
+
+Requirements:
+- Install indoxRouter: pip install indoxrouter
+- Set INDOX_ROUTER_API_KEY environment variable with your API key
+"""
+
+import os
+from indoxrouter import Client
+
+# 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 generate_image(model, prompt, **kwargs):
+    """Generate an image with the specified Google model and parameters."""
+    print(f"\n=== Generating image with {model} ===")
+    print(f"Prompt: {prompt}")
+
+    try:
+        response = client.images(prompt=prompt, model=f"google/{model}", **kwargs)
+
+        # Print the URL of the generated image
+        if "data" in response and response["data"] and "url" in response["data"][0]:
+            print(f"Image URL: {response['data'][0]['url']}")
+
+        # Print usage/cost information if available
+        if "usage" in response and "cost" in response["usage"]:
+            print(f"Cost: ${response['usage']['cost']:.4f}")
+
+        return response
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return None
+
+
+def main():
+    """Main function demonstrating Google image generation."""
+
+    # Basic example with square aspect ratio
+    imagen_square = generate_image(
+        model="imagen-3.0-generate-002",
+        prompt="A serene Japanese garden with a koi pond",
+        aspect_ratio="1:1",  # Use aspect_ratio instead of size
+        response_format="url",
+    )
+
+    # Example with landscape aspect ratio
+    imagen_landscape = generate_image(
+        model="imagen-3.0-generate-002",
+        prompt="A panoramic view of the Grand Canyon at sunset",
+        aspect_ratio="16:9",  # Landscape orientation
+        response_format="url",
+    )
+
+    # Example with portrait aspect ratio
+    imagen_portrait = generate_image(
+        model="imagen-3.0-generate-002",
+        prompt="A tall redwood tree in a misty forest",
+        aspect_ratio="9:16",  # Portrait orientation
+        response_format="url",
+    )
+
+    # Example with additional parameters
+    imagen_advanced = generate_image(
+        model="imagen-3.0-generate-002",
+        prompt="A cyberpunk cityscape with neon lights and flying vehicles",
+        aspect_ratio="4:3",
+        negative_prompt="cartoon, illustration, drawing, painting",  # What to avoid
+        guidance_scale=12.0,  # Controls adherence to the text prompt (7-20)
+        seed=12345,  # For reproducible results
+        response_format="url",
+    )
+
+    # Close the client when done
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

indoxrouter-0.1.22/examples/openai_image_generation.py

@@ -0,0 +1,87 @@
+"""
+Example script demonstrating OpenAI image generation through indoxRouter.
+
+This script shows how to generate images using different OpenAI models:
+- DALL-E 2
+- DALL-E 3
+- GPT-image-1
+
+Requirements:
+- Install indoxRouter: pip install indoxrouter
+- Set INDOX_ROUTER_API_KEY environment variable with your API key
+"""
+
+import os
+from indoxrouter import Client
+
+# 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 generate_image(model, prompt, **kwargs):
+    """Generate an image with the specified model and parameters."""
+    print(f"\n=== Generating image with {model} ===")
+    print(f"Prompt: {prompt}")
+
+    try:
+        response = client.images(prompt=prompt, model=f"openai/{model}", **kwargs)
+
+        # Print the URL of the generated image
+        if "data" in response and response["data"] and "url" in response["data"][0]:
+            print(f"Image URL: {response['data'][0]['url']}")
+
+            # Check for revised prompt (DALL-E 3 often revises prompts)
+            if "revised_prompt" in response["data"][0]:
+                print(f"Revised prompt: {response['data'][0]['revised_prompt']}")
+
+        # Print usage/cost information if available
+        if "usage" in response and "cost" in response["usage"]:
+            print(f"Cost: ${response['usage']['cost']:.4f}")
+
+        return response
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return None
+
+
+def main():
+    """Main function demonstrating OpenAI image generation."""
+
+    # Basic DALL-E 2 example
+    dalle2_response = generate_image(
+        model="dall-e-2",
+        prompt="A beautiful mountain landscape at sunset",
+        size="1024x1024",  # Required parameter
+        response_format="url",  # Optional parameter
+    )
+
+    # DALL-E 3 with quality and style options
+    dalle3_response = generate_image(
+        model="dall-e-3",
+        prompt="A futuristic city with flying cars and tall skyscrapers",
+        size="1024x1024",  # Required parameter
+        quality="hd",  # Optional parameter ('standard' or 'hd')
+        style="vivid",  # Optional parameter ('vivid' or 'natural')
+        response_format="url",
+    )
+
+    # GPT-image-1 example
+    # Note: For GPT-image-1, don't include response_format unless you need it
+    gpt_image_response = generate_image(
+        model="gpt-image-1",
+        prompt="A whimsical fantasy castle with dragons flying around it",
+        size="1024x1024",  # Required parameter
+        # response_format is omitted as it can cause errors with gpt-image-1
+    )
+
+    # Close the client when done
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

indoxrouter-0.1.22/examples/provider_specific_image_generation.py

@@ -0,0 +1,191 @@
+"""
+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=== OpenAI (GPT-image-1) ===")
+    print("Uses pixel dimensions (e.g., '1024x1024')")
+    try:
+        # For GPT-image-1, don't include response_format parameter unless you specify it
+        gpt_image_response = client.images(
+            prompt=prompt,
+            model="openai/gpt-image-1",
+            size="1024x1024",  # OpenAI uses pixel dimensions
+            # Note: don't include response_format parameter unless explicitly needed
+        )
+        print(
+            f"Response received - Success: {gpt_image_response.get('success', False)}"
+        )
+        print(f"Cost: ${gpt_image_response.get('usage', {}).get('cost', 0):.4f}")
+        display_response_image(gpt_image_response, "openai", "gpt-image-1")
+    except Exception as e:
+        print(f"Error with GPT-image-1: {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
+            # Only include specific parameters that xAI supports
+            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)}")
+
+    print("\n=== Provider-Specific Parameter Examples ===")
+    print("Each provider supports different parameters:")
+    print("OpenAI: size, quality, style, background, response_format...")
+    print("Google: aspect_ratio, negative_prompt, guidance_scale, seed...")
+    print("xAI: n, response_format (minimal parameters)")
+    print(
+        "\nRefer to the documentation for the complete list of parameters for each provider."
+    )
+
+    # Close the client when done
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

indoxrouter-0.1.22/examples/xai_image_generation.py

@@ -0,0 +1,90 @@
+"""
+Example script demonstrating xAI image generation through indoxRouter.
+
+This script shows how to generate images using xAI's Grok model
+with the correct parameters (avoiding 'size' which is not supported).
+
+Requirements:
+- Install indoxRouter: pip install indoxrouter
+- Set INDOX_ROUTER_API_KEY environment variable with your API key
+"""
+
+import os
+from indoxrouter import Client
+
+# 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 generate_image(prompt, **kwargs):
+    """Generate an image with xAI's Grok model."""
+    print(f"\n=== Generating image with xAI Grok ===")
+    print(f"Prompt: {prompt}")
+
+    try:
+        response = client.images(
+            prompt=prompt,
+            model="xai/grok-2-image",
+            # DO NOT include 'size' parameter - it will cause an error
+            **kwargs,
+        )
+
+        # Print the URL of the generated image
+        if "data" in response and response["data"] and "url" in response["data"][0]:
+            print(f"Image URL: {response['data'][0]['url']}")
+
+        # Print usage/cost information if available
+        if "usage" in response and "cost" in response["usage"]:
+            print(f"Cost: ${response['usage']['cost']:.4f}")
+
+        return response
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return None
+
+
+def main():
+    """Main function demonstrating xAI image generation."""
+
+    # Basic example - minimal parameters
+    basic_image = generate_image(
+        prompt="A cybernetic fox in a futuristic city",
+        # No size parameter - xAI doesn't support it
+        response_format="url",  # One of the few parameters xAI supports
+    )
+
+    # Multiple images example
+    multiple_images = generate_image(
+        prompt="A colorful abstract painting of geometric shapes",
+        n=2,  # Generate 2 images
+        response_format="url",
+    )
+
+    # Example with long, detailed prompt
+    detailed_prompt = generate_image(
+        prompt=(
+            "A steampunk-inspired mechanical dragonfly with brass gears, "
+            "copper wings, and glowing blue energy cores, hovering above "
+            "a Victorian-era cityscape with airships in the cloudy sky"
+        ),
+        response_format="url",
+    )
+
+    print("\n=== xAI Parameter Notes ===")
+    print("xAI/Grok supports very few parameters compared to other providers:")
+    print("- prompt: The text prompt (required)")
+    print("- n: Number of images to generate (optional)")
+    print("- response_format: 'url' or 'b64_json' (optional)")
+    print("DO NOT include 'size', 'quality', 'style', or other parameters")
+
+    # Close the client when done
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

{indoxrouter-0.1.19 → indoxrouter-0.1.22}/indoxrouter/client.py

@@ -597,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]:
         """
@@ -608,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
@@ -635,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
 
@@ -644,10 +647,11 @@ class Client:
         # Format the model string
         formatted_model = self._format_model_string(model)
 
-        # Extract provider from model string if present
+        # Extract provider and model name from model string if present
         provider = "openai"  # Default provider
+        model_name = model
         if "/" in model:
-            provider, _ = model.split("/", 1)
+            provider, model_name = model.split("/", 1)
 
         # Filter out problematic parameters
         filtered_kwargs = {}
@@ -665,13 +669,26 @@ class Client:
         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"
+        # 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_name
+                )
+                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 - do not include it
+            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
@@ -722,6 +739,12 @@ class Client:
         if filtered_kwargs:
             data["additional_params"] = filtered_kwargs
 
+        # Special case handling for specific models
+        if provider.lower() == "openai" and "gpt-image" in model_name.lower():
+            # Remove response_format for gpt-image models unless explicitly provided
+            if response_format is None and "response_format" in data:
+                del data["response_format"]
+
         return self._request("POST", IMAGE_ENDPOINT, data)
 
     def models(self, provider: Optional[str] = None) -> Dict[str, Any]:

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

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

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

@@ -5,6 +5,9 @@ cookbook/README.md
 cookbook/indoxRouter_cookbook.ipynb
 examples/google_image_generation.py
 examples/image_generation.py
+examples/openai_image_generation.py
+examples/provider_specific_image_generation.py
+examples/xai_image_generation.py
 indoxrouter/__init__.py
 indoxrouter/client.py
 indoxrouter/constants.py

{indoxrouter-0.1.19 → indoxrouter-0.1.22}/pyproject.toml

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

indoxrouter-0.1.19/examples/google_image_generation.py

@@ -1,159 +0,0 @@
-"""
-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()