camera-ui-ml 1.2.0__tar.gz → 1.2.2__tar.gz

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camera-ui-ml
-Version: 1.2.0
+Version: 1.2.2
 Summary: Shared ML inference framework for camera.ui detection plugins (onnx, openvino, coreml, ncnn)
 Author-email: seydx <hi@seydx.dev>
 Maintainer-email: seydx <hi@seydx.dev>

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/__init__.py

@@ -49,7 +49,6 @@ from .preprocess import (
 )
 
 __all__ = [
-    # backend seam
     "InferenceBackend",
     "InputSpec",
     "Outputs",
@@ -57,9 +56,8 @@ __all__ = [
     "Layout",
     "Normalize",
     "DType",
-    # model manager
     "BaseModelManager",
-    # detectors (ClipEncoder is opt-in via camera_ui_ml.detectors.clip)
+    # ClipEncoder is opt-in via camera_ui_ml.detectors.clip
     "BaseDetector",
     "BoxDetector",
     "NormalizedDetection",
@@ -67,7 +65,6 @@ __all__ = [
     "Embedder",
     "PlateOcr",
     "OcrResult",
-    # geometry
     "Box",
     "NormalizedBox",
     "cxcywh_to_xyxy",
@@ -75,7 +72,6 @@ __all__ = [
     "clamp_box",
     "normalize_box",
     "pad_box",
-    # parsing
     "RawDetection",
     "channels_first",
     "parse_yolov9",
@@ -83,17 +79,14 @@ __all__ = [
     "decode_ocr",
     "l2_normalize",
     "nms",
-    # preprocess
     "frame_to_rgb",
     "resize_rgb",
     "to_pil",
     "to_tensor",
     "crop_rgb",
     "decode_image",
-    # pipeline
     "run_prepare",
     "prepare_executor",
-    # orchestration
     "detect_objects",
     "detect_faces",
     "detect_plates",

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/backend.py

@@ -15,8 +15,6 @@ Layout = Literal["nchw", "nhwc"]
 Normalize = Literal["unit", "facenet", "none"]
 DType = Literal["float32", "uint8"]
 
-# Inference outputs in model output order; detectors index `outputs[0]` for the
-# primary output (OCR scans all outputs, CLIP uses the single embedding output).
 Outputs = Sequence[NDArray]
 
 
@@ -25,9 +23,7 @@ class InputSpec:
     width: int
     height: int
     layout: Layout = "nchw"
-    normalize: Normalize = (
-        "unit"  # "unit" = /255, "facenet" = (x-127.5)/128, "none" = raw
-    )
+    normalize: Normalize = "unit"
     dtype: DType = "float32"
 
 
@@ -41,8 +37,7 @@ class InferenceBackend(ABC):
 
     @property
     def device(self) -> str:
-        """Human-readable hardware this backend actually runs on (e.g. "CUDA:0",
-        "GPU", "Neural Engine", "CPU")"""
+        """Human-readable hardware this backend runs on (e.g. "CUDA:0", "CPU")."""
         return "unknown"
 
     @abstractmethod
@@ -52,11 +47,7 @@ class InferenceBackend(ABC):
     def close(self) -> None: ...
 
     def adapt(self, image: NDArray, spec: InputSpec) -> Sequence[Any]:
-        """Realize the canonical HWC uint8 RGB image into runtime model inputs.
-
-        Default: one normalized tensor per ``spec`` (onnx/openvino/ncnn). CoreML
-        image-input models override this to pass a PIL image instead. Runs on the
-        shared prepare-executor (CPU)."""
+        """Realize the canonical HWC uint8 RGB image into runtime model inputs."""
         from .preprocess import to_tensor
 
         return [to_tensor(image, spec)]

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/detectors/base.py

@@ -50,8 +50,7 @@ class BaseDetector:
             self._init_task = None
 
     async def _configure(self, model_name: str) -> None:
-        """Read model-derived config (input size, labels) from ``self.backend``.
-        Overridden by subclasses that need it; the default is a no-op."""
+        """Read model-derived config (input size, labels) from ``self.backend``."""
 
     def _ready(self) -> bool:
         return self.initialized and self.backend is not None

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/detectors/clip.py

@@ -20,7 +20,6 @@ class ClipEncoder:
         manager: BaseModelManager,
         logger: LoggerService,
         *,
-        pretrained: str = "openai/clip-vit-base-patch32",
         embedding_model: str = "clip-vit-base-patch32",
     ) -> None:
         self.manager = manager
@@ -33,14 +32,15 @@ class ClipEncoder:
 
         self.initialized = False
         self.closed = False
-        self._pretrained = pretrained
         self._init_task: asyncio.Task[None] | None = None
 
     async def initialize(self, vision_model: str, text_model: str) -> None:
         if self.initialized:
             return
         if self._init_task is None:
-            self._init_task = asyncio.create_task(self._do_initialize(vision_model, text_model))
+            self._init_task = asyncio.create_task(
+                self._do_initialize(vision_model, text_model)
+            )
         await self._init_task
 
     async def close(self) -> None:
@@ -83,7 +83,10 @@ class ClipEncoder:
     async def embed_frames(self, frames: list[VideoFrameData]) -> list[list[float]]:
         if not self._ready():
             return [[] for _ in frames]
-        return [await self.embed_frame(frame["width"], frame["height"], frame["data"]) for frame in frames]
+        return [
+            await self.embed_frame(frame["width"], frame["height"], frame["data"])
+            for frame in frames
+        ]
 
     def _ready(self) -> bool:
         return (
@@ -97,7 +100,14 @@ class ClipEncoder:
         try:
             self.vision = await self.manager.ensure_backend(vision_model)
             self.text = await self.manager.ensure_backend(text_model)
-            self.processor = await asyncio.to_thread(CLIPProcessor.from_pretrained, self._pretrained)
+            processor_dir = await self.manager.ensure_clip_processor()
+            if processor_dir is None:
+                raise RuntimeError(
+                    "CLIP processor files are not bundled (clip_processor_files is empty)"
+                )
+            self.processor = await asyncio.to_thread(
+                CLIPProcessor.from_pretrained, processor_dir
+            )
             if self.closed:
                 return
             self.initialized = True
@@ -108,11 +118,15 @@ class ClipEncoder:
             self._init_task = None
 
     def _vision_input(self, pil: Any) -> NDArray:
-        inputs = self.processor(images=pil, return_tensors="np", padding="max_length", truncation=True)
+        inputs = self.processor(
+            images=pil, return_tensors="np", padding="max_length", truncation=True
+        )
         return np.asarray(inputs["pixel_values"], dtype=np.float32)
 
     def _text_input(self, text: str) -> tuple[NDArray, NDArray]:
-        inputs = self.processor(text=text, return_tensors="np", padding="max_length", truncation=True)
+        inputs = self.processor(
+            text=text, return_tensors="np", padding="max_length", truncation=True
+        )
         return (
             np.asarray(inputs["input_ids"], dtype=np.int64),
             np.asarray(inputs["attention_mask"], dtype=np.int64),

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/detectors/ocr.py

@@ -12,8 +12,7 @@ from ..parsing import decode_ocr
 from ..preprocess import frame_to_rgb
 from .base import BaseDetector
 
-#: Default plate alphabet: digits + uppercase letters + pad. Plugins pass the
-#: exact constant their model was trained with.
+#: Default plate alphabet; pass the exact constant the model was trained with.
 DEFAULT_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_"
 
 
@@ -79,8 +78,7 @@ class PlateOcr(BaseDetector):
     def _decode(self, outputs: Outputs) -> OcrResult | None:
         logits: NDArray | None = None
         for value in outputs:
-            # Batched [1, slots, classes] (onnx/openvino/coreml) or bare [slots,
-            # classes] (ncnn) — squeeze to a 2D logits matrix either way.
+            # Output is [1, slots, classes] or bare [slots, classes]; squeeze to 2D.
             arr = np.squeeze(np.asarray(value))
             if arr.ndim == 2 and arr.shape[0] == self._slots:
                 logits = arr

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/geometry.py

@@ -44,8 +44,7 @@ def normalize_box(box: Box, width: float, height: float) -> NormalizedBox:
 
 
 def pad_box(box: Box, width: float, height: float, padding: float, min_size: int = 0) -> Box:
-    """Expand a box by ``padding`` (fraction of its size) and an optional minimum
-    pixel size, clamped to the frame. Used to crop faces/plates with context."""
+    """Expand a box by ``padding`` (fraction of its size) and an optional minimum pixel size, clamped to the frame."""
     x1, y1, x2, y2 = box
     w = x2 - x1
     h = y2 - y1

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/model_manager.py

@@ -14,6 +14,15 @@ _CHUNK = 1024 * 1024
 
 
 class BaseModelManager(ABC):
+    CLIP_PROCESSOR_FILENAMES = (
+        "preprocessor_config.json",
+        "tokenizer_config.json",
+        "vocab.json",
+        "merges.txt",
+        "special_tokens_map.json",
+        "tokenizer.json",
+    )
+
     def __init__(self, storage_path: str, logger: LoggerService, version: str) -> None:
         self.logger = logger
         self.model_path = os.path.join(storage_path, "models", version)
@@ -29,12 +38,28 @@ class BaseModelManager(ABC):
     def reset(self) -> None:
         self._load_tasks.clear()
 
+    def clip_processor_files(self) -> Mapping[str, tuple[str, str]]:
+        """CLIP processor (tokenizer + image preprocessor) files: key → (url, path relative to
+        ``model_path``). Empty (default) = plugin has no CLIP; CLIP plugins must override this."""
+        return {}
+
+    async def ensure_clip_processor(self) -> str | None:
+        files = self.clip_processor_files()
+        if not files:
+            return None
+        for url, rel in files.values():
+            await self._download(url, rel)
+        first_rel = next(iter(files.values()))[1]
+        return os.path.dirname(os.path.join(self.model_path, first_rel))
+
     @abstractmethod
     def model_files(self, model_name: str) -> Mapping[str, tuple[str, str]]:
         """Map of file key → (download_url, path relative to ``model_path``)."""
 
     @abstractmethod
-    async def build_backend(self, model_name: str, paths: Mapping[str, str]) -> InferenceBackend:
+    async def build_backend(
+        self, model_name: str, paths: Mapping[str, str]
+    ) -> InferenceBackend:
         """Build the runtime backend from the (already downloaded) local paths."""
 
     async def _load(self, model_name: str) -> InferenceBackend:
@@ -42,7 +67,10 @@ class BaseModelManager(ABC):
         for url, rel in files.values():
             await self._download(url, rel)
 
-        paths = {key: os.path.join(self.model_path, rel) for key, (_url, rel) in files.items()}
+        paths = {
+            key: os.path.join(self.model_path, rel)
+            for key, (_url, rel) in files.items()
+        }
         return await self.build_backend(model_name, paths)
 
     async def _download(self, url: str, rel: str) -> None:

camera_ui_ml-1.2.2/camera_ui_ml/pipelines.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, cast
+
+from camera_ui_sdk import (
+    ClipEmbedding,
+    ClipResult,
+    DetectionLabel,
+    FaceDetection,
+    FaceResult,
+    LicensePlateDetection,
+    LicensePlateResult,
+    ObjectResult,
+    TrackedDetection,
+    VideoFrameData,
+)
+
+from .detectors.box import BoxDetector
+from .detectors.embedder import Embedder
+from .detectors.ocr import PlateOcr
+from .geometry import normalize_box
+
+if TYPE_CHECKING:
+    from .detectors.clip import ClipEncoder
+
+
+async def detect_objects(
+    detector: BoxDetector, frame: VideoFrameData, threshold: float | None = None
+) -> ObjectResult:
+    raw = await detector.detect_frame(frame, threshold)
+    width, height = frame["width"], frame["height"]
+    detections: list[TrackedDetection] = [
+        {
+            "label": cast(DetectionLabel, detector.labels.get(cid, "unknown")),
+            "confidence": conf,
+            "box": normalize_box(box, width, height),
+        }
+        for cid, conf, box in raw
+    ]
+    return {"detected": len(detections) > 0, "detections": detections}
+
+
+async def detect_faces(
+    detector: BoxDetector,
+    embedder: Embedder,
+    frames: list[VideoFrameData],
+    threshold: float | None = None,
+) -> list[FaceResult]:
+    tasks = [_detect_faces_one(detector, embedder, frame, threshold) for frame in frames]
+    return list(await asyncio.gather(*tasks))
+
+
+async def _detect_faces_one(
+    detector: BoxDetector,
+    embedder: Embedder,
+    frame: VideoFrameData,
+    threshold: float | None,
+) -> FaceResult:
+    raw = await detector.detect_frame(frame, threshold)
+    if not raw:
+        return {"detected": False, "detections": []}
+
+    width, height = frame["width"], frame["height"]
+    data = bytes(frame["data"])
+    embeddings = await asyncio.gather(
+        *(embedder.embed_from_crop(data, width, height, box) for _cid, _conf, box in raw)
+    )
+    detections: list[FaceDetection] = [
+        {
+            "label": "person",
+            "attribute": "face",
+            "confidence": conf,
+            "box": normalize_box(box, width, height),
+            "embedding": embedding,
+        }
+        for (_cid, conf, box), embedding in zip(raw, embeddings, strict=False)
+    ]
+    return {"detected": len(detections) > 0, "detections": detections}
+
+
+async def detect_plates(
+    detector: BoxDetector,
+    ocr: PlateOcr,
+    frames: list[VideoFrameData],
+    threshold: float | None = None,
+) -> list[LicensePlateResult]:
+    tasks = [_detect_plates_one(detector, ocr, frame, threshold) for frame in frames]
+    return list(await asyncio.gather(*tasks))
+
+
+async def _detect_plates_one(
+    detector: BoxDetector, ocr: PlateOcr, frame: VideoFrameData, threshold: float | None
+) -> LicensePlateResult:
+    raw = await detector.detect_frame(frame, threshold)
+    if not raw:
+        return {"detected": False, "detections": []}
+
+    width, height = frame["width"], frame["height"]
+    data = bytes(frame["data"])
+    ocr_results = await asyncio.gather(
+        *(ocr.recognize_from_crop(data, width, height, box) for _cid, _conf, box in raw)
+    )
+    detections: list[LicensePlateDetection] = []
+    for (_cid, conf, box), result in zip(raw, ocr_results, strict=False):
+        if result is None or not result.text:
+            continue
+        detections.append(
+            {
+                "label": "vehicle",
+                "attribute": "license_plate",
+                "confidence": conf,
+                "plateText": result.text,
+                "box": normalize_box(box, width, height),
+            }
+        )
+    return {"detected": len(detections) > 0, "detections": detections}
+
+
+async def detect_clip(encoder: ClipEncoder, frames: list[VideoFrameData]) -> list[ClipResult]:
+    embeddings = await encoder.embed_frames(frames)
+    results: list[ClipResult] = []
+    for frame, embedding in zip(frames, embeddings, strict=False):
+        items: list[ClipEmbedding] = []
+        if embedding:
+            items.append(
+                {
+                    "label": frame.get("label") or "image",
+                    "box": {"x": 0.0, "y": 0.0, "width": 1.0, "height": 1.0},
+                    "embedding": embedding,
+                }
+            )
+        results.append({"embeddings": items, "embeddingModel": encoder.embedding_model})
+    return results

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml/preprocess.py

@@ -48,7 +48,7 @@ def to_tensor(rgb: NDArray, spec: InputSpec) -> NDArray:
         arr = resized.astype(np.float32) / 255.0
     elif spec.normalize == "facenet":
         arr = (resized.astype(np.float32) - 127.5) / 128.0
-    else:  # "none"
+    else:
         arr = resized.astype(np.uint8 if spec.dtype == "uint8" else np.float32)
 
     if spec.layout == "nchw":

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/camera_ui_ml.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camera-ui-ml
-Version: 1.2.0
+Version: 1.2.2
 Summary: Shared ML inference framework for camera.ui detection plugins (onnx, openvino, coreml, ncnn)
 Author-email: seydx <hi@seydx.dev>
 Maintainer-email: seydx <hi@seydx.dev>

{camera_ui_ml-1.2.0 → camera_ui_ml-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "camera-ui-ml"
-version = "1.2.0"
+version = "1.2.2"
 description = "Shared ML inference framework for camera.ui detection plugins (onnx, openvino, coreml, ncnn)"
 keywords = ["camera.ui", "python", "ml", "inference", "detection"]
 readme = "README.md"

camera_ui_ml-1.2.0/camera_ui_ml/pipelines.py

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, cast
-
-from camera_ui_sdk import (
-    ClipEmbedding,
-    ClipResult,
-    DetectionLabel,
-    FaceDetection,
-    FaceResult,
-    LicensePlateDetection,
-    LicensePlateResult,
-    ObjectResult,
-    TrackedDetection,
-    VideoFrameData,
-)
-
-from .detectors.box import BoxDetector
-from .detectors.embedder import Embedder
-from .detectors.ocr import PlateOcr
-from .geometry import normalize_box
-
-if TYPE_CHECKING:
-    from .detectors.clip import ClipEncoder
-
-
-async def detect_objects(
-    detector: BoxDetector, frame: VideoFrameData, threshold: float | None = None
-) -> ObjectResult:
-    raw = await detector.detect_frame(frame, threshold)
-    width, height = frame["width"], frame["height"]
-    detections: list[TrackedDetection] = [
-        {
-            "label": cast(DetectionLabel, detector.labels.get(cid, "unknown")),
-            "confidence": conf,
-            "box": normalize_box(box, width, height),
-        }
-        for cid, conf, box in raw
-    ]
-    return {"detected": len(detections) > 0, "detections": detections}
-
-
-async def detect_faces(
-    detector: BoxDetector,
-    embedder: Embedder,
-    frames: list[VideoFrameData],
-    threshold: float | None = None,
-) -> list[FaceResult]:
-    results: list[FaceResult] = []
-    for frame in frames:
-        raw = await detector.detect_frame(frame, threshold)
-        if not raw:
-            results.append({"detected": False, "detections": []})
-            continue
-
-        width, height = frame["width"], frame["height"]
-        data = bytes(frame["data"])
-        detections: list[FaceDetection] = []
-        for _cid, conf, box in raw:
-            embedding = await embedder.embed_from_crop(data, width, height, box)
-            detections.append(
-                {
-                    "label": "person",
-                    "attribute": "face",
-                    "confidence": conf,
-                    "box": normalize_box(box, width, height),
-                    "embedding": embedding,
-                }
-            )
-        results.append({"detected": len(detections) > 0, "detections": detections})
-    return results
-
-
-async def detect_plates(
-    detector: BoxDetector,
-    ocr: PlateOcr,
-    frames: list[VideoFrameData],
-    threshold: float | None = None,
-) -> list[LicensePlateResult]:
-    results: list[LicensePlateResult] = []
-    for frame in frames:
-        raw = await detector.detect_frame(frame, threshold)
-        if not raw:
-            results.append({"detected": False, "detections": []})
-            continue
-
-        width, height = frame["width"], frame["height"]
-        data = bytes(frame["data"])
-        detections: list[LicensePlateDetection] = []
-        for _cid, conf, box in raw:
-            result = await ocr.recognize_from_crop(data, width, height, box)
-            if result is None or not result.text:
-                continue
-            detections.append(
-                {
-                    "label": "vehicle",
-                    "attribute": "license_plate",
-                    "confidence": conf,
-                    "plateText": result.text,
-                    "box": normalize_box(box, width, height),
-                }
-            )
-        results.append({"detected": len(detections) > 0, "detections": detections})
-    return results
-
-
-async def detect_clip(encoder: ClipEncoder, frames: list[VideoFrameData]) -> list[ClipResult]:
-    embeddings = await encoder.embed_frames(frames)
-    results: list[ClipResult] = []
-    for frame, embedding in zip(frames, embeddings, strict=False):
-        items: list[ClipEmbedding] = []
-        if embedding:
-            items.append(
-                {
-                    "label": frame.get("label") or "image",
-                    "box": {"x": 0.0, "y": 0.0, "width": 1.0, "height": 1.0},
-                    "embedding": embedding,
-                }
-            )
-        results.append({"embeddings": items, "embeddingModel": encoder.embedding_model})
-    return results