wavespeed 0.0.1__tar.gz

wavespeed-0.0.1/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,233 @@
+# 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/pyproject.toml

@@ -0,0 +1,93 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wavespeed"
+version = "0.0.1"
+description = "Python client for Wavespeed"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Wavespeed, Inc." }]
+requires-python = ">=3.8"
+dependencies = [
+    "httpx>=0.21.0,<1",
+    "packaging",
+    "pydantic>1.10.7",
+    "typing_extensions>=4.5.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.1.1,<9",
+    "pylint>=3.1.0,<4",
+    "pyright>=1.1.358,<2",
+    "pytest-asyncio>=0.23.6,<1",
+    "pytest-recording>=0.13.1,<1",
+    "respx>=0.21.1,<1",
+    "ruff>=0.3.7,<1",
+]
+
+[project.urls]
+homepage = "https://wavespeed.ai"
+repository = "https://github.com/wavespeed-ai/wavespeed-python"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = "tests/"
+
+[tool.setuptools]
+packages = ["wavespeed"]
+
+[tool.setuptools.package-data]
+"wavespeed" = ["py.typed"]
+
+[tool.pylint.main]
+disable = [
+    "C0301", # Line too long
+    "C0413", # Import should be placed at the top of the module
+    "C0114", # Missing module docstring
+    "R0801", # Similar lines in N files
+    "W0212", # Access to a protected member
+    "W0622", # Redefining built-in
+    "R0903", # Too few public methods
+]
+good-names = ["id"]
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle error
+    "F",   # Pyflakes
+    "I",   # isort
+    "W",   # pycodestyle warning
+    "UP",  # pyupgrade
+    "S",   # flake8-bandit
+    "BLE", # flake8-blind-except
+    "FBT", # flake8-boolean-trap
+    "B",   # flake8-bugbear
+    "ANN", # flake8-annotations
+]
+ignore = [
+    "E501",   # Line too long
+    "S113",   # Probable use of requests call without timeout
+    "ANN001", # Missing type annotation for function argument
+    "ANN002", # Missing type annotation for `*args`
+    "ANN003", # Missing type annotation for `**kwargs`
+    "ANN101", # Missing type annotation for self in method
+    "ANN102", # Missing type annotation for cls in classmethod
+    "ANN401", # Dynamically typed expressions (typing.Any) are disallowed in {name}
+    "W191",   # Indentation contains tabs
+    "UP037",  # Remove quotes from type annotation
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = [
+    "S101",   # Use of assert
+    "S106",   # Possible use of hard-coded password function arguments
+    "ANN201", # Missing return type annotation for public function
+    "ANN202", # Missing return type annotation for private function
+]
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"

wavespeed-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+