new gradio test

app copy.py

@@ -1,105 +0,0 @@
-from typing import Tuple, Optional
-from PIL import Image, ImageDraw, ImageFont
-
-
-WEATHER_PNG_PATH = None  # disk fallback removed
-GENERATED_PNG_PATH = None  # disk fallback removed
-
-def _placeholder_image(size: Tuple[int, int], text: str, bg=(230, 230, 230)) -> Image.Image:
-    # Always create a simple placeholder; don't try to read a file here
-    img = Image.new("RGB", size, color=bg)
-    draw = ImageDraw.Draw(img)
-    try:
-        font = ImageFont.load_default()
-    except Exception:
-        font = None
-    w, h = draw.textbbox((0, 0), text, font=font)[2:]
-    draw.text(((size[0] - w) / 2, (size[1] - h) / 2), text, fill=(80, 80, 80), font=font)
-    return img
-
-
-def load_weather_plot(size: Tuple[int, int] = (1024, 1024), kit_id: Optional[int] = None) -> Image.Image:
-    """Load the weather plot image for a given kit.
-
-    Tries to generate in-memory via weather_data_visualisation(); falls back to
-    a placeholder if unavailable.
-    """
-    try:
-        # Prefer calling the function to get a PIL image directly
-        from weather_data_visualisation import weather_data_visualisation
-        # Coerce kit_id to int, defaulting to 1001 if not provided/invalid
-        kit = 1001
-        if kit_id is not None:
-            try:
-                kit = int(kit_id)
-            except Exception:
-                kit = 1001
-
-        img = weather_data_visualisation(kit=kit, save_to_disk=False)
-        if isinstance(img, Image.Image):
-            if img.size != size:
-                img = img.resize(size, Image.LANCZOS)
-            return img
-    except Exception as e:
-        print(f"Weather plot generation failed: {e}")
-
-    return _placeholder_image(size, "Weather plot unavailable")
-
-
-def load_genai_output(size: Tuple[int, int] = (1024, 1024), kit_id: Optional[int] = None) -> Image.Image:
-    """Load the GenAI output image for a given kit if available; otherwise a placeholder.
-
-    Uses the selected kit's weather plot as the guiding input for the GenAI image.
-    """
-    try:
-        from genai import generate_genai_image
-
-        # Provide the latest weather image if possible to guide the GenAI
-        base_img = None
-        try:
-            base_img = load_weather_plot(size, kit_id=kit_id)
-        except Exception:
-            base_img = None
-
-        img = generate_genai_image(input_image=base_img, save_to_disk=False)
-        if isinstance(img, Image.Image):
-            if img.size != size:
-                img = img.resize(size, Image.LANCZOS)
-            return img
-    except Exception as e:
-        print(f"genai.py not usable yet: {e}")
-
-    return _placeholder_image(size, "GenAI image pending")
-
-
-def get_both_images(kit_id: Optional[int] = None, size: Tuple[int, int] = (1024, 1024)) -> Tuple[Image.Image, Image.Image]:
-    left = load_weather_plot(size, kit_id=kit_id)
-    right = load_genai_output(size, kit_id=kit_id)
-    return left, right
-
-
-def create_app():
-    """Creates and returns the Gradio app with two side-by-side images."""
-    import gradio as gr
-
-    with gr.Blocks(title="Weather × GenAI") as app:
-        gr.Markdown("# Weather visualization and GenAI output")
-        with gr.Row():
-            kit_input = gr.Number(label="Kit ID", value=1001, precision=0)
-        with gr.Row():
-            left_img = gr.Image(label="Weather plot", type="pil")
-            right_img = gr.Image(label="GenAI output", type="pil")
-
-        # Load both images on app start
-        app.load(fn=get_both_images, inputs=[kit_input], outputs=[left_img, right_img])
-
-        # Manual refresh button
-        refresh_btn = gr.Button("Refresh")
-        refresh_btn.click(fn=get_both_images, inputs=[kit_input], outputs=[left_img, right_img])
-
-    return app
-
-
-if __name__ == "__main__":
-    app = create_app()
-    app.launch()

app.py

@@ -1,4 +1,4 @@
-from typing import Tuple
+from typing import Tuple, Optional
 from PIL import Image, ImageDraw, ImageFont
 
 
@@ -18,17 +18,24 @@ def _placeholder_image(size: Tuple[int, int], text: str, bg=(230, 230, 230)) ->
     return img
 
 
-def load_weather_plot(size: Tuple[int, int] = (1024, 1024)) -> Image.Image:
-    """Load the weather plot image produced by weather_data_visualisation.py.
+def load_weather_plot(size: Tuple[int, int] = (1024, 1024), kit_id: Optional[int] = None) -> Image.Image:
+    """Load the weather plot image for a given kit.
 
-    Attempts to import the script to generate the file on first run. Falls back
-    to a placeholder if unavailable.
+    Tries to generate in-memory via weather_data_visualisation(); falls back to
+    a placeholder if unavailable.
     """
     try:
         # Prefer calling the function to get a PIL image directly
         from weather_data_visualisation import weather_data_visualisation
-
-        img = weather_data_visualisation(save_to_disk=False)
+        # Coerce kit_id to int, defaulting to 1001 if not provided/invalid
+        kit = 1001
+        if kit_id is not None:
+            try:
+                kit = int(kit_id)
+            except Exception:
+                kit = 1001
+
+        img = weather_data_visualisation(kit=kit, save_to_disk=False)
         if isinstance(img, Image.Image):
             if img.size != size:
                 img = img.resize(size, Image.LANCZOS)
@@ -39,11 +46,10 @@ def load_weather_plot(size: Tuple[int, int] = (1024, 1024)) -> Image.Image:
     return _placeholder_image(size, "Weather plot unavailable")
 
 
-def load_genai_output(size: Tuple[int, int] = (1024, 1024)) -> Image.Image:
-    """Load the GenAI output image if available; otherwise return a placeholder.
+def load_genai_output(size: Tuple[int, int] = (1024, 1024), kit_id: Optional[int] = None) -> Image.Image:
+    """Load the GenAI output image for a given kit if available; otherwise a placeholder.
 
-    If `genai.py` later exposes a function like `generate_genai_image(size)`,
-    it will be used here automatically.
+    Uses the selected kit's weather plot as the guiding input for the GenAI image.
     """
     try:
         from genai import generate_genai_image
@@ -51,7 +57,7 @@ def load_genai_output(size: Tuple[int, int] = (1024, 1024)) -> Image.Image:
         # Provide the latest weather image if possible to guide the GenAI
         base_img = None
         try:
-            base_img = load_weather_plot(size)
+            base_img = load_weather_plot(size, kit_id=kit_id)
         except Exception:
             base_img = None
 
@@ -66,9 +72,9 @@ def load_genai_output(size: Tuple[int, int] = (1024, 1024)) -> Image.Image:
     return _placeholder_image(size, "GenAI image pending")
 
 
-def get_both_images(size: Tuple[int, int] = (1024, 1024)) -> Tuple[Image.Image, Image.Image]:
-    left = load_weather_plot(size)
-    right = load_genai_output(size)
+def get_both_images(kit_id: Optional[int] = None, size: Tuple[int, int] = (1024, 1024)) -> Tuple[Image.Image, Image.Image]:
+    left = load_weather_plot(size, kit_id=kit_id)
+    right = load_genai_output(size, kit_id=kit_id)
     return left, right
 
 
@@ -78,16 +84,18 @@ def create_app():
 
     with gr.Blocks(title="Weather × GenAI") as app:
         gr.Markdown("# Weather visualization and GenAI output")
+        with gr.Row():
+            kit_input = gr.Number(label="Kit ID", value=1001, precision=0)
         with gr.Row():
             left_img = gr.Image(label="Weather plot", type="pil")
             right_img = gr.Image(label="GenAI output", type="pil")
 
         # Load both images on app start
-        app.load(fn=get_both_images, inputs=None, outputs=[left_img, right_img])
+        app.load(fn=get_both_images, inputs=[kit_input], outputs=[left_img, right_img])
 
         # Manual refresh button
         refresh_btn = gr.Button("Refresh")
-        refresh_btn.click(fn=get_both_images, inputs=None, outputs=[left_img, right_img])
+        refresh_btn.click(fn=get_both_images, inputs=[kit_input], outputs=[left_img, right_img])
 
     return app
 

genai copy 2.py

@@ -1,116 +0,0 @@
-from dotenv import load_dotenv
-from PIL import Image
-from typing import Optional
-from io import BytesIO
-import time
-
-load_dotenv()  # take environment variables from .env.
-
-from google import genai
-
-client = genai.Client()
-
-# Default creative prompt
-DEFAULT_PROMPT = (
-    "Turn the provided data visualization into a painting using an eastern art style."
-)
-
-
-def generate_genai_image(
-    input_image: Optional[Image.Image] = None,
-    prompt: Optional[str] = None,
-    model: str = "gemini-2.5-flash-image-preview",
-    save_to_disk: bool = False,
-) -> Optional[Image.Image]:
-    """Generate a stylized image from an input PIL image using Google GenAI.
-
-    Args:
-        input_image: Source PIL image. If None, calls weather_data_visualisation() to generate in-memory.
-        prompt: Optional text prompt; falls back to DEFAULT_PROMPT.
-        model: Model name to use.
-        save_to_disk: When True, saves to output/generated_image.png (no disk reads occur).
-
-    Returns:
-        A PIL.Image on success, or None if generation failed.
-    """
-
-    # Resolve input image strictly in-memory
-    img = input_image
-    if img is None:
-        try:
-            from weather_data_visualisation import weather_data_visualisation
-
-            img = weather_data_visualisation(save_to_disk=False)
-        except Exception:
-            img = None
-
-    if img is None:
-        return None
-
-    # Prepare prompt
-    ptxt = prompt or DEFAULT_PROMPT
-
-    output_image = None
-    last_error = None
-
-    # Retry up to 5 times, waiting 2 seconds between failed attempts
-    for attempt in range(1, 6):
-        try:
-            response = client.models.generate_content(
-                model=model,
-                contents=[ptxt, img],
-            )
-        except Exception as e:
-            last_error = e
-            # If not last attempt, wait and retry
-            if attempt < 5:
-                time.sleep(2)
-                continue
-            else:
-                print(f"GenAI request failed (attempt {attempt}/5): {e}")
-                break
-
-        try:
-            # Reset on each attempt
-            output_image = None
-            for part in response.candidates[0].content.parts:
-                if getattr(part, "text", None) is not None:
-                    # Optional: print any textual response
-                    print(part.text)
-                elif getattr(part, "inline_data", None) is not None:
-                    output_image = Image.open(BytesIO(part.inline_data.data)).convert("RGB")
-            # Success condition
-            if output_image is not None:
-                break
-        except Exception as e:
-            last_error = e
-            # Parsing failed; if not last attempt, wait and retry
-            if attempt < 5:
-                time.sleep(2)
-                continue
-            else:
-                print(f"Failed to parse GenAI response (attempt {attempt}/5): {e}")
-                break
-
-        # If we reached here with no image, wait then try again (unless last attempt)
-        if output_image is None and attempt < 5:
-            time.sleep(2)
-
-    # Optional save without using as a future fallback
-    if output_image is not None and save_to_disk:
-        try:
-            import os
-
-            os.makedirs("output", exist_ok=True)
-            output_image.save("output/generated_image.png")
-        except Exception:
-            pass
-
-    if output_image is None and last_error is not None:
-        # Keep return type unchanged; logging already printed above
-        pass
-
-    return output_image
-
-if __name__ == "__main__":
-    generate_genai_image()

genai copy.py

@@ -1,116 +0,0 @@
-from dotenv import load_dotenv
-from PIL import Image
-from typing import Optional
-from io import BytesIO
-import time
-
-load_dotenv()  # take environment variables from .env.
-
-from google import genai
-
-client = genai.Client()
-
-# Default creative prompt
-DEFAULT_PROMPT = (
-    "Turn the provided data visualization into a painting using an eastern art style."
-)
-
-
-def generate_genai_image(
-    input_image: Optional[Image.Image] = None,
-    prompt: Optional[str] = None,
-    model: str = "gemini-2.5-flash-image-preview",
-    save_to_disk: bool = False,
-) -> Optional[Image.Image]:
-    """Generate a stylized image from an input PIL image using Google GenAI.
-
-    Args:
-        input_image: Source PIL image. If None, calls weather_data_visualisation() to generate in-memory.
-        prompt: Optional text prompt; falls back to DEFAULT_PROMPT.
-        model: Model name to use.
-        save_to_disk: When True, saves to output/generated_image.png (no disk reads occur).
-
-    Returns:
-        A PIL.Image on success, or None if generation failed.
-    """
-
-    # Resolve input image strictly in-memory
-    img = input_image
-    if img is None:
-        try:
-            from weather_data_visualisation import weather_data_visualisation
-
-            img = weather_data_visualisation(save_to_disk=False)
-        except Exception:
-            img = None
-
-    if img is None:
-        return None
-
-    # Prepare prompt
-    ptxt = prompt or DEFAULT_PROMPT
-
-    output_image = None
-    last_error = None
-
-    # Retry up to 5 times, waiting 2 seconds between failed attempts
-    for attempt in range(1, 6):
-        try:
-            response = client.models.generate_content(
-                model=model,
-                contents=[ptxt, img],
-            )
-        except Exception as e:
-            last_error = e
-            # If not last attempt, wait and retry
-            if attempt < 5:
-                time.sleep(2)
-                continue
-            else:
-                print(f"GenAI request failed (attempt {attempt}/5): {e}")
-                break
-
-        try:
-            # Reset on each attempt
-            output_image = None
-            for part in response.candidates[0].content.parts:
-                if getattr(part, "text", None) is not None:
-                    # Optional: print any textual response
-                    print(part.text)
-                elif getattr(part, "inline_data", None) is not None:
-                    output_image = Image.open(BytesIO(part.inline_data.data)).convert("RGB")
-            # Success condition
-            if output_image is not None:
-                break
-        except Exception as e:
-            last_error = e
-            # Parsing failed; if not last attempt, wait and retry
-            if attempt < 5:
-                time.sleep(2)
-                continue
-            else:
-                print(f"Failed to parse GenAI response (attempt {attempt}/5): {e}")
-                break
-
-        # If we reached here with no image, wait then try again (unless last attempt)
-        if output_image is None and attempt < 5:
-            time.sleep(2)
-
-    # Optional save without using as a future fallback
-    if output_image is not None and save_to_disk:
-        try:
-            import os
-
-            os.makedirs("output", exist_ok=True)
-            output_image.save("output/generated_image.png")
-        except Exception:
-            pass
-
-    if output_image is None and last_error is not None:
-        # Keep return type unchanged; logging already printed above
-        pass
-
-    return output_image
-
-if __name__ == "__main__":
-    generate_genai_image()

genai.py

@@ -2,6 +2,7 @@ from dotenv import load_dotenv
 from PIL import Image
 from typing import Optional
 from io import BytesIO
+import time
 
 load_dotenv()  # take environment variables from .env.
 
@@ -49,27 +50,51 @@ def generate_genai_image(
     # Prepare prompt
     ptxt = prompt or DEFAULT_PROMPT
 
-    try:
-        response = client.models.generate_content(
-            model=model,
-            contents=[ptxt, img],
-        )
-    except Exception as e:
-        # No credentials or API issue
-        print(f"GenAI request failed: {e}")
-        return None
-
     output_image = None
-    try:
-        for part in response.candidates[0].content.parts:
-            if getattr(part, "text", None) is not None:
-                # Optional: print any textual response
-                print(part.text)
-            elif getattr(part, "inline_data", None) is not None:
-                output_image = Image.open(BytesIO(part.inline_data.data)).convert("RGB")
-    except Exception as e:
-        print(f"Failed to parse GenAI response: {e}")
-        return None
+    last_error = None
+
+    # Retry up to 5 times, waiting 2 seconds between failed attempts
+    for attempt in range(1, 6):
+        try:
+            response = client.models.generate_content(
+                model=model,
+                contents=[ptxt, img],
+            )
+        except Exception as e:
+            last_error = e
+            # If not last attempt, wait and retry
+            if attempt < 5:
+                time.sleep(2)
+                continue
+            else:
+                print(f"GenAI request failed (attempt {attempt}/5): {e}")
+                break
+
+        try:
+            # Reset on each attempt
+            output_image = None
+            for part in response.candidates[0].content.parts:
+                if getattr(part, "text", None) is not None:
+                    # Optional: print any textual response
+                    print(part.text)
+                elif getattr(part, "inline_data", None) is not None:
+                    output_image = Image.open(BytesIO(part.inline_data.data)).convert("RGB")
+            # Success condition
+            if output_image is not None:
+                break
+        except Exception as e:
+            last_error = e
+            # Parsing failed; if not last attempt, wait and retry
+            if attempt < 5:
+                time.sleep(2)
+                continue
+            else:
+                print(f"Failed to parse GenAI response (attempt {attempt}/5): {e}")
+                break
+
+        # If we reached here with no image, wait then try again (unless last attempt)
+        if output_image is None and attempt < 5:
+            time.sleep(2)
 
     # Optional save without using as a future fallback
     if output_image is not None and save_to_disk:
@@ -81,6 +106,10 @@ def generate_genai_image(
         except Exception:
             pass
 
+    if output_image is None and last_error is not None:
+        # Keep return type unchanged; logging already printed above
+        pass
+
     return output_image
 
 if __name__ == "__main__":