Add files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -4,6 +4,7 @@ emoji: 🔥
 colorFrom: yellow
 colorTo: green
 sdk: gradio
+python_version: 3.12.12
 sdk_version: 6.5.1
 app_file: app.py
 pinned: false

app.py

@@ -0,0 +1,343 @@
+import os
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+from detection_viewer import DetectionViewer
+from PIL import Image
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForZeroShotObjectDetection,
+    AutoProcessor,
+    Mask2FormerForUniversalSegmentation,
+    RTDetrForObjectDetection,
+    RTDetrImageProcessor,
+    VitPoseForPoseEstimation,
+)
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+USE_SMALL_MODELS = os.environ.get("USE_SMALL_MODELS", "0") == "1"
+ASSETS_DIR = Path(__file__).parent / "assets"
+
+# ============================================================
+# RT-DETR (Object Detection)
+# ============================================================
+RTDETR_MODEL_ID = "PekingU/rtdetr_r18vd" if USE_SMALL_MODELS else "PekingU/rtdetr_r101vd"
+rtdetr_processor = RTDetrImageProcessor.from_pretrained(RTDETR_MODEL_ID)
+rtdetr_model = RTDetrForObjectDetection.from_pretrained(RTDETR_MODEL_ID).eval().to(device)
+
+# ============================================================
+# Grounding DINO (Zero-Shot Detection)
+# ============================================================
+GDINO_MODEL_ID = "IDEA-Research/grounding-dino-tiny" if USE_SMALL_MODELS else "IDEA-Research/grounding-dino-base"
+gdino_processor = AutoProcessor.from_pretrained(GDINO_MODEL_ID)
+gdino_model = AutoModelForZeroShotObjectDetection.from_pretrained(GDINO_MODEL_ID).eval().to(device)
+
+# ============================================================
+# Mask2Former (Instance Segmentation)
+# ============================================================
+M2F_MODEL_ID = (
+    "facebook/mask2former-swin-tiny-coco-instance"
+    if USE_SMALL_MODELS
+    else "facebook/mask2former-swin-large-coco-instance"
+)
+m2f_processor = AutoImageProcessor.from_pretrained(M2F_MODEL_ID)
+m2f_model = Mask2FormerForUniversalSegmentation.from_pretrained(M2F_MODEL_ID).eval().to(device)
+
+# ============================================================
+# ViTPose (Pose Estimation)
+# ============================================================
+VITPOSE_DET_MODEL_ID = "PekingU/rtdetr_r18vd" if USE_SMALL_MODELS else "PekingU/rtdetr_r50vd"
+vitpose_det_processor = AutoProcessor.from_pretrained(VITPOSE_DET_MODEL_ID)
+vitpose_det_model = RTDetrForObjectDetection.from_pretrained(VITPOSE_DET_MODEL_ID).eval().to(device)
+PERSON_LABEL_ID = next(k for k, v in vitpose_det_model.config.id2label.items() if v == "person")
+
+VITPOSE_MODEL_ID = "usyd-community/vitpose-base-simple" if USE_SMALL_MODELS else "usyd-community/vitpose-plus-large"
+VITPOSE_IS_MOE = not USE_SMALL_MODELS  # vitpose-plus models use Mixture-of-Experts heads
+vitpose_processor = AutoProcessor.from_pretrained(VITPOSE_MODEL_ID)
+vitpose_model = VitPoseForPoseEstimation.from_pretrained(VITPOSE_MODEL_ID).eval().to(device)
+SKELETON = vitpose_model.config.edges
+
+COCO_KEYPOINT_NAMES = [
+    "nose",
+    "left_eye",
+    "right_eye",
+    "left_ear",
+    "right_ear",
+    "left_shoulder",
+    "right_shoulder",
+    "left_elbow",
+    "right_elbow",
+    "left_wrist",
+    "right_wrist",
+    "left_hip",
+    "right_hip",
+    "left_knee",
+    "right_knee",
+    "left_ankle",
+    "right_ankle",
+]
+
+
+# ============================================================
+# Utilities
+# ============================================================
+def _mask_to_rle(mask: np.ndarray) -> dict:
+    """Convert a binary mask to uncompressed RLE (column-major / COCO format)."""
+    h, w = mask.shape
+    flat = mask.ravel(order="F")
+    changes = np.diff(flat)
+    change_idx = np.flatnonzero(changes)
+    runs = np.diff(np.concatenate([[-1], change_idx, [len(flat) - 1]]))
+    counts = runs.tolist()
+    if flat[0] == 1:
+        counts = [0, *counts]
+    return {"counts": counts, "size": [h, w]}
+
+
+def _mask_to_bbox(mask: np.ndarray) -> dict:
+    """Compute bounding box from a binary mask."""
+    ys, xs = np.where(mask)
+    x_min, x_max = int(xs.min()), int(xs.max())
+    y_min, y_max = int(ys.min()), int(ys.max())
+    return {"x": x_min, "y": y_min, "width": x_max - x_min + 1, "height": y_max - y_min + 1}
+
+
+# ============================================================
+# Inference helpers
+# ============================================================
+def _detect_rtdetr(image: Image.Image, _labels: str, threshold: float) -> tuple[Image.Image, list[dict], dict]:
+    inputs = rtdetr_processor(images=image, return_tensors="pt").to(device)
+    outputs = rtdetr_model(**inputs)
+    results = rtdetr_processor.post_process_object_detection(
+        outputs,
+        target_sizes=torch.tensor([(image.height, image.width)]),
+        threshold=threshold,
+    )[0]
+
+    annotations = []
+    for score, label_id, box in zip(results["scores"], results["labels"], results["boxes"], strict=True):
+        x_min, y_min, x_max, y_max = box.tolist()
+        annotations.append(
+            {
+                "bbox": {"x": x_min, "y": y_min, "width": x_max - x_min, "height": y_max - y_min},
+                "score": round(score.item(), 3),
+                "label": rtdetr_model.config.id2label[label_id.item()],
+            }
+        )
+
+    return image, annotations, {"score_threshold": (threshold, 1.0)}
+
+
+def _detect_gdino(image: Image.Image, labels: str, threshold: float) -> tuple[Image.Image, list[dict], dict]:
+    text = labels.strip().rstrip(".")
+    candidate_labels = [part.strip() for part in text.split(",") if part.strip()]
+    text_prompt = ". ".join(candidate_labels) + "."
+
+    inputs = gdino_processor(images=image, text=text_prompt, return_tensors="pt").to(device)
+    outputs = gdino_model(**inputs)
+    results = gdino_processor.post_process_grounded_object_detection(
+        outputs,
+        input_ids=inputs["input_ids"],
+        target_sizes=[(image.height, image.width)],
+        threshold=threshold,
+        text_threshold=threshold,
+    )[0]
+
+    annotations = []
+    for score, label, box in zip(results["scores"], results["labels"], results["boxes"], strict=True):
+        x_min, y_min, x_max, y_max = box.tolist()
+        annotations.append(
+            {
+                "bbox": {"x": x_min, "y": y_min, "width": x_max - x_min, "height": y_max - y_min},
+                "score": round(float(score), 3),
+                "label": label,
+            }
+        )
+
+    return image, annotations, {"score_threshold": (threshold, 1.0)}
+
+
+def _detect_m2f(image: Image.Image, _labels: str, threshold: float) -> tuple[Image.Image, list[dict], dict]:
+    inputs = m2f_processor(images=image, return_tensors="pt").to(device)
+    outputs = m2f_model(**inputs)
+    results = m2f_processor.post_process_instance_segmentation(
+        outputs,
+        target_sizes=[(image.height, image.width)],
+        threshold=threshold,
+    )[0]
+
+    segmentation = results["segmentation"].cpu().numpy().astype(np.uint8)
+    annotations = []
+    for segment in results["segments_info"]:
+        binary_mask = (segmentation == segment["id"]).astype(np.uint8)
+        if binary_mask.sum() == 0:
+            continue
+        annotations.append(
+            {
+                "bbox": _mask_to_bbox(binary_mask),
+                "mask": _mask_to_rle(binary_mask),
+                "score": round(float(segment["score"]), 3),
+                "label": m2f_model.config.id2label[int(segment["label_id"])],
+            }
+        )
+
+    return image, annotations, {"score_threshold": (threshold, 1.0)}
+
+
+def _detect_vitpose(
+    image: Image.Image, _labels: str, threshold: float
+) -> tuple[Image.Image, list[dict], dict] | tuple[Image.Image, list]:
+    # Step 1: Detect persons with RT-DETR
+    det_inputs = vitpose_det_processor(images=image, return_tensors="pt").to(device)
+    det_outputs = vitpose_det_model(**det_inputs)
+    det_results = vitpose_det_processor.post_process_object_detection(
+        det_outputs,
+        target_sizes=torch.tensor([(image.height, image.width)]),
+        threshold=threshold,
+    )[0]
+
+    person_mask = det_results["labels"] == PERSON_LABEL_ID
+    person_boxes_voc = det_results["boxes"][person_mask].cpu().numpy()
+    person_scores = det_results["scores"][person_mask].cpu().numpy()
+
+    if len(person_boxes_voc) == 0:
+        return image, []
+
+    # Convert VOC (x1, y1, x2, y2) to COCO (x, y, w, h)
+    person_boxes_coco = person_boxes_voc.copy()
+    person_boxes_coco[:, 2] = person_boxes_voc[:, 2] - person_boxes_voc[:, 0]
+    person_boxes_coco[:, 3] = person_boxes_voc[:, 3] - person_boxes_voc[:, 1]
+
+    # Step 2: Estimate keypoints with ViTPose
+    pose_inputs = vitpose_processor(image, boxes=[person_boxes_coco], return_tensors="pt").to(device)
+    forward_kwargs = dict(pose_inputs)
+    if VITPOSE_IS_MOE:
+        # COCO dataset index = 0 for vitpose-plus MoE heads
+        forward_kwargs["dataset_index"] = torch.zeros(pose_inputs["pixel_values"].shape[0], dtype=torch.long, device=device)
+    pose_outputs = vitpose_model(**forward_kwargs)
+    pose_results = vitpose_processor.post_process_pose_estimation(pose_outputs, boxes=[person_boxes_coco])
+
+    # Step 3: Build annotations
+    annotations = []
+    for i, pose_result in enumerate(pose_results[0]):
+        keypoints_xy = pose_result["keypoints"].cpu().numpy()
+        keypoints_scores = pose_result["scores"].cpu().numpy()
+
+        x1, y1, x2, y2 = person_boxes_voc[i]
+        keypoints = [
+            {
+                "x": float(keypoints_xy[j][0]),
+                "y": float(keypoints_xy[j][1]),
+                "name": COCO_KEYPOINT_NAMES[j],
+                "confidence": round(float(keypoints_scores[j]), 3),
+            }
+            for j in range(len(keypoints_xy))
+        ]
+
+        annotations.append(
+            {
+                "bbox": {"x": float(x1), "y": float(y1), "width": float(x2 - x1), "height": float(y2 - y1)},
+                "score": round(float(person_scores[i]), 3),
+                "label": "person",
+                "keypoints": keypoints,
+                "connections": SKELETON,
+            }
+        )
+
+    return image, annotations, {"score_threshold": (threshold, 1.0)}
+
+
+# ============================================================
+# Dispatcher
+# ============================================================
+TASK_OBJECT_DETECTION = "Object Detection"
+TASK_ZERO_SHOT_DETECTION = "Zero-Shot Detection"
+TASK_INSTANCE_SEGMENTATION = "Instance Segmentation"
+TASK_POSE_ESTIMATION = "Pose Estimation"
+
+TASK_CHOICES = [
+    TASK_OBJECT_DETECTION,
+    TASK_ZERO_SHOT_DETECTION,
+    TASK_INSTANCE_SEGMENTATION,
+    TASK_POSE_ESTIMATION,
+]
+
+
+_TASK_DISPATCH = {
+    TASK_OBJECT_DETECTION: _detect_rtdetr,
+    TASK_ZERO_SHOT_DETECTION: _detect_gdino,
+    TASK_INSTANCE_SEGMENTATION: _detect_m2f,
+    TASK_POSE_ESTIMATION: _detect_vitpose,
+}
+
+
+@spaces.GPU
+@torch.inference_mode()
+def run_detection(
+    image: Image.Image, task: str, labels: str, threshold: float
+) -> tuple[Image.Image, list[dict], dict] | None:
+    if image is None:
+        return None
+    if task == TASK_ZERO_SHOT_DETECTION and not labels.strip():
+        return None
+    return _TASK_DISPATCH[task](image, labels, threshold)  # type: ignore[return-value]
+
+
+# ============================================================
+# UI
+# ============================================================
+with gr.Blocks(title="Detection Viewer Demo") as demo:
+    gr.Markdown("# Detection Viewer Demo")
+    gr.Markdown(
+        "Showcase of the **Detection Viewer** Gradio custom component "
+        "— visualizing bounding boxes, segmentation masks, keypoints, and skeleton connections."
+    )
+
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(label="Input Image", type="pil")
+            task_selector = gr.Radio(
+                choices=TASK_CHOICES,
+                value=TASK_OBJECT_DETECTION,
+                label="Task",
+            )
+            labels_input = gr.Textbox(
+                label="Labels (comma-separated)",
+                placeholder="person, dog, car, chair",
+                value="person, dog, cat, car",
+                visible=False,
+            )
+            threshold = gr.Slider(label="Confidence Threshold", minimum=0.0, maximum=1.0, step=0.05, value=0.3)
+            run_btn = gr.Button("Detect", variant="primary")
+        with gr.Column():
+            viewer = DetectionViewer(label="Detection Results", keypoint_threshold=0.3)
+
+    task_selector.change(
+        fn=lambda task: gr.update(visible=task == TASK_ZERO_SHOT_DETECTION),
+        inputs=task_selector,
+        outputs=labels_input,
+    )
+
+    run_btn.click(
+        fn=run_detection,
+        inputs=[input_image, task_selector, labels_input, threshold],
+        outputs=viewer,
+    )
+
+    gr.Examples(
+        examples=[
+            [str(ASSETS_DIR / "kitchen.jpg"), TASK_OBJECT_DETECTION, "", 0.3],
+            [str(ASSETS_DIR / "office.jpg"), TASK_ZERO_SHOT_DETECTION, "person, laptop, notebook, pencil, glasses, watch, potted plant, bookshelf, window", 0.3],
+            [str(ASSETS_DIR / "traffic.jpg"), TASK_INSTANCE_SEGMENTATION, "", 0.3],
+            [str(ASSETS_DIR / "people.jpg"), TASK_POSE_ESTIMATION, "", 0.3],
+        ],
+        inputs=[input_image, task_selector, labels_input, threshold],
+        fn=run_detection,
+        outputs=viewer,
+    )
+
+if __name__ == "__main__":
+    demo.launch()

pyproject.toml

@@ -0,0 +1,67 @@
+[project]
+name = "detection-viewer-demo"
+version = "0.1.0"
+description = "Combined demo Space for the Detection Viewer component"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "detection-viewer",
+    "gradio>=6.5.1",
+    "scipy>=1.17.0",
+    "spaces>=0.34.0",
+    "torch==2.9.1",
+    "transformers>=5.1.0",
+]
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.1",
+]
+hf-spaces = [
+    "datasets>=4.5.0",
+]
+
+[tool.ruff]
+line-length = 119
+exclude = ["*.pyi"]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "COM812", # missing-trailing-comma
+    "D203",   # one-blank-line-before-class
+    "D213",   # multi-line-summary-second-line
+    "E501",   # line-too-long
+    "SIM117", # multiple-with-statements
+    #
+    "D100",    # undocumented-public-module
+    "D101",    # undocumented-public-class
+    "D102",    # undocumented-public-method
+    "D103",    # undocumented-public-function
+    "D104",    # undocumented-public-package
+    "D105",    # undocumented-magic-method
+    "D107",    # undocumented-public-init
+    "EM101",   # raw-string-in-exception
+    "FBT001",  # boolean-type-hint-positional-argument
+    "FBT002",  # boolean-default-value-positional-argument
+    "ISC001",  # single-line-implicit-string-concatenation
+    "PGH003",  # blanket-type-ignore
+    "PLR0913", # too-many-arguments
+    "PLR0915", # too-many-statements
+    "TRY003",  # raise-vanilla-args
+]
+unfixable = [
+    "F401", # unused-import
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.per-file-ignores]
+"app.py" = ["INP001"]
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.uv.sources]
+detection-viewer = { url = "https://huggingface.co/spaces/hysts-gradio-custom-html/detection-viewer/resolve/main/dist/detection_viewer-0.1.0-py3-none-any.whl" }

requirements.txt

@@ -0,0 +1,254 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --format requirements.txt --no-hashes --no-emit-package typer-slim -o requirements.txt
+aiofiles==24.1.0
+    # via gradio
+annotated-doc==0.0.4
+    # via
+    #   fastapi
+    #   typer
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.12.1
+    # via
+    #   gradio
+    #   httpx
+    #   starlette
+audioop-lts==0.2.2 ; python_full_version >= '3.13'
+    # via gradio
+brotli==1.2.0
+    # via gradio
+certifi==2026.1.4
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.4
+    # via requests
+click==8.3.1
+    # via
+    #   typer
+    #   uvicorn
+colorama==0.4.6 ; sys_platform == 'win32'
+    # via
+    #   click
+    #   tqdm
+detection-viewer @ https://huggingface.co/spaces/hysts-gradio-custom-html/detection-viewer/resolve/main/dist/detection_viewer-0.1.0-py3-none-any.whl
+    # via detection-viewer-demo
+fastapi==0.129.0
+    # via gradio
+ffmpy==1.0.0
+    # via gradio
+filelock==3.24.2
+    # via
+    #   huggingface-hub
+    #   torch
+fsspec==2025.10.0
+    # via
+    #   gradio-client
+    #   huggingface-hub
+    #   torch
+gradio==6.5.1
+    # via
+    #   detection-viewer
+    #   detection-viewer-demo
+    #   spaces
+gradio-client==2.0.3
+    # via gradio
+groovy==0.1.2
+    # via gradio
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+hf-xet==1.2.0 ; platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   safehttpx
+    #   spaces
+huggingface-hub==1.4.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   tokenizers
+    #   transformers
+idna==3.11
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+jinja2==3.1.6
+    # via
+    #   gradio
+    #   torch
+markdown-it-py==4.0.0
+    # via rich
+markupsafe==3.0.3
+    # via
+    #   gradio
+    #   jinja2
+mdurl==0.1.2
+    # via markdown-it-py
+mpmath==1.3.0
+    # via sympy
+networkx==3.6.1
+    # via torch
+numpy==2.4.2
+    # via
+    #   gradio
+    #   pandas
+    #   scipy
+    #   transformers
+nvidia-cublas-cu12==12.8.4.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.10.2.21 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.3.3.83 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufile-cu12==1.13.1.3 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.9.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.7.3.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.5.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cusparselt-cu12==0.7.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nccl-cu12==2.27.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvshmem-cu12==3.3.20 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvtx-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+orjson==3.11.7
+    # via gradio
+packaging==26.0
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   spaces
+    #   transformers
+pandas==3.0.0
+    # via gradio
+pillow==12.1.1
+    # via gradio
+psutil==5.9.8
+    # via spaces
+pydantic==2.12.5
+    # via
+    #   fastapi
+    #   gradio
+    #   spaces
+pydantic-core==2.41.5
+    # via pydantic
+pydub==0.25.1
+    # via gradio
+pygments==2.19.2
+    # via rich
+python-dateutil==2.9.0.post0
+    # via pandas
+python-multipart==0.0.22
+    # via gradio
+pytz==2025.2
+    # via gradio
+pyyaml==6.0.3
+    # via
+    #   gradio
+    #   huggingface-hub
+    #   transformers
+regex==2026.1.15
+    # via transformers
+requests==2.32.5
+    # via spaces
+rich==14.3.2
+    # via typer
+ruff==0.15.1
+safehttpx==0.1.7
+    # via gradio
+safetensors==0.7.0
+    # via transformers
+scipy==1.17.0
+    # via detection-viewer-demo
+semantic-version==2.10.0
+    # via gradio
+setuptools==82.0.0
+    # via torch
+shellingham==1.5.4
+    # via
+    #   huggingface-hub
+    #   typer
+six==1.17.0
+    # via python-dateutil
+spaces==0.47.0
+    # via detection-viewer-demo
+starlette==0.52.1
+    # via
+    #   fastapi
+    #   gradio
+sympy==1.14.0
+    # via torch
+tokenizers==0.22.2
+    # via transformers
+tomlkit==0.13.3
+    # via gradio
+torch==2.9.1
+    # via detection-viewer-demo
+tqdm==4.67.3
+    # via
+    #   huggingface-hub
+    #   transformers
+transformers==5.2.0
+    # via detection-viewer-demo
+triton==3.5.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typer==0.24.0
+    # via
+    #   gradio
+    #   typer-slim
+typing-extensions==4.15.0
+    # via
+    #   anyio
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   spaces
+    #   starlette
+    #   torch
+    #   typing-inspection
+typing-inspection==0.4.2
+    # via
+    #   fastapi
+    #   pydantic
+tzdata==2025.3 ; sys_platform == 'emscripten' or sys_platform == 'win32'
+    # via pandas
+urllib3==2.6.3
+    # via requests
+uvicorn==0.41.0
+    # via gradio