update

app.py

@@ -1,53 +1,67 @@
-import sys
 import os
-current_dir = os.path.dirname(os.path.abspath(__file__))
-src_path = os.path.join(current_dir, 'src')
-if src_path not in sys.path:
-    sys.path.insert(0, src_path)
-
 import gradio as gr
 import json
-from typing import Any, Dict, Generator
+from typing import Any, Dict, Tuple
 from dotenv import load_dotenv
 import gradio.themes as gr_themes
-import io
-from contextlib import redirect_stdout, redirect_stderr
+from urllib.request import urlopen, Request, urlretrieve
+from io import BytesIO
+from PIL import Image
+from functools import lru_cache
 
-# Load environment variables from a .env file for local development
+# Load environment variables from a .env file
 load_dotenv()
 
 # --- Secure Token Management ---
+# Get the Hugging Face token from environment variables
 VIDDEXA_TOKEN = os.getenv("HF_TOKEN")
 
 # A simple cache to store loaded model instances
 _MODEL_CACHE: Dict[str, Any] = {}
 
-
-def _load_model(model_id: str, user_hf_token: str | None = None):
-    """
-    Loads a model, caches it, and handles token management.
-    All print outputs from this function will be captured.
-    """
+# --- CSS Styles ---
+# Custom CSS for the verdict card
+CUSTOM_CSS = """
+.verdict-safe { background-color: #D5F5E3; border: 2px solid #2ECC71; color: #1D8348; }
+.verdict-sensitive { background-color: #FCF3CF; border: 2px solid #F1C40F; color: #B7950B; }
+.verdict-nsfw { background-color: #FADBD8; border: 2px solid #E74C3C; color: #B03A2E; }
+.verdict-card { padding: 20px; border-radius: 10px; text-align: center; font-size: 24px; font-weight: bold; }
+
+/* Responsive Galleries: show mobile (2 cols) on small screens, desktop (4 cols) on larger */
+#examples-gallery-mobile { display: block; }
+#examples-gallery-desktop { display: none; }
+@media (min-width: 900px) {
+  #examples-gallery-mobile { display: none; }
+  #examples-gallery-desktop { display: block; }
+}
+
+/* Ensure the Viddexa logo is readable on dark backgrounds */
+.viddexa-logo {
+  background-color: #FFFFFF; /* white background behind the SVG */
+  padding: 8px;              /* a little breathing room */
+  border-radius: 8px;        /* soften the corners */
+}
+"""
+
+
+# --- Helper Functions ---
+
+@lru_cache(maxsize=32)
+def _download_image_bytes(image_url: str) -> bytes:
+    req = Request(image_url, headers={"User-Agent": "viddexa-gradio-demo/1.0"})
+    with urlopen(req, timeout=20) as resp:
+        return resp.read()
+
+
+def _load_model(model_id: str) -> Any:
+    """Loads a model and caches it."""
     if model_id in _MODEL_CACHE:
-        print(f"Model '{model_id}' found in cache.")
         return _MODEL_CACHE[model_id]
-
-    print(f"Loading model '{model_id}'...")
-    active_token = None
-    if model_id == "viddexa/mobilenet_v2_1.0_224":
-        if not VIDDEXA_TOKEN:
-            raise gr.Error(
-                "The featured model 'viddexa/mobilenet_v2_1.0_224' requires an 'HF_TOKEN' to be set in the Space Secrets or a local .env file."
-            )
-        active_token = VIDDEXA_TOKEN
-    elif user_hf_token:
-        active_token = user_hf_token
-
     try:
         from moderators.auto_model import AutoModerator
-        model = AutoModerator.from_pretrained(model_id, token=active_token, use_fast=True)
+        # Download the model from Hugging Face
+        model = AutoModerator.from_pretrained(model_id, token=VIDDEXA_TOKEN, use_fast=True)
         _MODEL_CACHE[model_id] = model
-        print("Model loaded successfully.")
         return model
     except Exception as e:
         error_msg = f"Failed to load model: {model_id}. Error: {e}"
@@ -56,160 +70,301 @@ def _load_model(model_id: str, user_hf_token: str | None = None):
         raise gr.Error(error_msg)
 
 
-def _to_jsonable(results: Any) -> Any:
-    """Helper function to make model outputs JSON-serializable."""
+def _get_image_input(image_path: str | None, image_url: str | None) -> Image.Image:
+    """Gets image data from either an uploaded file path or a URL."""
+    if image_url:
+        try:
+            data = _download_image_bytes(image_url)
+            img = Image.open(BytesIO(data))
+            return img.convert("RGB")
+        except Exception as fetch_err:
+            raise gr.Error(f"Could not download or open the image from the URL: {fetch_err}")
+    elif image_path:
+        # Open the image from a local file
+        img = Image.open(image_path)
+        return img.convert("RGB")
+    else:
+        raise gr.Error("Please upload an image or provide an image URL.")
+
+
+def _format_results(results: list) -> Tuple[str, Dict[str, float], str, Dict]:
+    """Formats the model output for the Gradio interface."""
+    if not results or "classifications" not in results[0]:
+        return "<div class='verdict-card'>No classifications found.</div>", {}, "No classifications found.", {}
+
+    classifications = results[0]["classifications"]
+
+    # Normalize to a dict[str, float]
+    label_output: Dict[str, float]
+    if isinstance(classifications, dict):
+        label_output = {str(k): float(v) for k, v in classifications.items()}
+    else:
+        # Assume list[{'label': str, 'score': float}] shape
+        try:
+            label_output = {str(item['label']): float(item['score']) for item in classifications}
+        except Exception:
+            # Fallback to empty if unexpected
+            label_output = {}
+
+    # Determine the final verdict
+    scores = {label.lower(): score for label, score in label_output.items()}
+    nsfw_score = scores.get("nsfw", 0.0)
+
+    if nsfw_score > 0.7:
+        verdict_text = "HIGH RISK: NSFW"
+        verdict_class = "verdict-nsfw"
+    elif nsfw_score > 0.2:
+        verdict_text = "MEDIUM RISK: SENSITIVE"
+        verdict_class = "verdict-sensitive"
+    else:
+        verdict_text = "LOW RISK: SAFE"
+        verdict_class = "verdict-safe"
+
+    verdict_html = f"<div class='verdict-card {verdict_class}'>{verdict_text}</div>"
+
+    # Prepare scores for Markdown list
+    markdown_output = "### All Scores\n---\n"
+    for label, score in sorted(label_output.items(), key=lambda kv: kv[1], reverse=True):
+        markdown_output += f"- **{label.capitalize()}**: {score:.4f}\n"
+
+    return verdict_html, label_output, markdown_output, results[0]
+
+
+# --- Main Analysis Function ---
+
+def analyze_image(image_path: str | None, image_url: str | None, model_choice: str,
+                  progress=gr.Progress(track_tqdm=True)):
+    """The main inference function for the Gradio interface."""
+    progress(0, desc="Initializing Analysis...")
+
+    # 1. Get Image Input
+    progress(0.2, desc="Processing Image...")
+    input_image = _get_image_input(image_path, image_url)
+
+    # 2. Load Model
+    progress(0.5, desc=f"Loading Model: {os.path.basename(model_choice)}...")
+    model = _load_model(model_choice)
+
+    # 3. Run Inference
+    progress(0.8, desc="Running Inference...")
+    results = model(input_image)
+
+    # Helper to make model outputs JSON-serializable and in expected shape
+    json_results = [
+        {"classifications": getattr(r, "classifications", r)}
+        for r in results
+    ]
+    json_results = json.loads(json.dumps(json_results, ensure_ascii=False))
+
+    # 4. Format and Return Results
+    progress(1, desc="Complete!")
+    return _format_results(json_results)
+
+
+def analyze_image_from_url(image_url: str, model_choice: str, progress=gr.Progress(track_tqdm=True)):
+    """Wrapper to run examples with just URL + model."""
+    return analyze_image(None, image_url, model_choice, progress)
+
+
+def analyze_image_with_status(image_path: str | None, image_url: str | None, model_choice: str,
+                              progress=gr.Progress(track_tqdm=True)):
+    """Run analysis and also return a user-friendly status string."""
+    verdict_html, label_scores, md_scores, json_obj = analyze_image(image_path, image_url, model_choice, progress)
+    if image_url:
+        status = f"Last analysed URL: {image_url}"
+    elif image_path:
+        status = "Last analysed uploaded image."
+    else:
+        status = "Last analysed: —"
+    return verdict_html, label_scores, md_scores, json_obj, status
+
+
+# Example mapping for gallery selections
+EXAMPLE_ITEMS = [
+    (
+        "https://assets.clevelandclinic.org/transform/LargeFeatureImage/cd71f4bd-81d4-45d8-a450-74df78e4477a/Apples-184940975-770x533-1_jpg",
+        "viddexa/nsfw-mini",
+        "Apples (mini)",
+    ),
+    (
+        "https://img.freepik.com/free-photo/breast-screening-is-very-important-every-woman_329181-14953.jpg",
+        "viddexa/nsfw-nano",
+        "Breast screening (nano)",
+    ),
+    (
+        "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSbRwt56NYsiHwrT8oS-igzgeEzp7p3Jbe2dw&s",
+        "viddexa/nsfw-mini",
+        "Thumbnail (mini)",
+    ),
+    (
+        "https://img.freepik.com/premium-photo/portrait-beautiful-young-woman_1048944-5548042.jpg",
+        "viddexa/nsfw-nano",
+        "Portrait (nano)",
+    ),
+]
+
+
+def run_example_by_index(evt: gr.SelectData):
+    """Handle gallery selection: run analysis for the selected example and update inputs."""
     try:
-        return [getattr(r, "classifications", r) for r in results]
-    except TypeError:
-        return results
+        idx = int(getattr(evt, "index", 0))
     except Exception:
-        return results
-
-
-# --- NEW: Rewritten 'infer' function as a generator to stream logs ---
-def infer(image_path: str, model_choice: str, custom_model_id: str, user_hf_token: str) -> Generator[
-    tuple[str, Any], None, None]:
-    """
-    The main inference function that now yields updates to stream logs to the UI.
-    """
-    # 1. Clear previous outputs and show an initial message
-    yield "Starting analysis...", None
-
-    if not image_path:
-        raise gr.Error("Please upload an image first.")
-
-    log_stream = io.StringIO()
-    try:
-        # 2. Capture all printed output from the loading and inference process
-        with redirect_stdout(log_stream), redirect_stderr(log_stream):
-            if model_choice == "Custom Model":
-                model_id = (custom_model_id or "").strip()
-                if not model_id:
-                    raise gr.Error("Please enter the Hugging Face ID for your custom model.")
-            else:
-                model_id = model_choice
-                user_hf_token = ""
-
-            # Load model and yield logs generated during loading
-            model = _load_model(model_id, user_hf_token)
-            yield log_stream.getvalue(), None
-
-            # Run inference and yield any new logs
-            print("\nRunning inference on the image...")
-            results = model(image_path)
-            print("Inference complete.")
-            yield log_stream.getvalue(), None
-
-        # 3. Process the final result and yield it with the complete log
-        final_json = json.loads(json.dumps(_to_jsonable(results), ensure_ascii=False, indent=2))
-        yield log_stream.getvalue(), final_json
-
-    except gr.Error as e:
-        # If a Gradio error happens, show it in the logs
-        yield str(e), None
-    except Exception as e:
-        # For other exceptions, capture the error message and show it
-        yield f"An unexpected error occurred:\n{e}", None
-
-
-def on_model_choice_change(choice: str):
-    """Shows or hides the custom model input fields based on the dropdown selection."""
-    return gr.update(visible=(choice == "Custom Model"))
-
-
-# --- Enhanced Gradio Interface with a Log Viewer ---
-with gr.Blocks(
-        theme=gr_themes.Default(
-            primary_hue="blue",
-            secondary_hue="neutral",
-            font=gr_themes.GoogleFont("Inter")
-        ),
-        title="Moderators - Visual Content Moderation"
-) as demo:
-    gr.Markdown("# 🖼️ Moderators: Visual Content Moderation")
-    gr.Markdown(
-        "Analyze an image using the featured `viddexa/mobilenet_v2_1.0_224` model, "
-        "or select another model from the list. You can also use your own private or public model from the Hub."
+        idx = 0
+    idx = max(0, min(idx, len(EXAMPLE_ITEMS) - 1))
+    url, model, caption = EXAMPLE_ITEMS[idx]
+    verdict_html, label_scores, md_scores, json_obj = analyze_image(None, url, model)
+    status = f"Last analysed example: {caption}"
+    # Also update the dropdown and URL textbox for transparency
+    return (
+        verdict_html,
+        label_scores,
+        md_scores,
+        json_obj,
+        gr.update(value=model),
+        gr.update(value=url),
+        status,
     )
 
-    with gr.Row(variant="panel"):
-        # Column 1: Controls and Inputs
-        with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ Controls")
+
+# --- Gradio Interface ---
+
+with gr.Blocks(theme=gr_themes.Soft(), title="Viddexa - Visual Content Moderation", css=CUSTOM_CSS) as demo:
+    # Header and Introduction
+    gr.HTML("""
+    <div class=\"viddexa-header\" style=\"text-align: center; max-width: 800px; margin: 0 auto;\">
+        <img class=\"viddexa-logo\" src=\"https://aky-tech.com/images/viddexa-logo.svg\" alt=\"Viddexa logo\" style=\"max-width: 320px; width: 80%; height: auto; display: block; margin: 10px auto 6px;\" />
+        <p style=\"font-size: 1.2em; color: #888;\">
+            This demo showcases the open-source <code>moderators</code> Python package and NSFW (Not Safe For Work) detection models developed by <b>Viddexa</b>.
+            Upload an image or provide a URL to get an instant content analysis.
+        </p>
+        <p>
+            🔗 <b>Project Links:</b>
+            <a href=\"https://huggingface.co/viddexa/nsfw-mini\" target=\"_blank\">[Model: nsfw-mini]</a> |
+            <a href=\"https://huggingface.co/viddexa/nsfw-nano\" target=\"_blank\">[Model: nsfw-nano]</a> |
+            <a href=\"https://github.com/viddexa/moderators\" target=\"_blank\">[GitHub]</a> |
+            <a href=\"https://pypi.org/project/moderators/\" target=\"_blank\">[PyPI]</a>
+        </p>
+    </div>
+    """)
+
+    with gr.Row(variant="panel") as main_row:
+        # Capture both columns so we can add widgets in any order
+        with gr.Column(scale=1, min_width=350) as left_col:
+            gr.Markdown("## ⚙️ Step 1: Configure Settings")
             model_choice = gr.Dropdown(
-                choices=[
-                    "viddexa/mobilenet_v2_1.0_224",
-                    "Falconsai/nsfw_image_detection",
-                    "Custom Model",
-                ],
-                value="viddexa/mobilenet_v2_1.0_224",
-                label="Select Model",
-                info="Choose a model for the analysis.",
+                choices=["viddexa/nsfw-mini", "viddexa/nsfw-nano"],
+                value="viddexa/nsfw-mini",
+                label="Analysis Model",
+                info="Choose the faster 'nano' or the more comprehensive 'mini' model.",
             )
 
-            with gr.Group(visible=False) as custom_model_group:
-                custom_model_id = gr.Textbox(
-                    label="Custom Hugging Face Model ID",
-                    placeholder="username/model-name",
-                    info="Enter the ID of the model you want to use."
-                )
-                user_hf_token = gr.Textbox(
-                    label='HF Token (if your model is private)',
-                    type="password",
-                    placeholder="hf_...",
-                    info="An access token is required for private models."
-                )
-
-            gr.Markdown("### 🖼️ Upload Image")
-            image_input = gr.Image(type="filepath", label="Image to analyze")
-
-            run_btn = gr.Button("Analyze", variant="primary")
-
-            gr.Examples(
-                examples=[
-                    ["https://assets.clevelandclinic.org/transform/LargeFeatureImage/cd71f4bd-81d4-45d8-a450-74df78e4477a/Apples-184940975-770x533-1_jpg",
-                     "viddexa/mobilenet_v2_1.0_224"],
-                    ["https://img.freepik.com/free-photo/breast-screening-is-very-important-every-woman_329181-14953.jpg",
-                     "Falconsai/nsfw_image_detection"],
-                    ["https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSbRwt56NYsiHwrT8oS-igzgeEzp7p3Jbe2dw&s",
-                     "viddexa/mobilenet_v2_1.0_224"],
-                    ["https://img.freepik.com/premium-photo/portrait-beautiful-young-woman_1048944-5548042.jpg",
-                     "Falconsai/nsfw_image_detection"]
-                ],
-                inputs=[image_input, model_choice],
-                label="Click an example to run",
-            )
+            gr.Markdown("## 🖼️ Step 2: Provide an Image")
+            with gr.Tabs() as input_tabs:
+                with gr.TabItem("Upload Image", id="upload_tab"):
+                    image_input = gr.Image(type="filepath", label="Drag & drop a file or click to upload")
+                with gr.TabItem("From URL", id="url_tab"):
+                    image_url_input = gr.Textbox(
+                        label="Image URL",
+                        placeholder="https://example.com/image.jpg",
+                    )
+
+            run_btn = gr.Button("Start Analysis", variant="primary", scale=2)
 
         # Column 2: Outputs
-        with gr.Column(scale=2):
-            gr.Markdown("### 📊 Results")
-            # --- NEW: Status Log Textbox ---
-            status_log = gr.Textbox(
-                label="Status Logs",
-                info="Shows model loading progress and other technical details.",
-                interactive=False,
-                lines=8,  # Give it some height
-            )
-            output_json = gr.JSON(label="Model Output (JSON)")
+        with gr.Column(scale=2, min_width=500) as right_col:
+            gr.Markdown("## 📊 Step 3: Review Results")
+            verdict_output = gr.HTML(label="Final Verdict")
+            label_output = gr.Label(label="Classification Scores", num_top_classes=4, show_label=True)
+            markdown_output = gr.Markdown(label="All Scores")
+
+            with gr.Accordion("Show Raw JSON Output", open=False):
+                json_output = gr.JSON(label="Model Output (JSON)")
+
+    # Full-width Examples Gallery section
+    gr.Markdown("## 🎯 Try an Example (click an image)")
+    gallery_items = [[url, caption] for (url, _model, caption) in EXAMPLE_ITEMS]
+    examples_gallery_mobile = gr.Gallery(
+        label="Try an Example",
+        value=gallery_items,
+        columns=2,
+        height="auto",
+        allow_preview=False,
+        elem_id="examples-gallery-mobile",
+    )
+    examples_gallery_desktop = gr.Gallery(
+        label=None,
+        value=gallery_items,
+        columns=4,
+        height="auto",
+        allow_preview=False,
+        elem_id="examples-gallery-desktop",
+    )
 
-    # Define the interactive events
+    # Status label under galleries
+    status_md = gr.Markdown("Last analyse: —", elem_id="last-example-status")
+
+    # When a gallery image is selected, run analysis and update outputs + inputs + status
+    for gallery in (examples_gallery_mobile, examples_gallery_desktop):
+        gallery.select(
+            fn=run_example_by_index,
+            outputs=[
+                verdict_output,
+                label_output,
+                markdown_output,
+                json_output,
+                model_choice,
+                image_url_input,
+                status_md,
+            ],
+        )
+
+    # Interactive Event Listeners
+
+    # When the analysis button is clicked
     run_btn.click(
-        fn=infer,
-        inputs=[image_input, model_choice, custom_model_id, user_hf_token],
-        # --- NEW: The click event now updates both the log and the JSON output ---
-        outputs=[status_log, output_json],
+        fn=analyze_image_with_status,
+        inputs=[image_input, image_url_input, model_choice],
+        outputs=[verdict_output, label_output, markdown_output, json_output, status_md],
     )
 
-    model_choice.change(
-        fn=on_model_choice_change,
-        inputs=model_choice,
-        outputs=custom_model_group,
+    # Clear the other input when one changes (avoid relying on Tabs.select on some Gradio versions)
+    def _clear_url_on_image_change(_img):
+        # Keep image as-is, clear URL
+        return gr.update(), gr.update(value="")
+
+    def _clear_image_on_url_change(_url):
+        # Clear uploaded image, keep URL as-is
+        return gr.update(value=None), gr.update()
+
+    image_input.change(
+        fn=_clear_url_on_image_change,
+        inputs=[image_input],
+        outputs=[image_input, image_url_input],
+    )
+    image_url_input.change(
+        fn=_clear_image_on_url_change,
+        inputs=[image_url_input],
+        outputs=[image_input, image_url_input],
     )
 
+    gr.HTML("""
+    <div style=\"text-align: center; margin-top: 20px; color: #888;\">
+        <p>Developed by Viddexa.</p>
+    </div>
+    """)
+
 if __name__ == "__main__":
+    # Create an 'examples' directory and download a sample image if it doesn't exist
     if not os.path.exists("examples"):
         os.makedirs("examples")
         print("Created 'examples' directory.")
-        print("Please add some images like 'safe_image.jpg' to it for the examples to work.")
+        try:
+            urlretrieve(
+                "https://images.pexels.com/photos/36717/amazing-animal-beautiful-beautifull.jpg",
+                "examples/safe_nature.jpg"
+            )
+            print("Downloaded an example image to 'examples/safe_nature.jpg'")
+        except Exception as e:
+            print(f"Could not download example image: {e}")
 
     demo.launch()

requirements.txt

@@ -6,4 +6,7 @@ transformers>=4.36
 
 # Transformers'ın çalışması için gereken backend ve yardımcı kütüphaneler
 torch
-Pillow
+Pillow
+
+# Moderators artık paket olarak kullanılıyor
+moderators