Update app.py

app.py

@@ -1,70 +1,348 @@
+# # import logging
+# # import random
+# # import warnings
+# # import os
+# # import gradio as gr
+# # import numpy as np
+# # import spaces
+# # import torch
+# # from diffusers import FluxControlNetModel
+# # from diffusers.pipelines import FluxControlNetPipeline
+# # from gradio_imageslider import ImageSlider
+# # from PIL import Image
+# # from huggingface_hub import snapshot_download
+
+# # css = """
+# # #col-container {
+# #     margin: 0 auto;
+# #     max-width: 512px;
+# # }
+# # """
+
+# # if torch.cuda.is_available():
+# #     power_device = "GPU"
+# #     device = "cuda"
+# # else:
+# #     power_device = "CPU"
+# #     device = "cpu"
+
+
+# # huggingface_token = os.getenv("HUGGINFACE_TOKEN")
+
+# # model_path = snapshot_download(
+# #     repo_id="black-forest-labs/FLUX.1-dev", 
+# #     repo_type="model", 
+# #     ignore_patterns=["*.md", "*..gitattributes"],
+# #     local_dir="FLUX.1-dev",
+# #     token=huggingface_token, # type a new token-id.
+# # )
+
+
+# # # Load pipeline
+# # controlnet = FluxControlNetModel.from_pretrained(
+# #     "jasperai/Flux.1-dev-Controlnet-Upscaler", torch_dtype=torch.bfloat16
+# # ).to(device)
+# # pipe = FluxControlNetPipeline.from_pretrained(
+# #     model_path, controlnet=controlnet, torch_dtype=torch.bfloat16
+# # )
+# # pipe.to(device)
+
+# # MAX_SEED = 1000000
+# # MAX_PIXEL_BUDGET = 1024 * 1024
+
+
+# # def process_input(input_image, upscale_factor, **kwargs):
+# #     w, h = input_image.size
+# #     w_original, h_original = w, h
+# #     aspect_ratio = w / h
+
+# #     was_resized = False
+
+# #     if w * h * upscale_factor**2 > MAX_PIXEL_BUDGET:
+# #         warnings.warn(
+# #             f"Requested output image is too large ({w * upscale_factor}x{h * upscale_factor}). Resizing to ({int(aspect_ratio * MAX_PIXEL_BUDGET ** 0.5 // upscale_factor), int(MAX_PIXEL_BUDGET ** 0.5 // aspect_ratio // upscale_factor)}) pixels."
+# #         )
+# #         gr.Info(
+# #             f"Requested output image is too large ({w * upscale_factor}x{h * upscale_factor}). Resizing input to ({int(aspect_ratio * MAX_PIXEL_BUDGET ** 0.5 // upscale_factor), int(MAX_PIXEL_BUDGET ** 0.5 // aspect_ratio // upscale_factor)}) pixels budget."
+# #         )
+# #         input_image = input_image.resize(
+# #             (
+# #                 int(aspect_ratio * MAX_PIXEL_BUDGET**0.5 // upscale_factor),
+# #                 int(MAX_PIXEL_BUDGET**0.5 // aspect_ratio // upscale_factor),
+# #             )
+# #         )
+# #         was_resized = True
+
+# #     # resize to multiple of 8
+# #     w, h = input_image.size
+# #     w = w - w % 8
+# #     h = h - h % 8
+
+# #     return input_image.resize((w, h)), w_original, h_original, was_resized
+
+
+# # @spaces.GPU#(duration=42)
+# # def infer(
+# #     seed,
+# #     randomize_seed,
+# #     input_image,
+# #     num_inference_steps,
+# #     upscale_factor,
+# #     controlnet_conditioning_scale,
+# #     progress=gr.Progress(track_tqdm=True),
+# # ):
+# #     if randomize_seed:
+# #         seed = random.randint(0, MAX_SEED)
+# #     true_input_image = input_image
+# #     input_image, w_original, h_original, was_resized = process_input(
+# #         input_image, upscale_factor
+# #     )
+
+# #     # rescale with upscale factor
+# #     w, h = input_image.size
+# #     control_image = input_image.resize((w * upscale_factor, h * upscale_factor))
+
+# #     generator = torch.Generator().manual_seed(seed)
+
+# #     gr.Info("Upscaling image...")
+# #     image = pipe(
+# #         prompt="",
+# #         control_image=control_image,
+# #         controlnet_conditioning_scale=controlnet_conditioning_scale,
+# #         num_inference_steps=num_inference_steps,
+# #         guidance_scale=3.5,
+# #         height=control_image.size[1],
+# #         width=control_image.size[0],
+# #         generator=generator,
+# #     ).images[0]
+
+# #     if was_resized:
+# #         gr.Info(
+# #             f"Resizing output image to targeted {w_original * upscale_factor}x{h_original * upscale_factor} size."
+# #         )
+
+# #     # resize to target desired size
+# #     image = image.resize((w_original * upscale_factor, h_original * upscale_factor))
+# #     image.save("output.jpg")
+# #     # convert to numpy
+# #     return [true_input_image, image, seed]
+
+
+# # with gr.Blocks(css=css) as demo:
+# #     # with gr.Column(elem_id="col-container"):
+# #     gr.Markdown(
+# #         f"""
+# #     # ⚡ Flux.1-dev Upscaler ControlNet ⚡
+# #     This is an interactive demo of [Flux.1-dev Upscaler ControlNet](https://huggingface.co/jasperai/Flux.1-dev-Controlnet-Upscaler) taking as input a low resolution image to generate a high resolution image.
+# #     Currently running on {power_device}.
+
+# #     *Note*: Even though the model can handle higher resolution images, due to GPU memory constraints, this demo was limited to a generated output not exceeding a pixel budget of 1024x1024. If the requested size exceeds that limit, the input will be first resized keeping the aspect ratio such that the output of the controlNet model does not exceed the allocated pixel budget. The output is then resized to the targeted shape using a simple resizing. This may explain some artifacts for high resolution input. To adress this, run the demo locally or consider implementing a tiling strategy. Happy upscaling! 🚀
+# #     """
+# #     )
+
+# #     with gr.Row():
+# #         run_button = gr.Button(value="Run")
+
+# #     with gr.Row():
+# #         with gr.Column(scale=4):
+# #             input_im = gr.Image(label="Input Image", type="pil")
+# #         with gr.Column(scale=1):
+# #             num_inference_steps = gr.Slider(
+# #                 label="Number of Inference Steps",
+# #                 minimum=8,
+# #                 maximum=50,
+# #                 step=1,
+# #                 value=28,
+# #             )
+# #             upscale_factor = gr.Slider(
+# #                 label="Upscale Factor",
+# #                 minimum=1,
+# #                 maximum=4,
+# #                 step=1,
+# #                 value=4,
+# #             )
+# #             controlnet_conditioning_scale = gr.Slider(
+# #                 label="Controlnet Conditioning Scale",
+# #                 minimum=0.1,
+# #                 maximum=1.5,
+# #                 step=0.1,
+# #                 value=0.6,
+# #             )
+# #             seed = gr.Slider(
+# #                 label="Seed",
+# #                 minimum=0,
+# #                 maximum=MAX_SEED,
+# #                 step=1,
+# #                 value=42,
+# #             )
+
+# #             randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+
+# #     with gr.Row():
+# #         result = ImageSlider(label="Input / Output", type="pil", interactive=True)
+
+# #     examples = gr.Examples(
+# #         examples=[
+# #         #    [42, False, "examples/image_1.jpg", 28, 4, 0.6],
+# #             [42, False, "examples/image_2.jpg", 28, 4, 0.6],
+# #         #    [42, False, "examples/image_3.jpg", 28, 4, 0.6],
+# #             [42, False, "examples/image_4.jpg", 28, 4, 0.6],
+# #         #    [42, False, "examples/image_5.jpg", 28, 4, 0.6],
+# #         #    [42, False, "examples/image_6.jpg", 28, 4, 0.6],
+# #         ],
+# #         inputs=[
+# #             seed,
+# #             randomize_seed,
+# #             input_im,
+# #             num_inference_steps,
+# #             upscale_factor,
+# #             controlnet_conditioning_scale,
+# #         ],
+# #         fn=infer,
+# #         outputs=result,
+# #         cache_examples="lazy",
+# #     )
+
+# #     # examples = gr.Examples(
+# #     #     examples=[
+# #     #         #[42, False, "examples/image_1.jpg", 28, 4, 0.6],
+# #     #         [42, False, "examples/image_2.jpg", 28, 4, 0.6],
+# #     #         #[42, False, "examples/image_3.jpg", 28, 4, 0.6],
+# #     #         #[42, False, "examples/image_4.jpg", 28, 4, 0.6],
+# #     #         [42, False, "examples/image_5.jpg", 28, 4, 0.6],
+# #     #         [42, False, "examples/image_6.jpg", 28, 4, 0.6],
+# #     #         [42, False, "examples/image_7.jpg", 28, 4, 0.6],
+# #     #     ],
+# #     #     inputs=[
+# #     #         seed,
+# #     #         randomize_seed,
+# #     #         input_im,
+# #     #         num_inference_steps,
+# #     #         upscale_factor,
+# #     #         controlnet_conditioning_scale,
+# #     #     ],
+# #     # )
+
+# #     gr.Markdown("**Disclaimer:**")
+# #     gr.Markdown(
+# #         "This demo is only for research purpose. Jasper cannot be held responsible for the generation of NSFW (Not Safe For Work) content through the use of this demo. Users are solely responsible for any content they create, and it is their obligation to ensure that it adheres to appropriate and ethical standards. Jasper provides the tools, but the responsibility for their use lies with the individual user."
+# #     )
+# #     gr.on(
+# #         [run_button.click],
+# #         fn=infer,
+# #         inputs=[
+# #             seed,
+# #             randomize_seed,
+# #             input_im,
+# #             num_inference_steps,
+# #             upscale_factor,
+# #             controlnet_conditioning_scale,
+# #         ],
+# #         outputs=result,
+# #         show_api=False,
+# #         # show_progress="minimal",
+# #     )
+
+# # demo.queue().launch(share=False, show_api=False)
+
+
+
+
+
+
 # import logging
 # import random
 # import warnings
-# import os
-# import gradio as gr
-# import numpy as np
-# import spaces
+# import os,shutil,subprocess
 # import torch
+# import numpy as np
 # from diffusers import FluxControlNetModel
 # from diffusers.pipelines import FluxControlNetPipeline
-# from gradio_imageslider import ImageSlider
 # from PIL import Image
-# from huggingface_hub import snapshot_download
-
-# css = """
-# #col-container {
-#     margin: 0 auto;
-#     max-width: 512px;
-# }
-# """
-
+# from huggingface_hub import snapshot_download,login
+# import io
+# import base64
+# from flask import Flask, request, jsonify
+# from concurrent.futures import ThreadPoolExecutor
+# from flask_cors import CORS
+# from tqdm import tqdm
+
+# app = Flask(__name__)
+# CORS(app)
+
+# # Function to check disk usage
+# def check_disk_space():
+#     result = subprocess.run(['df', '-h'], capture_output=True, text=True)
+#     print(result.stdout)
+
+# # Function to clear Hugging Face cache
+# def clear_huggingface_cache():
+#     cache_dir = os.path.expanduser('~/.cache/huggingface')
+#     if os.path.exists(cache_dir):
+#         shutil.rmtree(cache_dir)  # Removes the entire cache directory
+#         print(f"Cleared Hugging Face cache at: {cache_dir}")
+#     else:
+#         print("No Hugging Face cache found.")
+
+# # Check disk space
+# check_disk_space()
+
+# # Clear Hugging Face cache
+# clear_huggingface_cache()
+
+# # Add config to store base64 images
+# app.config['image_outputs'] = {}
+
+# # ThreadPoolExecutor for managing image processing threads
+# executor = ThreadPoolExecutor()
+
+# # Determine the device (GPU or CPU)
 # if torch.cuda.is_available():
-#     power_device = "GPU"
 #     device = "cuda"
 # else:
-#     power_device = "CPU"
 #     device = "cpu"
 
-
-# huggingface_token = os.getenv("HUGGINFACE_TOKEN")
-
-# model_path = snapshot_download(
+# # Load model from Huggingface Hub
+# huggingface_token = os.getenv("HUGGINGFACE_TOKEN")
+# if huggingface_token:
+#     login(token=huggingface_token)
+# else:
+#     print("Hugging Face token not found in environment variables.")
+# print(huggingface_token)
+# with tqdm(total=100, desc="Downloading model", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
+#  model_path = snapshot_download(
 #     repo_id="black-forest-labs/FLUX.1-dev", 
 #     repo_type="model", 
 #     ignore_patterns=["*.md", "*..gitattributes"],
 #     local_dir="FLUX.1-dev",
-#     token=huggingface_token, # type a new token-id.
-# )
-
+#     token=huggingface_token)
 
 # # Load pipeline
-# controlnet = FluxControlNetModel.from_pretrained(
+# print('controlnet enters')
+# with tqdm(total=100, desc="Downloading model", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
+#  controlnet = FluxControlNetModel.from_pretrained(
 #     "jasperai/Flux.1-dev-Controlnet-Upscaler", torch_dtype=torch.bfloat16
 # ).to(device)
-# pipe = FluxControlNetPipeline.from_pretrained(
+# print('controlnet exits')
+# print('pipe enters')
+# with tqdm(total=100, desc="Downloading model", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
+#  pipe = FluxControlNetPipeline.from_pretrained(
 #     model_path, controlnet=controlnet, torch_dtype=torch.bfloat16
-# )
-# pipe.to(device)
+# ).to(device)
+# # pipe.to(device)
+# print('pipe exits')
 
 # MAX_SEED = 1000000
 # MAX_PIXEL_BUDGET = 1024 * 1024
 
-
-# def process_input(input_image, upscale_factor, **kwargs):
+# def process_input(input_image, upscale_factor):
 #     w, h = input_image.size
-#     w_original, h_original = w, h
 #     aspect_ratio = w / h
-
 #     was_resized = False
 
+#     # Resize if input size exceeds the maximum pixel budget
 #     if w * h * upscale_factor**2 > MAX_PIXEL_BUDGET:
-#         warnings.warn(
-#             f"Requested output image is too large ({w * upscale_factor}x{h * upscale_factor}). Resizing to ({int(aspect_ratio * MAX_PIXEL_BUDGET ** 0.5 // upscale_factor), int(MAX_PIXEL_BUDGET ** 0.5 // aspect_ratio // upscale_factor)}) pixels."
-#         )
-#         gr.Info(
-#             f"Requested output image is too large ({w * upscale_factor}x{h * upscale_factor}). Resizing input to ({int(aspect_ratio * MAX_PIXEL_BUDGET ** 0.5 // upscale_factor), int(MAX_PIXEL_BUDGET ** 0.5 // aspect_ratio // upscale_factor)}) pixels budget."
-#         )
+#         warnings.warn(f"Requested output image is too large. Resizing to fit within pixel budget.")
 #         input_image = input_image.resize(
 #             (
 #                 int(aspect_ratio * MAX_PIXEL_BUDGET**0.5 // upscale_factor),
@@ -73,38 +351,24 @@
 #         )
 #         was_resized = True
 
-#     # resize to multiple of 8
+#     # Adjust dimensions to be a multiple of 8
 #     w, h = input_image.size
 #     w = w - w % 8
 #     h = h - h % 8
 
-#     return input_image.resize((w, h)), w_original, h_original, was_resized
+#     return input_image.resize((w, h)), was_resized
 
+# def run_inference(process_id, input_image, upscale_factor, seed, num_inference_steps, controlnet_conditioning_scale):
+#     input_image, was_resized = process_input(input_image, upscale_factor)
 
-# @spaces.GPU#(duration=42)
-# def infer(
-#     seed,
-#     randomize_seed,
-#     input_image,
-#     num_inference_steps,
-#     upscale_factor,
-#     controlnet_conditioning_scale,
-#     progress=gr.Progress(track_tqdm=True),
-# ):
-#     if randomize_seed:
-#         seed = random.randint(0, MAX_SEED)
-#     true_input_image = input_image
-#     input_image, w_original, h_original, was_resized = process_input(
-#         input_image, upscale_factor
-#     )
-
-#     # rescale with upscale factor
+#     # Rescale image for ControlNet processing
 #     w, h = input_image.size
 #     control_image = input_image.resize((w * upscale_factor, h * upscale_factor))
 
+#     # Set the random generator for inference
 #     generator = torch.Generator().manual_seed(seed)
 
-#     gr.Info("Upscaling image...")
+#     # Perform inference using the pipeline
 #     image = pipe(
 #         prompt="",
 #         control_image=control_image,
@@ -116,135 +380,85 @@
 #         generator=generator,
 #     ).images[0]
 
+#     # Resize output image back to the original dimensions if needed
 #     if was_resized:
-#         gr.Info(
-#             f"Resizing output image to targeted {w_original * upscale_factor}x{h_original * upscale_factor} size."
-#         )
+#         original_size = (input_image.width * upscale_factor, input_image.height * upscale_factor)
+#         image = image.resize(original_size)
+
+#     # Convert the output image to base64
+#     buffered = io.BytesIO()
+#     image.save(buffered, format="JPEG")
+#     image_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+#     # Store the result in the shared dictionary
+#     app.config['image_outputs'][process_id] = image_base64
+
+# @app.route('/infer', methods=['POST'])
+# def infer():
+#     data = request.json
+#     seed = data.get("seed", 42)
+#     randomize_seed = data.get("randomize_seed", True)
+#     num_inference_steps = data.get("num_inference_steps", 28)
+#     upscale_factor = data.get("upscale_factor", 4)
+#     controlnet_conditioning_scale = data.get("controlnet_conditioning_scale", 0.6)
+
+#     # Randomize seed if specified
+#     if randomize_seed:
+#         seed = random.randint(0, MAX_SEED)
 
-#     # resize to target desired size
-#     image = image.resize((w_original * upscale_factor, h_original * upscale_factor))
-#     image.save("output.jpg")
-#     # convert to numpy
-#     return [true_input_image, image, seed]
-
-
-# with gr.Blocks(css=css) as demo:
-#     # with gr.Column(elem_id="col-container"):
-#     gr.Markdown(
-#         f"""
-#     # ⚡ Flux.1-dev Upscaler ControlNet ⚡
-#     This is an interactive demo of [Flux.1-dev Upscaler ControlNet](https://huggingface.co/jasperai/Flux.1-dev-Controlnet-Upscaler) taking as input a low resolution image to generate a high resolution image.
-#     Currently running on {power_device}.
-
-#     *Note*: Even though the model can handle higher resolution images, due to GPU memory constraints, this demo was limited to a generated output not exceeding a pixel budget of 1024x1024. If the requested size exceeds that limit, the input will be first resized keeping the aspect ratio such that the output of the controlNet model does not exceed the allocated pixel budget. The output is then resized to the targeted shape using a simple resizing. This may explain some artifacts for high resolution input. To adress this, run the demo locally or consider implementing a tiling strategy. Happy upscaling! 🚀
-#     """
-#     )
-
-#     with gr.Row():
-#         run_button = gr.Button(value="Run")
-
-#     with gr.Row():
-#         with gr.Column(scale=4):
-#             input_im = gr.Image(label="Input Image", type="pil")
-#         with gr.Column(scale=1):
-#             num_inference_steps = gr.Slider(
-#                 label="Number of Inference Steps",
-#                 minimum=8,
-#                 maximum=50,
-#                 step=1,
-#                 value=28,
-#             )
-#             upscale_factor = gr.Slider(
-#                 label="Upscale Factor",
-#                 minimum=1,
-#                 maximum=4,
-#                 step=1,
-#                 value=4,
-#             )
-#             controlnet_conditioning_scale = gr.Slider(
-#                 label="Controlnet Conditioning Scale",
-#                 minimum=0.1,
-#                 maximum=1.5,
-#                 step=0.1,
-#                 value=0.6,
-#             )
-#             seed = gr.Slider(
-#                 label="Seed",
-#                 minimum=0,
-#                 maximum=MAX_SEED,
-#                 step=1,
-#                 value=42,
-#             )
+#     # Load and process the input image
+#     input_image_data = base64.b64decode(data['input_image'])
+#     input_image = Image.open(io.BytesIO(input_image_data))
+
+#     # Create a unique process ID for this request
+#     process_id = str(random.randint(1000, 9999))
+
+#     # Set the status to 'in_progress'
+#     app.config['image_outputs'][process_id] = None
+
+#     # Run the inference in a separate thread
+#     executor.submit(run_inference, process_id, input_image, upscale_factor, seed, num_inference_steps, controlnet_conditioning_scale)
 
-#             randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-
-#     with gr.Row():
-#         result = ImageSlider(label="Input / Output", type="pil", interactive=True)
-
-#     examples = gr.Examples(
-#         examples=[
-#         #    [42, False, "examples/image_1.jpg", 28, 4, 0.6],
-#             [42, False, "examples/image_2.jpg", 28, 4, 0.6],
-#         #    [42, False, "examples/image_3.jpg", 28, 4, 0.6],
-#             [42, False, "examples/image_4.jpg", 28, 4, 0.6],
-#         #    [42, False, "examples/image_5.jpg", 28, 4, 0.6],
-#         #    [42, False, "examples/image_6.jpg", 28, 4, 0.6],
-#         ],
-#         inputs=[
-#             seed,
-#             randomize_seed,
-#             input_im,
-#             num_inference_steps,
-#             upscale_factor,
-#             controlnet_conditioning_scale,
-#         ],
-#         fn=infer,
-#         outputs=result,
-#         cache_examples="lazy",
-#     )
-
-#     # examples = gr.Examples(
-#     #     examples=[
-#     #         #[42, False, "examples/image_1.jpg", 28, 4, 0.6],
-#     #         [42, False, "examples/image_2.jpg", 28, 4, 0.6],
-#     #         #[42, False, "examples/image_3.jpg", 28, 4, 0.6],
-#     #         #[42, False, "examples/image_4.jpg", 28, 4, 0.6],
-#     #         [42, False, "examples/image_5.jpg", 28, 4, 0.6],
-#     #         [42, False, "examples/image_6.jpg", 28, 4, 0.6],
-#     #         [42, False, "examples/image_7.jpg", 28, 4, 0.6],
-#     #     ],
-#     #     inputs=[
-#     #         seed,
-#     #         randomize_seed,
-#     #         input_im,
-#     #         num_inference_steps,
-#     #         upscale_factor,
-#     #         controlnet_conditioning_scale,
-#     #     ],
-#     # )
-
-#     gr.Markdown("**Disclaimer:**")
-#     gr.Markdown(
-#         "This demo is only for research purpose. Jasper cannot be held responsible for the generation of NSFW (Not Safe For Work) content through the use of this demo. Users are solely responsible for any content they create, and it is their obligation to ensure that it adheres to appropriate and ethical standards. Jasper provides the tools, but the responsibility for their use lies with the individual user."
-#     )
-#     gr.on(
-#         [run_button.click],
-#         fn=infer,
-#         inputs=[
-#             seed,
-#             randomize_seed,
-#             input_im,
-#             num_inference_steps,
-#             upscale_factor,
-#             controlnet_conditioning_scale,
-#         ],
-#         outputs=result,
-#         show_api=False,
-#         # show_progress="minimal",
-#     )
-
-# demo.queue().launch(share=False, show_api=False)
+#     # Return the process ID
+#     return jsonify({
+#         "process_id": process_id,
+#         "message": "Processing started"
+#     })
 
+# # Modify status endpoint to receive process_id in request body
+# @app.route('/status', methods=['POST'])
+# def status():
+#     data = request.json
+#     process_id = data.get('process_id')
+
+#     # Check if process_id was provided
+#     if not process_id:
+#         return jsonify({
+#             "status": "error",
+#             "message": "Process ID is required"
+#         }), 400
+
+#     # Check if the process_id exists in the dictionary
+#     if process_id not in app.config['image_outputs']:
+#         return jsonify({
+#             "status": "error",
+#             "message": "Invalid process ID"
+#         }), 404
+
+#     # Check the status of the image processing
+#     image_base64 = app.config['image_outputs'][process_id]
+#     if image_base64 is None:
+#         return jsonify({
+#             "status": "in_progress"
+#         })
+#     else:
+#         return jsonify({
+#             "status": "completed",
+#             "output_image": image_base64
+#         })
+
+# if __name__ == '__main__':
+#     app.run(debug=True)
 
 
 
@@ -253,13 +467,15 @@
 import logging
 import random
 import warnings
-import os,shutil,subprocess
+import os
+import shutil
+import subprocess
 import torch
 import numpy as np
 from diffusers import FluxControlNetModel
 from diffusers.pipelines import FluxControlNetPipeline
 from PIL import Image
-from huggingface_hub import snapshot_download,login
+from huggingface_hub import snapshot_download, login
 import io
 import base64
 from flask import Flask, request, jsonify
@@ -267,22 +483,26 @@ from concurrent.futures import ThreadPoolExecutor
 from flask_cors import CORS
 from tqdm import tqdm
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 app = Flask(__name__)
 CORS(app)
 
 # Function to check disk usage
 def check_disk_space():
     result = subprocess.run(['df', '-h'], capture_output=True, text=True)
-    print(result.stdout)
+    logger.info("Disk space usage:\n%s", result.stdout)
 
 # Function to clear Hugging Face cache
 def clear_huggingface_cache():
     cache_dir = os.path.expanduser('~/.cache/huggingface')
     if os.path.exists(cache_dir):
         shutil.rmtree(cache_dir)  # Removes the entire cache directory
-        print(f"Cleared Hugging Face cache at: {cache_dir}")
+        logger.info("Cleared Hugging Face cache at: %s", cache_dir)
     else:
-        print("No Hugging Face cache found.")
+        logger.info("No Hugging Face cache found.")
 
 # Check disk space
 check_disk_space()
@@ -299,38 +519,45 @@ executor = ThreadPoolExecutor()
 # Determine the device (GPU or CPU)
 if torch.cuda.is_available():
     device = "cuda"
+    logger.info("CUDA is available. Using GPU.")
 else:
     device = "cpu"
+    logger.info("CUDA is not available. Using CPU.")
 
 # Load model from Huggingface Hub
 huggingface_token = os.getenv("HUGGINGFACE_TOKEN")
 if huggingface_token:
     login(token=huggingface_token)
+    logger.info("Hugging Face token found and logged in.")
 else:
-    print("Hugging Face token not found in environment variables.")
-print(huggingface_token)
+    logger.warning("Hugging Face token not found in environment variables.")
+
+logger.info("Hugging Face token: %s", huggingface_token)
+
+# Download model using snapshot_download
 with tqdm(total=100, desc="Downloading model", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
- model_path = snapshot_download(
-    repo_id="black-forest-labs/FLUX.1-dev", 
-    repo_type="model", 
-    ignore_patterns=["*.md", "*..gitattributes"],
-    local_dir="FLUX.1-dev",
-    token=huggingface_token)
+    model_path = snapshot_download(
+        repo_id="black-forest-labs/FLUX.1-dev", 
+        repo_type="model", 
+        ignore_patterns=["*.md", "*..gitattributes"],
+        local_dir="FLUX.1-dev",
+        token=huggingface_token)
+    logger.info("Model downloaded to: %s", model_path)
 
 # Load pipeline
-print('controlnet enters')
-with tqdm(total=100, desc="Downloading model", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
- controlnet = FluxControlNetModel.from_pretrained(
-    "jasperai/Flux.1-dev-Controlnet-Upscaler", torch_dtype=torch.bfloat16
-).to(device)
-print('controlnet exits')
-print('pipe enters')
-with tqdm(total=100, desc="Downloading model", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
- pipe = FluxControlNetPipeline.from_pretrained(
-    model_path, controlnet=controlnet, torch_dtype=torch.bfloat16
-).to(device)
-# pipe.to(device)
-print('pipe exits')
+logger.info('Loading ControlNet model.')
+with tqdm(total=100, desc="Downloading ControlNet model", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
+    controlnet = FluxControlNetModel.from_pretrained(
+        "jasperai/Flux.1-dev-Controlnet-Upscaler", torch_dtype=torch.bfloat16
+    ).to(device)
+logger.info("ControlNet model loaded successfully.")
+
+logger.info('Loading pipeline.')
+with tqdm(total=100, desc="Downloading pipeline", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}") as pbar:
+    pipe = FluxControlNetPipeline.from_pretrained(
+        model_path, controlnet=controlnet, torch_dtype=torch.bfloat16
+    ).to(device)
+logger.info("Pipeline loaded successfully.")
 
 MAX_SEED = 1000000
 MAX_PIXEL_BUDGET = 1024 * 1024
@@ -359,6 +586,7 @@ def process_input(input_image, upscale_factor):
     return input_image.resize((w, h)), was_resized
 
 def run_inference(process_id, input_image, upscale_factor, seed, num_inference_steps, controlnet_conditioning_scale):
+    logger.info("Processing inference for process_id: %s", process_id)
     input_image, was_resized = process_input(input_image, upscale_factor)
 
     # Rescale image for ControlNet processing
@@ -369,6 +597,7 @@ def run_inference(process_id, input_image, upscale_factor, seed, num_inference_s
     generator = torch.Generator().manual_seed(seed)
 
     # Perform inference using the pipeline
+    logger.info("Running pipeline for process_id: %s", process_id)
     image = pipe(
         prompt="",
         control_image=control_image,
@@ -392,6 +621,7 @@ def run_inference(process_id, input_image, upscale_factor, seed, num_inference_s
 
     # Store the result in the shared dictionary
     app.config['image_outputs'][process_id] = image_base64
+    logger.info("Inference completed for process_id: %s", process_id)
 
 @app.route('/infer', methods=['POST'])
 def infer():
@@ -405,6 +635,7 @@ def infer():
     # Randomize seed if specified
     if randomize_seed:
         seed = random.randint(0, MAX_SEED)
+        logger.info("Seed randomized to: %d", seed)
 
     # Load and process the input image
     input_image_data = base64.b64decode(data['input_image'])
@@ -412,6 +643,7 @@ def infer():
 
     # Create a unique process ID for this request
     process_id = str(random.randint(1000, 9999))
+    logger.info("Process started with process_id: %s", process_id)
 
     # Set the status to 'in_progress'
     app.config['image_outputs'][process_id] = None
@@ -433,6 +665,7 @@ def status():
 
     # Check if process_id was provided
     if not process_id:
+        logger.error("Process ID not provided in request.")
         return jsonify({
             "status": "error",
             "message": "Process ID is required"
@@ -440,6 +673,7 @@ def status():
 
     # Check if the process_id exists in the dictionary
     if process_id not in app.config['image_outputs']:
+        logger.error("Invalid process ID: %s", process_id)
         return jsonify({
             "status": "error",
             "message": "Invalid process ID"
@@ -448,10 +682,12 @@ def status():
     # Check the status of the image processing
     image_base64 = app.config['image_outputs'][process_id]
     if image_base64 is None:
+        logger.info("Process ID %s is still in progress.", process_id)
         return jsonify({
             "status": "in_progress"
         })
     else:
+        logger.info("Process ID %s completed successfully.", process_id)
         return jsonify({
             "status": "completed",
             "output_image": image_base64
@@ -460,3 +696,4 @@ def status():
 if __name__ == '__main__':
     app.run(debug=True)
 
+