runware 0.1.2__tar.gz

runware-0.1.2/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.1
+Name: runware
+Version: 0.1.2
+Summary: The Python Runware SDK is used to run image inference with the Runware API, powered by the RunWare inference platform. It can be used to generate imaged with text-to-image and image-to-image. It also allows the use of an existing gallery of models or selecting any model or LoRA from the CivitAI gallery. The API also supports upscaling, background removal, inpainting and outpainting, and a series of other ControlNet models.
+Home-page: https://github.com/runware/sdk-python
+Author: Runware Inc.
+Author-email: python.sdk@runware.ai
+License: MIT
+Project-URL: Documentation, https://docs.runware.ai/
+Project-URL: Changes, https://github.com/runware/sdk-python/releases
+Project-URL: Code, https://github.com/runware/sdk-python
+Project-URL: Issue tracker, https://github.com/runware/sdk-python/issues
+Keywords: Runware,stable diffusion,text to image,image to text
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiofiles==23.2.1
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: websockets==12.0
+
+# Python Runware SDK
+
+The Python Runware SDK is used to run image inference with the Runware API, powered by the RunWare inference platform. It can be used to generate imaged with text-to-image and image-to-image. It also allows the use of an existing gallery of models or selecting any model or LoRA from the CivitAI gallery. The API also supports upscaling, background removal, inpainting and outpainting, and a series of other ControlNet models.
+
+## Get API Access
+
+To use the Python Runware SDK, you need to obtain an API key. Follow these steps to get API access:
+
+1. [Create a free account](https://my.runware.ai/) with [Runware](https://runware.ai/).
+2. Once you have created an account, you will receive an API key and trial credits.
+
+**Important**: Please keep your API key private and do not share it with anyone. Treat it as a sensitive credential.
+
+## Documentation
+
+For detailed documentation and API reference, please visit the [Runware Documentation](https://docs.runware.ai/) or refer to the [docs](docs) folder in the repository. The documentation provides comprehensive information about the available classes, methods, and parameters, along with code examples to help you get started with the Runware SDK Python.
+
+## Installation
+
+To install the Python Runware SDK, use the following command:
+
+```bash
+pip install runware
+```
+
+## Usage
+
+Before using the Python Runware SDK, make sure to set your Runware API key in the environment variable `RUNWARE_API_KEY`. You can do this by creating a `.env` file in your project root and adding the following line:
+
+```bash
+RUNWARE_API_KEY = "your_api_key_here"
+```
+
+### Generating Images
+
+To generate images using the Runware API, you can use the `requestImages` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IRequestImage
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    request_image = IRequestImage(
+        positive_prompt="A beautiful sunset over the mountains",
+        image_size=1,
+        model_id=13,
+        number_of_images=5,
+        negative_prompt="cloudy, rainy",
+        use_cache=False,
+    )
+
+    images = await runware.requestImages(requestImage=request_image)
+    for image in images:
+        print(f"Image URL: {image.imageSrc}")
+```
+
+### Enhancing Prompts
+
+To enhance prompts using the Runware API, you can use the `enhancePrompt` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IPromptEnhancer
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    prompt = "A beautiful sunset over the mountains"
+    prompt_enhancer = IPromptEnhancer(
+        prompt=prompt,
+        prompt_versions=3,
+    )
+
+    enhanced_prompts = await runware.enhancePrompt(promptEnhancer=prompt_enhancer)
+    for enhanced_prompt in enhanced_prompts:
+        print(enhanced_prompt.text)
+```
+
+### Removing Image Background
+
+To remove the background from an image using the Runware API, you can use the `removeImageBackground` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IRemoveImageBackground
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    image_path = "image.jpg"
+    remove_image_background_payload = IRemoveImageBackground(image_initiator=image_path)
+
+    processed_images = await runware.removeImageBackground(
+        removeImageBackgroundPayload=remove_image_background_payload
+    )
+    for image in processed_images:
+        print(image.imageSrc)
+```
+
+### Image-to-Text Conversion
+
+To convert an image to text using the Runware API, you can use the `requestImageToText` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IRequestImageToText
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    image_path = "image.jpg"
+    request_image_to_text_payload = IRequestImageToText(image_initiator=image_path)
+
+    image_to_text = await runware.requestImageToText(
+        requestImageToText=request_image_to_text_payload
+    )
+    print(image_to_text.text)
+```
+
+### Upscaling Images
+
+To upscale an image using the Runware API, you can use the `upscaleGan` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IUpscaleGan
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    image_path = "image.jpg"
+    upscale_factor = 4
+
+    upscale_gan_payload = IUpscaleGan(
+        image_initiator=image_path, upscale_factor=upscale_factor
+    )
+    upscaled_images = await runware.upscaleGan(upscaleGanPayload=upscale_gan_payload)
+    for image in upscaled_images:
+        print(image.imageSrc)
+```
+
+For more detailed usage and additional examples, please refer to the examples directory.

runware-0.1.2/README.md

@@ -0,0 +1,144 @@
+# Python Runware SDK
+
+The Python Runware SDK is used to run image inference with the Runware API, powered by the RunWare inference platform. It can be used to generate imaged with text-to-image and image-to-image. It also allows the use of an existing gallery of models or selecting any model or LoRA from the CivitAI gallery. The API also supports upscaling, background removal, inpainting and outpainting, and a series of other ControlNet models.
+
+## Get API Access
+
+To use the Python Runware SDK, you need to obtain an API key. Follow these steps to get API access:
+
+1. [Create a free account](https://my.runware.ai/) with [Runware](https://runware.ai/).
+2. Once you have created an account, you will receive an API key and trial credits.
+
+**Important**: Please keep your API key private and do not share it with anyone. Treat it as a sensitive credential.
+
+## Documentation
+
+For detailed documentation and API reference, please visit the [Runware Documentation](https://docs.runware.ai/) or refer to the [docs](docs) folder in the repository. The documentation provides comprehensive information about the available classes, methods, and parameters, along with code examples to help you get started with the Runware SDK Python.
+
+## Installation
+
+To install the Python Runware SDK, use the following command:
+
+```bash
+pip install runware
+```
+
+## Usage
+
+Before using the Python Runware SDK, make sure to set your Runware API key in the environment variable `RUNWARE_API_KEY`. You can do this by creating a `.env` file in your project root and adding the following line:
+
+```bash
+RUNWARE_API_KEY = "your_api_key_here"
+```
+
+### Generating Images
+
+To generate images using the Runware API, you can use the `requestImages` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IRequestImage
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    request_image = IRequestImage(
+        positive_prompt="A beautiful sunset over the mountains",
+        image_size=1,
+        model_id=13,
+        number_of_images=5,
+        negative_prompt="cloudy, rainy",
+        use_cache=False,
+    )
+
+    images = await runware.requestImages(requestImage=request_image)
+    for image in images:
+        print(f"Image URL: {image.imageSrc}")
+```
+
+### Enhancing Prompts
+
+To enhance prompts using the Runware API, you can use the `enhancePrompt` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IPromptEnhancer
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    prompt = "A beautiful sunset over the mountains"
+    prompt_enhancer = IPromptEnhancer(
+        prompt=prompt,
+        prompt_versions=3,
+    )
+
+    enhanced_prompts = await runware.enhancePrompt(promptEnhancer=prompt_enhancer)
+    for enhanced_prompt in enhanced_prompts:
+        print(enhanced_prompt.text)
+```
+
+### Removing Image Background
+
+To remove the background from an image using the Runware API, you can use the `removeImageBackground` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IRemoveImageBackground
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    image_path = "image.jpg"
+    remove_image_background_payload = IRemoveImageBackground(image_initiator=image_path)
+
+    processed_images = await runware.removeImageBackground(
+        removeImageBackgroundPayload=remove_image_background_payload
+    )
+    for image in processed_images:
+        print(image.imageSrc)
+```
+
+### Image-to-Text Conversion
+
+To convert an image to text using the Runware API, you can use the `requestImageToText` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IRequestImageToText
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    image_path = "image.jpg"
+    request_image_to_text_payload = IRequestImageToText(image_initiator=image_path)
+
+    image_to_text = await runware.requestImageToText(
+        requestImageToText=request_image_to_text_payload
+    )
+    print(image_to_text.text)
+```
+
+### Upscaling Images
+
+To upscale an image using the Runware API, you can use the `upscaleGan` method of the `Runware` class. Here's an example:
+
+```python
+from runware import Runware, IUpscaleGan
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    image_path = "image.jpg"
+    upscale_factor = 4
+
+    upscale_gan_payload = IUpscaleGan(
+        image_initiator=image_path, upscale_factor=upscale_factor
+    )
+    upscaled_images = await runware.upscaleGan(upscaleGanPayload=upscale_gan_payload)
+    for image in upscaled_images:
+        print(image.imageSrc)
+```
+
+For more detailed usage and additional examples, please refer to the examples directory.

runware-0.1.2/runware/__init__.py

@@ -0,0 +1,10 @@
+from .server import RunwareServer as Runware
+from .types import IRemoveImageBackground
+from .types import *
+from .utils import *
+from .base import *
+from .logging_config import *
+from .async_retry import *
+
+__all__ = ["Runware", "IRemoveImageBackground"]
+__version__ = "0.1.0"

runware-0.1.2/runware/async_retry.py

@@ -0,0 +1,96 @@
+import asyncio
+
+
+async def asyncRetry(apiCall, options=None):
+    """
+    Retry an asynchronous API call multiple times with configurable options.
+
+    :param apiCall: The asynchronous function to be retried.
+    :param options: An optional dictionary that allows you to configure the retry behavior.
+                    It has the following properties:
+                    - maxRetries: The maximum number of retries before giving up (default is 1).
+                    - delayInSeconds: The delay in seconds between each retry attempt (default is 1).
+                    - callback: A function that will be called after each failed attempt.
+    :return: The result of the successful API call.
+
+    This function retries an asynchronous API call multiple times with configurable options.
+    It attempts to execute the `apiCall` and returns the result if successful. If the `apiCall`
+    raises an exception, it calls the `callback` function (if provided), introduces a delay
+    before the next retry attempt, and continues retrying until the maximum number of retries
+    is reached. If all retry attempts are exhausted and the `apiCall` still fails, it raises
+    the last encountered exception.
+
+    Example:
+        async def myApiCall():
+            # API call logic here
+            ...
+
+        result = await asyncRetry(myApiCall, options={
+            'maxRetries': 3,
+            'delayInSeconds': 1,
+            'callback': lambda: print('Retry attempt failed')
+        })
+        print(result)
+    """
+    if options is None:
+        options = {}
+    delayInSeconds = options.get("delayInSeconds", 1)
+    callback = options.get("callback")
+    maxRetries = options.get("maxRetries", 1)
+
+    for attempt in range(maxRetries):
+        try:
+            return await apiCall()
+        except Exception as error:
+            if callback:
+                callback()
+            if attempt < maxRetries - 1:
+                await asyncio.sleep(delayInSeconds)
+            else:
+                raise error
+
+
+async def asyncRetryGather(apiCalls, options=None):
+    """
+    Retry multiple asynchronous API calls concurrently with configurable options.
+
+    :param apiCalls: A list of asynchronous functions to be retried.
+    :param options: An optional dictionary that allows you to configure the retry behavior.
+                    It has the following properties:
+                    - maxRetries: The maximum number of retries before giving up (default is 1).
+                    - delayInSeconds: The delay in seconds between each retry attempt (default is 1).
+                    - callback: A function that will be called after each failed attempt.
+    :return: A list of results from the successful API calls.
+
+    This function retries multiple asynchronous API calls concurrently with configurable options.
+    It creates tasks for each `apiCall` and executes them concurrently using `asyncio.gather()`.
+    Each task represents the execution of `asyncRetry` for a single `apiCall`. The results of
+    each successful API call are returned as a list in the same order as the input `apiCalls`.
+
+    Example:
+        async def myApiCall1():
+            # API call logic here
+            ...
+
+        async def myApiCall2():
+            # API call logic here
+            ...
+
+        results = await asyncRetryGather([myApiCall1, myApiCall2], options={
+            'maxRetries': 3,
+            'delayInSeconds': 1,
+            'callback': lambda: print('Retry attempt failed')
+        })
+        print(results)
+    """
+    if options is None:
+        options = {}
+    delayInSeconds = options.get("delayInSeconds", 1)
+    callback = options.get("callback")
+    maxRetries = options.get("maxRetries", 1)
+
+    tasks = []
+    for apiCall in apiCalls:
+        task = asyncio.create_task(asyncRetry(apiCall, options))
+        tasks.append(task)
+    return await asyncio.gather(*tasks)