.

app.py

@@ -1,108 +1,66 @@
 import os
-import torch
 import uuid
+import base64
+import requests
+from PIL import Image
+from io import BytesIO
 from pathlib import Path
 import gradio as gr
 from gradio_imageslider import ImageSlider  # Ensure this library is installed
+from dotenv import load_dotenv
 
-if os.environ.get("SPACES_ZERO_GPU") is not None:
-    import spaces
-else:
-    class spaces:
-        @staticmethod
-        def GPU(func):
-            def wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
+# Load environment variables from the .env file
+load_dotenv()
 
-            return wrapper
+# Get API key from environment variable
+api_key = os.getenv('API_KEY')
 
-from diffusers.utils import check_min_version
-from flux.controlnet_flux import FluxControlNetModel
-from flux.transformer_flux import FluxTransformer2DModel
-from flux.pipeline_flux_controlnet_inpaint import FluxControlNetInpaintingPipeline
+# Funzione per chiamare l'endpoint di predizione FastAPI
+def process_image(input_image_editor):
+    input_image = input_image_editor['background']
+    mask_image = input_image_editor['layers'][0]
 
-# Import configuration
-import config
+    # Converti le immagini in base64
+    buffered_input = BytesIO()
+    input_image.save(buffered_input, format="PNG")
+    input_image_base64 = base64.b64encode(buffered_input.getvalue()).decode()
 
-# Define the output folder
-output_folder = Path('output_images')
-output_folder.mkdir(exist_ok=True)
+    buffered_mask = BytesIO()
+    mask_image.save(buffered_mask, format="PNG")
+    mask_image_base64 = base64.b64encode(buffered_mask.getvalue()).decode()
 
-# Login to Hugging Face Hub
-# huggingface_hub.login(os.getenv('HF_TOKEN_FLUX'))
-check_min_version("0.30.2")
+    # Prepara il payload per la richiesta POST
+    payload = {
+        "input_image_editor": {
+            "background": input_image_base64,
+            "layers": [mask_image_base64]
+        }
+    }
+
+    # Effettua la richiesta POST al backend FastAPI
+    response = requests.post(
+        os.getenv('BACKEND_URL') + "/predict/",
+        headers={"access_token": api_key},
+        json=payload
+    )
+
+    if response.status_code == 200:
+        result = response.json()
+        processed_image_base64 = result['processed_image']
+        processed_image = Image.open(BytesIO(base64.b64decode(processed_image_base64)))
+
+        # Save the processed image
+        output_folder = Path("output")  # Make sure this folder exists or create it
+        output_folder.mkdir(parents=True, exist_ok=True)
+        image_path = output_folder / f"no_bg_image_{uuid.uuid4().hex}.png"
+        processed_image.save(image_path)
+
+        return (processed_image, input_image), str(image_path)
+
+    else:
+        raise Exception(f"Request failed with status code {response.status_code}")
 
-# Load models
-transformer = FluxTransformer2DModel.from_pretrained(
-    "black-forest-labs/FLUX.1-dev", subfolder='transformer', torch_dtype=torch.bfloat16
-)
-controlnet = FluxControlNetModel.from_pretrained(
-    "alimama-creative/FLUX.1-dev-Controlnet-Inpainting-Beta", torch_dtype=torch.bfloat16
-)
 
-# Build pipeline
-pipe = FluxControlNetInpaintingPipeline.from_pretrained(
-    "black-forest-labs/FLUX.1-dev",
-    controlnet=controlnet,
-    transformer=transformer,
-    torch_dtype=torch.bfloat16
-).to("cuda")
-pipe.transformer.to(torch.bfloat16)
-pipe.controlnet.to(torch.bfloat16)
-
-
-@spaces.GPU()
-def process(input_image_editor):
-    # Use default values from config
-    negative_prompt = config.DEFAULT_NEGATIVE_PROMPT
-    controlnet_conditioning_scale = config.DEFAULT_CONTROLNET_CONDITIONING_SCALE
-    guidance_scale = config.DEFAULT_GUIDANCE_SCALE
-    seed = config.DEFAULT_SEED
-    num_inference_steps = config.DEFAULT_NUM_INFERENCE_STEPS
-    true_guidance_scale = config.DEFAULT_TRUE_GUIDANCE_SCALE
-
-    # Process image and mask
-    image = input_image_editor['background']
-    mask = input_image_editor['layers'][0]
-    #print("TYPE=", type(image))
-    _h, _w = image.size
-    # Calculate the new dimensions
-    h = (_h // 8) * 8 + (8 if _h % 8 != 0 else 0)
-    w = (_w // 8) * 8 + (8 if _w % 8 != 0 else 0)
-    
-    size = (h, w)
-
-    image_or = image.copy()
-    image = image.convert("RGB").resize(size)
-    mask = mask.convert("RGB").resize(size)
-    generator = torch.Generator(device="cuda").manual_seed(seed)
-
-    # Generate result
-    result = pipe(
-        prompt="nothing",#os.getenv('MAGIC_PROMPT'),
-        height=size[1],
-        width=size[0],
-        control_image=image,
-        control_mask=mask,
-        num_inference_steps=num_inference_steps,
-        generator=generator,
-        controlnet_conditioning_scale=controlnet_conditioning_scale,
-        guidance_scale=guidance_scale,
-        negative_prompt=negative_prompt,
-        true_guidance_scale=true_guidance_scale
-    ).images[0]
-
-    processed_image = result.resize(image_or.size[:2])
-
-    # Save the processed image
-    output_folder = Path("output")  # Make sure this folder exists or create it
-    output_folder.mkdir(parents=True, exist_ok=True)
-    image_path = output_folder / f"no_bg_image_{uuid.uuid4().hex}.png"
-    processed_image.save(image_path)
-
-    return (processed_image, image), str(image_path)
-
-#################################################################
 
 # Define inputs and outputs for the Gradio interface
 image = gr.ImageEditor(
@@ -116,12 +74,11 @@ image = gr.ImageEditor(
 output_slider = ImageSlider(label="Processed photo", type="pil")
 
 demo = gr.Interface(
-    fn=process,
+    fn=process_image,
     inputs=image,
     outputs=[output_slider, gr.File(label="output png file")],
     #title="🫧 Snap Clean 🧽",
-    description=config.DESCRIPTION
+    description="Upload an image and a mask to remove unwanted objects."
 )
 
-
 demo.launch(debug=False, show_error=True, share=True)

requirements.txt

@@ -1,8 +1,3 @@
-diffusers==0.30.2
-torch
-transformers
-accelerate
-huggingface_hub
-sentencepiece
 gradio
-gradio_imageslider
+gradio_imageslider
+python-dotenv