Update app.py

app.py

@@ -2,6 +2,7 @@ import os
 import io
 import socket
 import requests
+import logging
 from fastapi import FastAPI, File, UploadFile, Form
 from fastapi.responses import FileResponse
 from PIL import Image
@@ -21,6 +22,19 @@ import random
 import time
 import tempfile
 
+logger = logging.getLogger(__name__)
+# Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+logger.setLevel(logging.DEBUG)
+file_handler = logging.FileHandler('inference.log')
+stream_handler = logging.StreamHandler(sys.stdout)
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+# Set the formatter for the stream handler (command line)
+stream_handler.setFormatter(formatter)
+
+# Add the file handler and stream handler to the logger
+logger.addHandler(file_handler)
+logger.addHandler(stream_handler)
+
 app = FastAPI()
 
 BASE_MODEL = "SG161222/Realistic_Vision_V5.1_noVAE"
@@ -94,7 +108,6 @@ def convert_to_base64(pil_image):
     base64_image = processing_utils.encode_pil_to_base64(pil_image)
     return base64_image
 
-# Inference function
 def inference(
     control_image: Image.Image,
     prompt: str,
@@ -108,56 +121,73 @@ def inference(
     sampler = "DPM++ Karras SDE",
     #profile: gr.OAuthProfile | None = None,
 ):
-    start_time = time.time()
-    start_time_struct = time.localtime(start_time)
-    start_time_formatted = time.strftime("%H:%M:%S", start_time_struct)
-    print(f"Inference started at {start_time_formatted}")
-    
-    # Generate the initial image
-    #init_image = init_pipe(prompt).images[0]
 
-    # Rest of your existing code
-    control_image_small = center_crop_resize(control_image)
-    control_image_large = center_crop_resize(control_image, (1024, 1024))
+    try:
+        # Log input types and values
+        logger.debug("Input Types: control_image=%s, prompt=%s, negative_prompt=%s, guidance_scale=%s, controlnet_conditioning_scale=%s, control_guidance_start=%s, control_guidance_end=%s, upscaler_strength=%s, seed=%s, sampler=%s",
+                    type(control_image), type(prompt), type(negative_prompt), type(guidance_scale), type(controlnet_conditioning_scale),
+                    type(control_guidance_start), type(control_guidance_end), type(upscaler_strength), type(seed), type(sampler))
+        logger.debug("Input Values: control_image=%s, prompt=%s, negative_prompt=%s, guidance_scale=%s, controlnet_conditioning_scale=%s, control_guidance_start=%s, control_guidance_end=%s, upscaler_strength=%s, seed=%s, sampler=%s",
+                    control_image, prompt, negative_prompt, guidance_scale, controlnet_conditioning_scale,
+                    control_guidance_start, control_guidance_end, upscaler_strength, seed, sampler)
+
+        start_time = time.time()
+        start_time_struct = time.localtime(start_time)
+        start_time_formatted = time.strftime("%H:%M:%S", start_time_struct)
+        logger.info(f"Inference started at {start_time_formatted}")
 
-    main_pipe.scheduler = SAMPLER_MAP[sampler](main_pipe.scheduler.config)
-    my_seed = random.randint(0, 2**32 - 1) if seed == -1 else seed
-    generator = torch.Generator(device="cuda").manual_seed(my_seed)
     
-    out = main_pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        image=control_image_small,
-        guidance_scale=float(guidance_scale),
-        controlnet_conditioning_scale=float(controlnet_conditioning_scale),
-        generator=generator,
-        control_guidance_start=float(control_guidance_start),
-        control_guidance_end=float(control_guidance_end),
-        num_inference_steps=15,
-        output_type="latent"
-    )
-    upscaled_latents = upscale(out, "nearest-exact", 2)
-    out_image = image_pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        control_image=control_image_large,        
-        image=upscaled_latents,
-        guidance_scale=float(guidance_scale),
-        generator=generator,
-        num_inference_steps=20,
-        strength=upscaler_strength,
-        control_guidance_start=float(control_guidance_start),
-        control_guidance_end=float(control_guidance_end),
-        controlnet_conditioning_scale=float(controlnet_conditioning_scale)
-    )
-    end_time = time.time()
-    end_time_struct = time.localtime(end_time)
-    end_time_formatted = time.strftime("%H:%M:%S", end_time_struct)
-    print(f"Inference ended at {end_time_formatted}, taking {end_time-start_time}s")
-
-    return out_image["images"][0]
+        # Generate the initial image
+        #init_image = init_pipe(prompt).images[0]
+    
+        # Rest of your existing code
+        control_image_small = center_crop_resize(control_image)
+        control_image_large = center_crop_resize(control_image, (1024, 1024))
+    
+        main_pipe.scheduler = SAMPLER_MAP[sampler](main_pipe.scheduler.config)
+        my_seed = random.randint(0, 2**32 - 1) if seed == -1 else seed
+        generator = torch.Generator(device="cuda").manual_seed(my_seed)
+        
+        out = main_pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            image=control_image_small,
+            guidance_scale=float(guidance_scale),
+            controlnet_conditioning_scale=float(controlnet_conditioning_scale),
+            generator=generator,
+            control_guidance_start=float(control_guidance_start),
+            control_guidance_end=float(control_guidance_end),
+            num_inference_steps=15,
+            output_type="latent"
+        )
+        upscaled_latents = upscale(out, "nearest-exact", 2)
+        out_image = image_pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            control_image=control_image_large,        
+            image=upscaled_latents,
+            guidance_scale=float(guidance_scale),
+            generator=generator,
+            num_inference_steps=20,
+            strength=upscaler_strength,
+            control_guidance_start=float(control_guidance_start),
+            control_guidance_end=float(control_guidance_end),
+            controlnet_conditioning_scale=float(controlnet_conditioning_scale)
+        )
+        end_time = time.time()
+        end_time_struct = time.localtime(end_time)
+        end_time_formatted = time.strftime("%H:%M:%S", end_time_struct)
+        print(f"Inference ended at {end_time_formatted}, taking {end_time-start_time}s")
+        logger.debug("Output Types: generated_image=%s", type(None))
+        logger.debug("Output Values: generated_image=None")
+        return out_image["images"][0]
+        
+    
+    except Exception as e:
+        # Handle exceptions and log error message
+        logger.error("Error occurred during inference: %s", str(e))
+        return str(e)
         
-import os
 
 def generate_image_from_parameters(prompt, guidance_scale, controlnet_scale, controlnet_end, upscaler_strength, seed, sampler_type, image):
     try: