wavespeed 0.0.1__py3-none-any.whl

wavespeed/__init__.py

@@ -0,0 +1,18 @@
+"""
+Wavespeed AI Python Client
+
+A Python client for interacting with the Wavespeed AI API.
+"""
+
+__version__ = "0.1.0"
+
+from .client import Wavespeed
+from .schemas.prediction import Prediction, PredictionUrls, PredictionResponse
+
+__all__ = [
+    "Wavespeed",
+    "Prediction",
+    "PredictionUrls",
+    "PredictionResponse",
+    "__version__",
+]

wavespeed/client.py

@@ -0,0 +1,150 @@
+import os
+import httpx
+from typing import Dict, Any
+from urllib.parse import urljoin
+
+from wavespeed.schemas.prediction import Prediction
+
+
+class Wavespeed:
+    """
+    A client for interacting with the Wavespeed AI API.
+    """
+    
+    BASE_URL = "https://api.wavespeed.ai/api/v2/"
+    
+    def __init__(self, api_key: str):
+        """
+        Initialize the Wavespeed client.
+        
+        Args:
+            api_key: Your Wavespeed API key
+        """
+        self.api_key = api_key
+        if not api_key:
+            api_key = os.environ.get("WAVESPEED_API_KEY", '')
+        if not api_key:
+            raise ValueError("API key is required.")
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+        self.async_client = httpx.AsyncClient(headers=self.headers)
+        self.client = httpx.Client(headers=self.headers)
+        self.poll_interval = float(os.environ.get("WAVESPEED_POLL_INTERVAL", 1)) # seconds
+        self.timeout = int(os.environ.get("WAVESPEED_TIMEOUT", 60)) # seconds
+    
+    async def async_run(
+        self,
+        modelId: str,
+        input: Dict[str, Any],
+        **kwargs
+    ) -> Prediction:
+        """
+        Generate an image using the Wavespeed AI API.
+        
+        Args:
+            modelId: The ID of the model to use
+            input: Input parameters for the model
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            The API response as a dictionary
+        """
+        url = urljoin(self.BASE_URL, modelId)
+        
+        payload = input
+        
+        # Reset client if it's closed
+        if self.async_client.is_closed:
+            self.async_client = httpx.AsyncClient()
+            
+        response = await self.async_client.post(
+            url,
+            headers=self.headers,
+            json=payload,
+            timeout=self.timeout
+        )
+        
+        # Raise an exception for HTTP errors
+        response.raise_for_status()
+        data = response.json()
+        prediction = Prediction(**data['data'])
+        prediction._client = self
+        return await prediction.async_wait()
+    
+    def run(
+        self,
+        modelId: str,
+        input: Dict[str, Any],
+        **kwargs
+    ) -> Prediction:
+        """
+        Generate an image using the Wavespeed AI API.
+        
+        Args:
+            modelId: The ID of the model to use
+            input: Input parameters for the model
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            The API response as a dictionary
+        """
+        url = urljoin(self.BASE_URL, modelId)
+        
+        payload = input
+        
+        response = self.client.post(
+            url,
+            headers=self.headers,
+            json=payload,
+            timeout=self.timeout
+        )
+
+        # Raise an exception for HTTP errors
+        response.raise_for_status()
+        data = response.json()
+        prediction = Prediction(**data['data'])
+        prediction._client = self
+        return prediction.wait()
+    
+    async def async_create(self, modelId: str, input: Dict[str, Any], **kwargs) -> Prediction:
+        url = urljoin(self.BASE_URL, modelId)
+        payload = input
+        response = await self.async_client.post(
+            url,
+            headers=self.headers,
+            json=payload,
+            timeout=self.timeout
+        )
+        # Raise an exception for HTTP errors
+        response.raise_for_status()
+        data = response.json()
+        prediction = Prediction(**data['data'])
+        prediction._client = self
+        return prediction
+    
+    def create(self, modelId: str, input: Dict[str, Any], **kwargs) -> Prediction:
+        url = urljoin(self.BASE_URL, modelId)
+        payload = input
+        response = self.client.post(
+            url,
+            headers=self.headers,
+            json=payload,
+            timeout=self.timeout
+        )
+        # Raise an exception for HTTP errors
+        response.raise_for_status()
+        data = response.json()
+        prediction = Prediction(**data['data'])
+        prediction._client = self
+        return prediction
+        
+    async def close(self):
+        """Close the httpx client session."""
+        self.client.close()
+        await self.async_client.aclose()
+        
+    def __str__(self) -> str:
+        """String representation of the client."""
+        return f"WavespeedClient()"

wavespeed-0.0.1.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: wavespeed
+Version: 0.0.1
+Summary: Python client for Wavespeed
+Author: Wavespeed, Inc.
+License: MIT License
+        
+        Copyright (c) 2025 Wavespeed AI
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: homepage, https://wavespeed.ai
+Project-URL: repository, https://github.com/wavespeed-ai/wavespeed-python
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1,>=0.21.0
+Requires-Dist: packaging
+Requires-Dist: pydantic>1.10.7
+Requires-Dist: typing_extensions>=4.5.0
+Dynamic: license-file
+
+# Wavespeed Python Client
+
+A Python client for interacting with the Wavespeed AI API.
+
+## Installation
+
+```bash
+pip install wavespeed
+```
+
+## Usage
+
+### Synchronous Image Generation
+
+```python
+from wavespeed import Wavespeed
+
+# Initialize the client with your API key (or set WAVESPEED_API_KEY environment variable)
+client = Wavespeed(api_key="YOUR_API_KEY")
+
+# Generate an image and wait for the result
+prediction = client.run(
+    modelId="wavespeed-ai/flux-dev",
+    input={
+        "prompt": "A futuristic cityscape with flying cars and neon lights",
+        "size": "1024*1024",
+        "num_inference_steps": 28,
+        "guidance_scale": 5.0,
+        "num_images": 1,
+        "seed": -1,
+        "enable_safety_checker": True
+    }
+)
+
+# Print the generated image URLs
+for i, img_url in enumerate(prediction.outputs):
+    print(f"Image {i+1}: {img_url}")
+```
+
+### Asynchronous Image Generation
+
+```python
+import asyncio
+from wavespeed import Wavespeed
+
+async def generate_image():
+    # Initialize the client with your API key (or set WAVESPEED_API_KEY environment variable)
+    client = Wavespeed(api_key="YOUR_API_KEY")
+    
+    try:
+        # Generate an image and wait for the result
+        prediction = await client.async_run(
+            modelId="wavespeed-ai/flux-dev",
+            input={
+                "prompt": "A futuristic cityscape with flying cars and neon lights",
+                "size": "1024*1024",
+                "num_inference_steps": 28,
+                "guidance_scale": 5.0,
+                "num_images": 1,
+                "seed": -1,
+                "enable_safety_checker": True
+            }
+        )
+        
+        # Print the generated image URLs
+        for i, img_url in enumerate(prediction.outputs):
+            print(f"Image {i+1}: {img_url}")
+    finally:
+        # Always close the client when done
+        await client.close()
+
+# Run the async function
+asyncio.run(generate_image())
+```
+
+### Non-blocking Image Generation
+
+You can also create a prediction without waiting for it to complete:
+
+```python
+from wavespeed import Wavespeed
+
+# Initialize the client with your API key (or set WAVESPEED_API_KEY environment variable)
+client = Wavespeed(api_key="YOUR_API_KEY")
+
+# Create a prediction without waiting
+prediction = client.create(
+    modelId="wavespeed-ai/flux-dev",
+    input={
+        "prompt": "A futuristic cityscape with flying cars and neon lights",
+        "size": "1024*1024",
+        "num_inference_steps": 28,
+        "guidance_scale": 5.0,
+        "num_images": 1,
+        "seed": -1,
+        "enable_safety_checker": True
+    }
+)
+
+print(f"Prediction created with ID: {prediction.id}")
+print(f"Initial status: {prediction.status}")
+
+# Later, you can wait for the prediction to complete
+result = prediction.wait()
+print(f"Final status: {result.status}")
+
+# Print the generated image URLs
+for i, img_url in enumerate(result.outputs):
+    print(f"Image {i+1}: {img_url}")
+```
+
+## Command Line Examples
+
+The package includes several example scripts that you can use to generate images:
+
+### Basic Image Generation
+
+```bash
+# Set your API key as an environment variable
+export WAVESPEED_API_KEY="your_api_key_here"
+
+# Run the example script
+python examples/generate_image.py --prompt "A futuristic cityscape with flying cars and neon lights"
+```
+
+### Asynchronous Image Generation
+
+```bash
+# Run the async example script
+python examples/async_generate_image.py --prompt "A futuristic cityscape with flying cars and neon lights"
+```
+
+### Non-blocking Image Generation
+
+```bash
+# Create a prediction and poll for status
+python examples/create_generate_image.py --prompt "A futuristic cityscape with flying cars and neon lights"
+```
+
+### Command Line Options
+
+```
+--prompt TEXT         Text description of the desired image (required)
+--strength FLOAT      How much to transform the input image (0.0 to 1.0)
+--size WIDTHxHEIGHT   Image dimensions (default: 1024*1024)
+--steps INT           Number of inference steps (default: 28)
+--guidance FLOAT      How closely to follow the prompt (default: 5.0)
+--num-images INT      Number of images to generate (default: 1)
+--seed INT            Random seed (-1 for random)
+--safety              Enable content safety filtering
+```
+
+## API Reference
+
+### Wavespeed Client
+
+```python
+Wavespeed(api_key)
+```
+
+#### Parameters:
+
+- `api_key` (str): Your Wavespeed API key
+
+### Methods
+
+#### run
+
+```python
+run(modelId, input, **kwargs) -> Prediction
+```
+
+Generate an image and wait for the result.
+
+#### async_run
+
+```python
+async_run(modelId, input, **kwargs) -> Prediction
+```
+
+Asynchronously generate an image and wait for the result.
+
+#### create
+
+```python
+create(modelId, input, **kwargs) -> Prediction
+```
+
+Create a prediction without waiting for it to complete.
+
+#### async_create
+
+```python
+async_create(modelId, input, **kwargs) -> Prediction
+```
+
+Asynchronously create a prediction without waiting for it to complete.
+
+### Prediction Model
+
+The `Prediction` object contains information about an image generation job:
+
+```python
+prediction.id           # Unique ID of the prediction
+prediction.model        # Model ID used for the prediction
+prediction.status       # Status of the prediction (processing, completed, failed)
+prediction.outputs      # List of output image URLs
+prediction.input        # Input parameters used for the prediction
+prediction.created_at   # Creation timestamp
+prediction.error        # Error message (if any)
+prediction.executionTime # Time taken to execute the prediction in milliseconds
+```
+
+#### Methods
+
+```python
+prediction.wait() -> Prediction  # Wait for the prediction to complete
+prediction.reload() -> Prediction  # Reload the prediction status
+
+# Async versions
+await prediction.async_wait() -> Prediction
+await prediction.async_reload() -> Prediction
+```
+
+## Environment Variables
+
+- `WAVESPEED_API_KEY`: Your Wavespeed API key
+- `WAVESPEED_POLL_INTERVAL`: Interval in seconds for polling prediction status (default: 1)
+- `WAVESPEED_TIMEOUT`: Timeout in seconds for API requests (default: 60)
+
+## License
+
+MIT

wavespeed-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+wavespeed/__init__.py,sha256=nKKSL3zBnSilkCnBbEM5QnV57mbBYo1L0zo3dy6boF4,344
+wavespeed/client.py,sha256=wOXgXewQSZEERt5CyLkAFM7KGX5SLi3vydykU7KssV4,4502
+wavespeed-0.0.1.dist-info/licenses/LICENSE,sha256=Ped14Wt87nPIhDPJxj5b8ZoHVHnktCBmJsSJ_Fov6KM,1068
+wavespeed-0.0.1.dist-info/METADATA,sha256=obdqF-AN4QSJ-EpTCyI61gLgwYZ3Oj5Oo5GluvoCINo,7761
+wavespeed-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+wavespeed-0.0.1.dist-info/top_level.txt,sha256=4S7lS5Vrdmel6Lg7UE5GK85WTaW_b8V_RxT59dAbV5I,10
+wavespeed-0.0.1.dist-info/RECORD,,

wavespeed-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wavespeed-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wavespeed AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wavespeed-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+wavespeed