t2i ok, i2i bork

app.py

@@ -24,31 +24,53 @@ def text_to_image_fn(prompt, model, negative_prompt=None, guidance_scale=7.5, nu
             num_inference_steps=num_inference_steps
         )
         
+        if image is None:
+            return None, "No image was generated. Check the model and parameters."
+        
         return image, None
     except Exception as e:
-        return None, str(e)
+        error_msg = f"Error: {str(e)}"
+        print(error_msg)
+        return None, error_msg
 
 def image_to_image_fn(image, prompt, model, negative_prompt=None, guidance_scale=7.5, num_inference_steps=50):
     """
     Handle image to image transformation request
     """
+    if image is None:
+        return None, "No input image provided."
+    
+    if not prompt:
+        prompt = ""
+    
+    if not model:
+        model = config.DEFAULT_IMG2IMG_MODEL
+    
+    print(f"Input type: {type(image)}")
+    print(f"Processing image-to-image with prompt: '{prompt}', model: {model}")
+    
     try:
-        if not model:
-            model = config.DEFAULT_IMG2IMG_MODEL
-            
-        # Call the inference module
+        # Call the inference module with explicit parameters
         result = inference.image_to_image(
             image=image,
             prompt=prompt,
             model_name=model,
-            negative_prompt=negative_prompt,
-            guidance_scale=guidance_scale,
-            num_inference_steps=num_inference_steps
+            negative_prompt=negative_prompt if negative_prompt else None,
+            guidance_scale=float(guidance_scale),
+            num_inference_steps=int(num_inference_steps)
         )
         
+        if result is None:
+            return None, "No image was generated. Check the model and parameters."
+        
         return result, None
     except Exception as e:
-        return None, str(e)
+        error_msg = f"Error: {str(e)}"
+        print(error_msg)
+        print(f"Input image type: {type(image)}")
+        print(f"Prompt: {prompt}")
+        print(f"Model: {model}")
+        return None, error_msg
 
 # Create Gradio UI
 with gr.Blocks(title="Diffusion Models") as app:

inference.py

@@ -30,20 +30,29 @@ class DiffusionInference:
         """
         model = model_name or config.DEFAULT_TEXT2IMG_MODEL
         
-        # Set up parameters dictionary
-        params = {"prompt": prompt}
+        # Create parameters dictionary for all keyword arguments
+        params = {
+            "prompt": prompt,
+            "model": model
+        }
         
-        if negative_prompt:
+        # Add negative prompt if provided
+        if negative_prompt is not None:
             params["negative_prompt"] = negative_prompt
-            
-        # Add any additional parameters
-        params.update(kwargs)
+        
+        # Add any other parameters
+        for k, v in kwargs.items():
+            if k not in ["prompt", "model", "negative_prompt"]:
+                params[k] = v
         
         try:
-            image = self.client.text_to_image(model=model, **params)
+            # Call the API with all parameters as kwargs
+            image = self.client.text_to_image(**params)
             return image
         except Exception as e:
             print(f"Error generating image: {e}")
+            print(f"Model: {model}")
+            print(f"Prompt: {prompt}")
             raise
 
     def image_to_image(self, image, prompt=None, model_name=None, negative_prompt=None, **kwargs):
@@ -60,27 +69,65 @@ class DiffusionInference:
         Returns:
             PIL.Image: The generated image
         """
+        import tempfile
+        import os
+        
         model = model_name or config.DEFAULT_IMG2IMG_MODEL
         
-        # Convert image path to PIL Image if needed
-        if isinstance(image, str):
-            image = Image.open(image)
+        # Create a temporary file for the image if it's a PIL Image
+        temp_file = None
+        try:
+            # Handle different image input types
+            if isinstance(image, str):
+                # If it's already a file path, use it directly
+                image_path = image
+            elif isinstance(image, Image.Image):
+                # If it's a PIL Image, save it to a temporary file
+                temp_dir = tempfile.gettempdir()
+                temp_file = os.path.join(temp_dir, "temp_image.png")
+                image.save(temp_file, format="PNG")
+                image_path = temp_file
+            else:
+                # If it's something else, try to convert it to a PIL Image first
+                try:
+                    pil_image = Image.fromarray(image)
+                    temp_dir = tempfile.gettempdir()
+                    temp_file = os.path.join(temp_dir, "temp_image.png")
+                    pil_image.save(temp_file, format="PNG")
+                    image_path = temp_file
+                except Exception as e:
+                    raise ValueError(f"Unsupported image type: {type(image)}. Error: {e}")
             
-        # Set up parameters dictionary
-        params = {"image": image}
-        
-        if prompt:
-            params["prompt"] = prompt
+            # Create a parameters dictionary including all the required keyword args
+            params = {"model": model}
             
-        if negative_prompt:
-            params["negative_prompt"] = negative_prompt
+            # Add prompt if provided (MUST be as a keyword arg, not positional)
+            if prompt is not None:
+                params["prompt"] = prompt
+                
+            # Add negative_prompt if provided
+            if negative_prompt is not None:
+                params["negative_prompt"] = negative_prompt
+                
+            # Add additional parameters
+            for k, v in kwargs.items():
+                if k not in ["prompt", "model", "negative_prompt", "image"]:
+                    params[k] = v
             
-        # Add any additional parameters
-        params.update(kwargs)
-        
-        try:
-            result = self.client.image_to_image(model=model, **params)
+            # Make the API call with image as the only positional arg, all others as kwargs
+            result = self.client.image_to_image(image_path, **params)
             return result
+            
         except Exception as e:
             print(f"Error transforming image: {e}")
+            print(f"Model: {model}")
+            print(f"Prompt: {prompt}")
             raise
+            
+        finally:
+            # Clean up the temporary file if it was created
+            if temp_file and os.path.exists(temp_file):
+                try:
+                    os.remove(temp_file)
+                except Exception as e:
+                    print(f"Warning: Could not delete temporary file {temp_file}: {e}")