feat(tools): add pt_bundle to bundle multiple .pt files without modifying originals\nfix(apps): webcam_app device auto-resolution and session_state safety

apps/README.md

@@ -0,0 +1,29 @@
+# YOLO11 Webcam App
+
+Basit bir Streamlit arayüzü ile webcam üzerinden YOLO11 gerçek zamanlı tespit.
+
+## Gereksinimler
+- Python 3.9+
+- Paketler: `ultralytics`, `streamlit`, `streamlit-webrtc`, `av`, (opsiyonel) `huggingface_hub`
+
+## Kurulum (PowerShell)
+```powershell
+cd C:\yolov11\YOLO11
+python -m venv .venv
+. .venv\Scripts\Activate.ps1
+pip install -U pip
+pip install ultralytics streamlit streamlit-webrtc av huggingface_hub
+```
+
+## Çalıştırma
+```powershell
+cd C:\yolov11\YOLO11
+. .venv\Scripts\Activate.ps1
+streamlit run apps/webcam_app.py
+```
+
+Sol menüden modeli yükleyin (örn. `yolo11n.pt`) ve kameraya izin verin.
+
+Notlar:
+- HF Hub’dan özel model çekmek için `HF_TOKEN` ortam değişkeni gerekebilir.
+- CUDA yoksa cihazı `cpu` seçin.

apps/webcam_app.py

@@ -0,0 +1,155 @@
+import os
+import sys
+from typing import Optional
+
+import av
+import torch
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer, VideoProcessorBase, RTCConfiguration
+
+try:
+    from ultralytics import YOLO
+except Exception as e:
+    st.error(f"Ultralytics import failed: {e}")
+    raise
+
+
+st.set_page_config(page_title="YOLO11 Webcam", layout="wide")
+st.title("YOLO11 Webcam Demo")
+st.caption("Live object detection with YOLO11 using your webcam. Use the sidebar to configure the model and thresholds.")
+
+
+def _resolve_device(device: str) -> str:
+    """Map UI device option to a valid torch/Ultralytics device string."""
+    d = (device or "").lower().strip()
+    if d in {"cpu", "cuda", "mps", "xpu"}:
+        return d
+    if d == "auto":
+        if torch.cuda.is_available():
+            return "cuda"
+        # Apple MPS (macOS). Kept for completeness even if not typical on Windows.
+        if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            return "mps"
+        return "cpu"
+    # Fallback to CPU for any unknown value
+    return "cpu"
+
+
+@st.cache_resource(show_spinner=True)
+def load_model(model_source: str, device: str = "auto"):
+    """
+    Load an Ultralytics model from a local path, built-in alias, or Hugging Face Hub path.
+    Examples for model_source:
+      - "yolo11n.pt" (auto-downloads if available)
+      - "C:/path/to/your_model.pt"
+      - "hf://Ultralytics/YOLO11/yolo11n.pt" (HF Hub file)
+    """
+    # Resolve device (maps 'auto' to an actual device)
+    resolved_device = _resolve_device(device)
+
+    # Hugging Face hub-style path
+    if model_source.startswith("hf://"):
+        try:
+            from huggingface_hub import hf_hub_download
+        except Exception as e:
+            st.error("huggingface_hub not installed. Install it or use a local/builtin model.")
+            raise
+
+        # Parse hf path: hf://<repo_id>/<filename>
+        path = model_source.replace("hf://", "", 1)
+        if "/" not in path:
+            raise ValueError("For hf://, use hf://<repo_id>/<filename>")
+        repo_id, filename = path.split("/", 1)
+        st.info(f"Downloading {filename} from {repo_id}...")
+        local_path = hf_hub_download(repo_id=repo_id, filename=filename, token=os.getenv("HF_TOKEN"))
+        try:
+            return YOLO(local_path).to(resolved_device)
+        except Exception as e:
+            st.warning(f"{resolved_device} cihaza taşınamadı, CPU'ya düşülüyor. Detay: {e}")
+            return YOLO(local_path).to("cpu")
+
+    # Local file or alias handled directly by Ultralytics
+    try:
+        return YOLO(model_source).to(resolved_device)
+    except Exception as e:
+        st.warning(f"{resolved_device} cihaza taşınamadı, CPU'ya düşülüyor. Detay: {e}")
+        return YOLO(model_source).to("cpu")
+
+
+class YOLOProcessor(VideoProcessorBase):
+    def __init__(self, model: YOLO, conf: float, iou: float):
+        self.model = model
+        self.conf = conf
+        self.iou = iou
+
+    def recv(self, frame: av.VideoFrame) -> av.VideoFrame:
+        img = frame.to_ndarray(format="bgr24")
+        results = self.model.predict(img, conf=self.conf, iou=self.iou, verbose=False)
+        plotted = results[0].plot()
+        return av.VideoFrame.from_ndarray(plotted, format="bgr24")
+
+
+with st.sidebar:
+    st.header("Ayarlar")
+    default_model = "yolo11n.pt"  # Ultralytics dağıtımından otomatik indirilmeye çalışılır
+    model_path = st.text_input("Model yolu veya alias", value=default_model, help="Yerel .pt yolu, yerleşik alias (örn. yolo11n.pt) veya hf://Ultralytics/YOLO11/yolo11n.pt")
+    device = st.selectbox("Cihaz", options=["auto", "cpu", "cuda"], index=0)
+    conf = st.slider("Confidence", min_value=0.1, max_value=0.9, value=0.25, step=0.05)
+    iou = st.slider("IoU", min_value=0.1, max_value=0.9, value=0.45, step=0.05)
+    load_btn = st.button("Modeli Yükle")
+
+
+st.session_state.setdefault("model", None)
+
+
+if load_btn:
+    try:
+        st.session_state.model = load_model(model_path, device=device)
+        names = getattr(st.session_state.model, "names", None)
+        if isinstance(names, dict):
+            st.success(f"Model yüklendi. Sınıflar: {len(names)}")
+        else:
+            st.success("Model yüklendi.")
+    except Exception as e:
+        st.exception(e)
+
+
+rtc_config = RTCConfiguration({
+    "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}],
+})
+
+
+col1, col2 = st.columns([2, 1])
+with col1:
+    st.subheader("Webcam")
+    if st.session_state.get("model") is None:
+        st.info("Önce soldan bir model yükleyin.")
+    else:
+        # Capture current values to avoid session_state race during worker creation
+        _model = st.session_state.get("model")
+        _conf = float(conf)
+        _iou = float(iou)
+
+        def video_processor_factory(model=_model, conf_val=_conf, iou_val=_iou):
+            return YOLOProcessor(model, conf=conf_val, iou=iou_val)
+
+        webrtc_streamer(
+            key="yolo11-webcam",
+            video_processor_factory=video_processor_factory,
+            rtc_configuration=rtc_config,
+            media_stream_constraints={"video": True, "audio": False},
+        )
+
+with col2:
+    st.subheader("İpuçları")
+    st.markdown(
+        """
+        - Model alanına şunlardan birini girebilirsiniz:
+            - Yerleşik: `yolo11n.pt` (veya sizde olan başka bir .pt)
+            - Yerel dosya: `C:/yolov11/weights/custom.pt`
+            - HF Hub: `hf://Ultralytics/YOLO11/yolo11n.pt`
+        - Hugging Face özel/korumalı dosyalar için `HF_TOKEN` ortam değişkenini ayarlayabilirsiniz.
+        - GPU (CUDA) yoksa cihazı `cpu` bırakabilirsiniz.
+        - Stream durmuyorsa tarayıcı izinlerini kontrol edin ve sayfayı yenileyin.
+        """
+    )

tools/pt_bundle.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+"""
+PT bundler: Bundle multiple .pt files into a single archive without modifying originals.
+
+Supports two formats:
+  1) ZIP archive (recommended) – exact bytes of each .pt preserved.
+  2) PT container – a single .pt (pickle) file containing a dict {relative_path: bytes}.
+
+CLI examples (PowerShell):
+  # Create ZIP bundle from current repo
+  python tools/pt_bundle.py zip --source . --out models_bundle.zip
+
+  # Create PT container bundle
+  python tools/pt_bundle.py pt --source . --out models_multi.pt
+
+  # List contents
+  python tools/pt_bundle.py list --bundle models_bundle.zip
+  python tools/pt_bundle.py list --bundle models_multi.pt
+
+  # Extract a single model from bundle to a path
+  python tools/pt_bundle.py extract --bundle models_multi.pt --member path/to/model.pt --out C:/tmp/model.pt
+"""
+
+from __future__ import annotations
+
+import argparse
+import io
+import os
+import sys
+from pathlib import Path
+from typing import Iterable, List
+
+try:
+    import torch  # Only needed for PT container
+except Exception:  # pragma: no cover - optional for ZIP-only usage
+    torch = None  # type: ignore
+
+import zipfile
+
+
+def find_pt_files(source: Path, include: Iterable[str] | None = None, exclude: Iterable[str] | None = None) -> List[Path]:
+    include = list(include or ["*.pt"])  # default include all .pt
+    exclude = list(exclude or [])
+    files: List[Path] = []
+    for p in source.rglob("*.pt"):
+        rel = p.relative_to(source)
+        rel_str = str(rel).replace("\\", "/")
+        if include and not any(Path(rel_str).match(pat) for pat in include):
+            continue
+        if exclude and any(Path(rel_str).match(pat) for pat in exclude):
+            continue
+        files.append(p)
+    return files
+
+
+def create_zip_bundle(source: Path, out_path: Path, includes: Iterable[str] | None = None, excludes: Iterable[str] | None = None) -> int:
+    files = find_pt_files(source, includes, excludes)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(out_path, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for f in files:
+            zf.write(f, f.relative_to(source))
+    return len(files)
+
+
+def create_pt_container(source: Path, out_path: Path, includes: Iterable[str] | None = None, excludes: Iterable[str] | None = None) -> int:
+    if torch is None:
+        raise RuntimeError("torch is required for PT container mode. Install torch and retry.")
+    files = find_pt_files(source, includes, excludes)
+    payload = {}
+    for f in files:
+        rel = str(f.relative_to(source)).replace("\\", "/")
+        with open(f, "rb") as fh:
+            payload[rel] = fh.read()  # store exact bytes (no mutation)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(payload, out_path)
+    return len(files)
+
+
+def list_bundle(bundle: Path) -> List[str]:
+    if bundle.suffix.lower() == ".zip":
+        with zipfile.ZipFile(bundle, "r") as zf:
+            return [i.filename for i in zf.infolist() if not i.is_dir()]
+    else:
+        if torch is None:
+            raise RuntimeError("torch is required to list PT container contents.")
+        data = torch.load(bundle, map_location="cpu")
+        if isinstance(data, dict):
+            return sorted(map(str, data.keys()))
+        raise ValueError("Unsupported PT container format: expected dict mapping.")
+
+
+def extract_member(bundle: Path, member: str, out_path: Path) -> None:
+    if bundle.suffix.lower() == ".zip":
+        with zipfile.ZipFile(bundle, "r") as zf:
+            with zf.open(member, "r") as fh, open(out_path, "wb") as out:
+                out.write(fh.read())
+    else:
+        if torch is None:
+            raise RuntimeError("torch is required to extract from PT container.")
+        data = torch.load(bundle, map_location="cpu")
+        if not isinstance(data, dict):
+            raise ValueError("Unsupported PT container format: expected dict mapping.")
+        if member not in data:
+            raise FileNotFoundError(f"member not found in container: {member}")
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(out_path, "wb") as fh:
+            fh.write(data[member])
+
+
+def main(argv: List[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Bundle multiple .pt files without modifying originals.")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_zip = sub.add_parser("zip", help="Create a ZIP archive of .pt files.")
+    p_zip.add_argument("--source", default=".", help="Root directory to scan for .pt files.")
+    p_zip.add_argument("--out", required=True, help="Output ZIP path.")
+    p_zip.add_argument("--include", nargs="*", default=["*.pt"], help="Glob patterns to include.")
+    p_zip.add_argument("--exclude", nargs="*", default=[], help="Glob patterns to exclude.")
+
+    p_pt = sub.add_parser("pt", help="Create a single .pt container (dict of bytes).")
+    p_pt.add_argument("--source", default=".", help="Root directory to scan for .pt files.")
+    p_pt.add_argument("--out", required=True, help="Output PT path (e.g., models_multi.pt).")
+    p_pt.add_argument("--include", nargs="*", default=["*.pt"], help="Glob patterns to include.")
+    p_pt.add_argument("--exclude", nargs="*", default=[], help="Glob patterns to exclude.")
+
+    p_list = sub.add_parser("list", help="List contents of a bundle (ZIP or PT container).")
+    p_list.add_argument("--bundle", required=True, help="Path to models_bundle.zip or models_multi.pt.")
+
+    p_ext = sub.add_parser("extract", help="Extract a single member from the bundle.")
+    p_ext.add_argument("--bundle", required=True, help="Bundle path (ZIP or PT container).")
+    p_ext.add_argument("--member", required=True, help="Member path inside the bundle.")
+    p_ext.add_argument("--out", required=True, help="Destination file path to write.")
+
+    args = parser.parse_args(argv)
+
+    if args.cmd == "zip":
+        count = create_zip_bundle(Path(args.source), Path(args.out), args.include, args.exclude)
+        print(f"ZIP bundle written: {args.out} ({count} files)")
+        return 0
+    if args.cmd == "pt":
+        count = create_pt_container(Path(args.source), Path(args.out), args.include, args.exclude)
+        print(f"PT container written: {args.out} ({count} files)")
+        return 0
+    if args.cmd == "list":
+        items = list_bundle(Path(args.bundle))
+        for it in items:
+            print(it)
+        return 0
+    if args.cmd == "extract":
+        extract_member(Path(args.bundle), args.member, Path(args.out))
+        print(f"Extracted {args.member} -> {args.out}")
+        return 0
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())