feat: photoMaker in imageInference, IIpAdapter (guideImages, etc.), IEmbedding weight, dict coercion for nested options

Sirsho1997 · Sirsho1997 · commit 6ea7401be7ee · 2026-03-04T22:10:50.000-05:00
diff --git a/runware/base.py b/runware/base.py
@@ -734,7 +734,9 @@ async def _imageInference(
                 ip_adapter_data = {
                     k: v for k, v in vars(ip_adapter).items() if v is not None
                 }
-                if "guideImage" in ip_adapter_data:
+                if "guideImages" in ip_adapter_data:
+                    ip_adapter_data["guideImages"] = await process_image(ip_adapter_data["guideImages"])
+                elif "guideImage" in ip_adapter_data:
                     ip_adapter_data["guideImage"] = await process_image(ip_adapter_data["guideImage"])
                 ip_adapters_data.append(ip_adapter_data)
 
@@ -762,9 +764,17 @@ async def _imageInference(
             if requestImage.puLID.inputImages:
                 pulid_data["inputImages"] = await process_image(requestImage.puLID.inputImages)
 
+        photo_maker_data = {}
+        if requestImage.photoMaker:
+            photo_maker_data = {"images": []}
+            if requestImage.photoMaker.style is not None:
+                photo_maker_data["style"] = requestImage.photoMaker.style
+            if requestImage.photoMaker.images:
+                photo_maker_data["images"] = await process_image(requestImage.photoMaker.images)
+
         request_object = self._buildImageRequest(
             requestImage, prompt, control_net_data_dicts,
-            instant_id_data, ip_adapters_data, ace_plus_plus_data, pulid_data
+            instant_id_data, ip_adapters_data, ace_plus_plus_data, pulid_data, photo_maker_data
         )
 
         delivery_method_enum = EDeliveryMethod(requestImage.deliveryMethod) if isinstance(requestImage.deliveryMethod,
@@ -2356,7 +2366,7 @@ def is_text_complete(r: "Dict[str, Any]") -> bool:
         finally:
             await self._unregister_pending_operation(task_uuid)
 
-    def _buildImageRequest(self, requestImage: IImageInference, prompt: Optional[str], control_net_data_dicts: List[Dict], instant_id_data: Optional[Dict], ip_adapters_data: Optional[List[Dict]], ace_plus_plus_data: Optional[Dict], pulid_data: Optional[Dict]) -> Dict[str, Any]:
+    def _buildImageRequest(self, requestImage: IImageInference, prompt: Optional[str], control_net_data_dicts: List[Dict], instant_id_data: Optional[Dict], ip_adapters_data: Optional[List[Dict]], ace_plus_plus_data: Optional[Dict], pulid_data: Optional[Dict], photo_maker_data: Optional[Dict]) -> Dict[str, Any]:
         request_object = {
             "taskType": ETaskType.IMAGE_INFERENCE.value,
             "taskUUID": requestImage.taskUUID,
@@ -2368,7 +2378,7 @@ def _buildImageRequest(self, requestImage: IImageInference, prompt: Optional[str
             request_object["positivePrompt"] = prompt
 
         self._addOptionalImageFields(request_object, requestImage)
-        self._addImageSpecialFields(request_object, requestImage, control_net_data_dicts, instant_id_data, ip_adapters_data, ace_plus_plus_data, pulid_data)
+        self._addImageSpecialFields(request_object, requestImage, control_net_data_dicts, instant_id_data, ip_adapters_data, ace_plus_plus_data, pulid_data, photo_maker_data)
         self._addOptionalField(request_object, requestImage.inputs)
         self._addImageProviderSettings(request_object, requestImage)
         self._addOptionalField(request_object, requestImage.ultralytics)
@@ -2396,7 +2406,7 @@ def _addOptionalImageFields(self, request_object: Dict[str, Any], requestImage:
                 else:
                     request_object[field] = value
 
-    def _addImageSpecialFields(self, request_object: Dict[str, Any], requestImage: IImageInference, control_net_data_dicts: List[Dict], instant_id_data: Optional[Dict], ip_adapters_data: Optional[List[Dict]], ace_plus_plus_data: Optional[Dict], pulid_data: Optional[Dict]) -> None:
+    def _addImageSpecialFields(self, request_object: Dict[str, Any], requestImage: IImageInference, control_net_data_dicts: List[Dict], instant_id_data: Optional[Dict], ip_adapters_data: Optional[List[Dict]], ace_plus_plus_data: Optional[Dict], pulid_data: Optional[Dict], photo_maker_data: Optional[Dict]) -> None:
         # Add controlNet if present
         if control_net_data_dicts:
             request_object["controlNet"] = control_net_data_dicts
@@ -2456,6 +2466,10 @@ def _addImageSpecialFields(self, request_object: Dict[str, Any], requestImage: I
         if pulid_data:
             request_object["puLID"] = pulid_data
 
+        # Add photoMaker if present 
+        if photo_maker_data:
+            request_object["photoMaker"] = photo_maker_data
+
         # Add referenceImages if present
         if requestImage.referenceImages:
             request_object["referenceImages"] = requestImage.referenceImages
diff --git a/runware/types.py b/runware/types.py
@@ -184,6 +184,7 @@ class ILycoris:
 @dataclass
 class IEmbedding:
     model: str
+    weight: Optional[float] = None  
 
 
 @dataclass
@@ -353,22 +354,9 @@ def __post_init__(self):
             raise ValueError("inputImages can contain a maximum of 4 elements.")
 
         # Validate `style` to ensure it matches one of the allowed case-sensitive options
-        valid_styles = {
-            "No style",
-            "Cinematic",
-            "Disney Character",
-            "Digital Art",
-            "Photographic",
-            "Fantasy art",
-            "Neonpunk",
-            "Enhance",
-            "Comic book",
-            "Lowpoly",
-            "Line art",
-        }
-        if self.style and self.style not in valid_styles:
+        if self.style and self.style not in _PHOTO_MAKER_VALID_STYLES:
             raise ValueError(
-                f"style must be one of the following: {', '.join(valid_styles)}."
+                f"style must be one of the following: {', '.join(sorted(_PHOTO_MAKER_VALID_STYLES))}."
             )
 
 
@@ -417,8 +405,13 @@ class IInstantID:
 @dataclass
 class IIpAdapter:
     model: Union[int, str]
-    guideImage: Union[File, str]
+    guideImage: Optional[Union[File, str]] = None
+    guideImages: Optional[List[Union[str, File]]] = None
     weight: Optional[float] = None
+    combineMethod: Optional[str] = None
+    weightType: Optional[str] = None
+    embedScaling: Optional[str] = None
+    weightComposition: Optional[float] = None
 
 
 @dataclass
@@ -450,6 +443,24 @@ class IPuLID:
     CFGStartStepPercentage: Optional[int] = None  # Min: 0, Max: 100
 
 
+_PHOTO_MAKER_VALID_STYLES = {"No style", "Cinematic", "Disney Character", "Digital Art", "Photographic", "Fantasy art", "Neonpunk", "Enhance", "Comic book", "Lowpoly", "Line art"}
+
+
+@dataclass
+class IPhotoMakerSettings:
+
+    images: List[Union[str, File]] = field(default_factory=list)
+    style: Optional[str] = None
+
+    def __post_init__(self):
+        if len(self.images) > 4:
+            raise ValueError("photoMaker.images can contain a maximum of 4 elements.")
+        if self.style and self.style not in _PHOTO_MAKER_VALID_STYLES:
+            raise ValueError(
+                f"photoMaker.style must be one of: {', '.join(sorted(_PHOTO_MAKER_VALID_STYLES))}."
+            )
+
+
 @dataclass
 class IAcceleratorOptions(SerializableMixin):
     fbcache: Optional[bool] = None
@@ -938,22 +949,23 @@ class IImageInference:
     lycoris: Optional[List[ILycoris]] = field(default_factory=list)
     includeCost: Optional[bool] = None
     onPartialImages: Optional[Callable[[List[IImage], Optional[IError]], None]] = None
-    refiner: Optional[IRefiner] = None
+    refiner: Optional[Union[IRefiner, Dict[str, Any]]] = None
     vae: Optional[str] = None
     maskMargin: Optional[int] = None
     outputQuality: Optional[int] = None
-    embeddings: Optional[List[IEmbedding]] = field(default_factory=list)
-    outpaint: Optional[IOutpaint] = None
-    instantID: Optional[IInstantID] = None
+    embeddings: Optional[List[Union[IEmbedding, Dict[str, Any]]]] = field(default_factory=list)
+    outpaint: Optional[Union[IOutpaint, Dict[str, Any]]] = None
+    instantID: Optional[Union[IInstantID, Dict[str, Any]]] = None
     ipAdapters: Optional[List[IIpAdapter]] = field(default_factory=list)
     referenceImages: Optional[List[Union[str, File]]] = field(default_factory=list)
-    acePlusPlus: Optional[IAcePlusPlus] = None
-    puLID: Optional[IPuLID] = None
+    acePlusPlus: Optional[Union[IAcePlusPlus, Dict[str, Any]]] = None
+    puLID: Optional[Union[IPuLID, Dict[str, Any]]] = None
+    photoMaker: Optional[Union[IPhotoMakerSettings, Dict[str, Any]]] = None
     providerSettings: Optional[ImageProviderSettings] = None
     safety: Optional[Union[ISafety, Dict[str, Any]]] = None
     settings: Optional[Union[ISettings, Dict[str, Any]]] = None
     inputs: Optional[Union[IInputs, Dict[str, Any]]] = None
-    ultralytics: Optional[IUltralytics] = None
+    ultralytics: Optional[Union[IUltralytics, Dict[str, Any]]] = None
     useCache: Optional[bool] = None
     resolution: Optional[str] = None
     extraArgs: Optional[Dict[str, Any]] = field(default_factory=dict)
@@ -967,6 +979,30 @@ def __post_init__(self):
             self.settings = ISettings(**self.settings)
         if self.inputs is not None and isinstance(self.inputs, dict):
             self.inputs = IInputs(**self.inputs)
+        if self.outpaint is not None and isinstance(self.outpaint, dict):
+            self.outpaint = IOutpaint(**self.outpaint)
+        if self.refiner is not None and isinstance(self.refiner, dict):
+            self.refiner = IRefiner(**self.refiner)
+        if self.embeddings:
+            self.embeddings = [
+                IEmbedding(**item) if isinstance(item, dict) else item
+                for item in self.embeddings
+            ]
+        if self.photoMaker is not None and isinstance(self.photoMaker, dict):
+            self.photoMaker = IPhotoMakerSettings(**self.photoMaker)
+        if self.instantID is not None and isinstance(self.instantID, dict):
+            self.instantID = IInstantID(**self.instantID)
+        if self.acePlusPlus is not None and isinstance(self.acePlusPlus, dict):
+            self.acePlusPlus = IAcePlusPlus(**self.acePlusPlus)
+        if self.puLID is not None and isinstance(self.puLID, dict):
+            self.puLID = IPuLID(**self.puLID)
+        if self.ultralytics is not None and isinstance(self.ultralytics, dict):
+            self.ultralytics = IUltralytics(**self.ultralytics)
+        if self.ipAdapters:
+            self.ipAdapters = [
+                IIpAdapter(**item) if isinstance(item, dict) else item
+                for item in self.ipAdapters
+            ]
 
 
 @dataclass
