Merge pull request #143 from Runware/openai-models

New openai models

Author: teith

README.md

@@ -429,6 +429,82 @@ async def main() -> None:
 ```
 This example demonstrates how to configure and use a ControlNet to enhance the image inference process.
 
+### Generating Images with OpenAI Models (DALL-E 2 & DALL-E 3)
+
+The Runware SDK supports OpenAI's DALL-E 2 and DALL-E 3 models for image generation. These models offer high-quality image generation with various configuration options.
+
+#### DALL-E 2
+
+```python
+from runware import Runware, IImageInference, IOpenAIProviderSettings
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    # DALL-E 2 configuration
+    provider_settings = IOpenAIProviderSettings(
+        quality="high",
+        background="transparent"  # Optional: for transparent backgrounds
+    )
+
+    request_image = IImageInference(
+        positivePrompt="A cute cartoon robot character",
+        model="openai:1@1",  # DALL-E 2 model identifier
+        width=1024,
+        height=1024,
+        numberResults=1,
+        outputFormat="PNG",
+        includeCost=True,
+        providerSettings=provider_settings
+    )
+
+    images = await runware.imageInference(requestImage=request_image)
+    for image in images:
+        print(f"Image URL: {image.imageURL}")
+```
+
+#### DALL-E 3
+
+```python
+from runware import Runware, IImageInference, IOpenAIProviderSettings
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    # DALL-E 3 with HD quality
+    provider_settings = IOpenAIProviderSettings(
+        quality="hd"  # Options: "hd" or "standard"
+    )
+
+    request_image = IImageInference(
+        positivePrompt="A futuristic city with flying cars, highly detailed",
+        model="openai:2@3",  # DALL-E 3 model identifier
+        width=1024,
+        height=1024,
+        numberResults=1,
+        outputFormat="PNG",
+        includeCost=True,
+        providerSettings=provider_settings
+    )
+
+    images = await runware.imageInference(requestImage=request_image)
+    for image in images:
+        print(f"Image URL: {image.imageURL}")
+```
+
+**OpenAI Provider Settings:**
+- `quality`: Image quality setting
+  - DALL-E 2: `"high"` (recommended)
+  - DALL-E 3: `"hd"` or `"standard"`
+- `background`: (DALL-E 2 only) Set to `"transparent"` for transparent backgrounds
+- `style`: (Optional) Additional style parameters
+
+**Model Identifiers:**
+- DALL-E 2: `"openai:1@1"`
+- DALL-E 3: `"openai:2@3"`
+
 
 ### Inferencing Video Models
 

examples/openai/dall-e2.py

@@ -0,0 +1,76 @@
+import asyncio
+import os
+from dotenv import load_dotenv
+from runware import Runware, IImageInference, IOpenAIProviderSettings, RunwareAPIError
+
+load_dotenv()
+
+RUNWARE_API_KEY = os.environ.get("RUNWARE_API_KEY")
+
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    # DALL-E 2 with standard settings
+    provider_settings = IOpenAIProviderSettings(
+        quality="high"
+    )
+
+    request_image = IImageInference(
+        positivePrompt="A serene landscape with mountains and a crystal clear lake at sunset",
+        model="openai:1@1",
+        width=1024,
+        height=1024,
+        numberResults=1,
+        outputFormat="PNG",
+        outputQuality=95,
+        includeCost=True,
+        providerSettings=provider_settings
+    )
+
+    try:
+        images = await runware.imageInference(requestImage=request_image)
+        for image in images:
+            print(f"Image URL: {image.imageURL}")
+            if image.cost:
+                print(f"Cost: ${image.cost}")
+    except RunwareAPIError as e:
+        print(f"API Error: {e}")
+        print(f"Error Code: {e.code}")
+    except Exception as e:
+        print(f"Unexpected Error: {e}")
+
+    # DALL-E 2 with transparent background
+    provider_settings_transparent = IOpenAIProviderSettings(
+        quality="high",
+        background="transparent"
+    )
+
+    request_image_transparent = IImageInference(
+        positivePrompt="A cute cartoon robot character with big eyes, isolated on transparent background",
+        model="openai:1@1",
+        width=1024,
+        height=1024,
+        numberResults=1,
+        outputFormat="PNG",
+        outputQuality=95,
+        includeCost=True,
+        providerSettings=provider_settings_transparent
+    )
+
+    try:
+        images = await runware.imageInference(requestImage=request_image_transparent)
+        for image in images:
+            print(f"Image URL (transparent): {image.imageURL}")
+            if image.cost:
+                print(f"Cost: ${image.cost}")
+    except RunwareAPIError as e:
+        print(f"API Error: {e}")
+        print(f"Error Code: {e.code}")
+    except Exception as e:
+        print(f"Unexpected Error: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/openai/dall-e3.py

@@ -0,0 +1,77 @@
+import asyncio
+import os
+
+from dotenv import load_dotenv
+from runware import Runware, IImageInference, IOpenAIProviderSettings, RunwareAPIError
+
+load_dotenv()
+
+RUNWARE_API_KEY = os.environ.get("RUNWARE_API_KEY")
+
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    # DALL-E 3 with HD quality
+    provider_settings_hd = IOpenAIProviderSettings(
+        quality="hd"
+    )
+
+    request_image_hd = IImageInference(
+        positivePrompt="A futuristic city with flying cars and neon lights, cyberpunk aesthetic, highly detailed",
+        model="openai:2@3",
+        width=1024,
+        height=1024,
+        numberResults=1,
+        outputFormat="PNG",
+        outputQuality=95,
+        includeCost=True,
+        providerSettings=provider_settings_hd
+    )
+
+    try:
+        images = await runware.imageInference(requestImage=request_image_hd)
+        for image in images:
+            print(f"Image URL (HD): {image.imageURL}")
+            if image.cost:
+                print(f"Cost: ${image.cost}")
+    except RunwareAPIError as e:
+        print(f"API Error: {e}")
+        print(f"Error Code: {e.code}")
+    except Exception as e:
+        print(f"Unexpected Error: {e}")
+
+    # DALL-E 3 with standard quality
+    provider_settings_standard = IOpenAIProviderSettings(
+        quality="standard",
+        style="ghibli style"
+    )
+
+    request_image_standard = IImageInference(
+        positivePrompt="A whimsical tea party in a magical forest with talking animals",
+        model="openai:2@3",
+        width=1024,
+        height=1024,
+        numberResults=1,
+        outputFormat="PNG",
+        outputQuality=95,
+        includeCost=True,
+        providerSettings=provider_settings_standard
+    )
+
+    try:
+        images = await runware.imageInference(requestImage=request_image_standard)
+        for image in images:
+            print(f"Image URL (Standard): {image.imageURL}")
+            if image.cost:
+                print(f"Cost: ${image.cost}")
+    except RunwareAPIError as e:
+        print(f"API Error: {e}")
+        print(f"Error Code: {e.code}")
+    except Exception as e:
+        print(f"Unexpected Error: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/openai/image_1.py

@@ -0,0 +1,46 @@
+import asyncio
+import os
+
+from dotenv import load_dotenv
+from runware import Runware, IImageInference, IOpenAIProviderSettings, RunwareAPIError
+
+load_dotenv()
+
+RUNWARE_API_KEY = os.environ.get("RUNWARE_API_KEY")
+
+
+async def main() -> None:
+    runware = Runware(api_key=RUNWARE_API_KEY)
+    await runware.connect()
+
+    provider_settings_hd = IOpenAIProviderSettings(
+        quality="high",
+        style="cyberpunk"
+    )
+
+    request_image_hd = IImageInference(
+        positivePrompt="A futuristic city with flying cars and neon lights, cyberpunk aesthetic, highly detailed",
+        model="openai:1@1",
+        width=1024,
+        height=1024,
+        numberResults=1,
+        outputFormat="PNG",
+        outputQuality=95,
+        includeCost=True,
+        providerSettings=provider_settings_hd
+    )
+
+    try:
+        images = await runware.imageInference(requestImage=request_image_hd)
+        for image in images:
+            print(f"Image URL (high): {image.imageURL}")
+            if image.cost:
+                print(f"Cost: ${image.cost}")
+    except RunwareAPIError as e:
+        print(f"API Error: {e}")
+        print(f"Error Code: {e.code}")
+    except Exception as e:
+        print(f"Unexpected Error: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

runware/__init__.py

@@ -6,4 +6,4 @@
 from .async_retry import *
 
 __all__ = ["Runware"]
-__version__ = "0.4.17"
+__version__ = "0.4.18"

runware/base.py

@@ -459,6 +459,11 @@ async def imageInference(
 
             if requestImage.outputQuality:
                 request_object["outputQuality"] = requestImage.outputQuality
+
+            if requestImage.providerSettings:
+                provider_data = requestImage.providerSettings.to_request_dict()
+                request_object.update(provider_data)
+
             return await asyncRetry(
                 lambda: self._requestImages(
                     request_object=request_object,

runware/types.py

@@ -397,6 +397,37 @@ class IAdvancedFeatures:
     fluxKontext: Optional[IFluxKontext] = None
 
 
+class SerializableMixin:
+    def serialize(self) -> Dict[str, Any]:
+        return {k: v for k, v in asdict(self).items()
+                if v is not None and not k.startswith('_')}
+
+@dataclass
+class BaseProviderSettings(SerializableMixin, ABC):
+    @property
+    @abstractmethod
+    def provider_key(self) -> str:
+        pass
+
+    def to_request_dict(self) -> Dict[str, Any]:
+        data = self.serialize()
+        if data:
+            return {self.provider_key: data}
+        return {}
+
+@dataclass
+class IOpenAIProviderSettings(BaseProviderSettings):
+    quality: Optional[str] = None
+    background: Optional[str] = None
+    style: Optional[str] = None
+
+    @property
+    def provider_key(self) -> str:
+        return "openai"
+
+ImageProviderSettings = IOpenAIProviderSettings
+
+
 @dataclass
 class IImageInference:
     positivePrompt: str
@@ -437,6 +468,7 @@ class IImageInference:
     ipAdapters: Optional[List[IIpAdapter]] = field(default_factory=list)
     referenceImages: Optional[List[Union[str, File]]] = field(default_factory=list)
     acePlusPlus: Optional[IAcePlusPlus] = None
+    providerSettings: Optional[ImageProviderSettings] = None
     extraArgs: Optional[Dict[str, Any]] = field(default_factory=dict)
 
 
@@ -589,24 +621,8 @@ class IFrameImage:
     frame: Optional[Union[Literal["first", "last"], int]] = None
 
 
-class SerializableMixin:
-    def serialize(self) -> Dict[str, Any]:
-        return {k: v for k, v in asdict(self).items()
-                if v is not None and not k.startswith('_')}
 
 
-@dataclass
-class BaseProviderSettings(SerializableMixin, ABC):
-    @property
-    @abstractmethod
-    def provider_key(self) -> str:
-        pass
-
-    def to_request_dict(self) -> Dict[str, Any]:
-        data = self.serialize()
-        if data:
-            return {self.provider_key: data}
-        return {}
 
 
 @dataclass

setup.py

@@ -6,7 +6,7 @@
 setup(
     name="runware",
     license="MIT",
-    version="0.4.17",
+    version="0.4.18",
     author="Runware Inc.",
     author_email="python.sdk@runware.ai",
     description="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 images 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.",