homesec 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

homesec/plugins/analyzers/openai.py

@@ -14,6 +14,7 @@ import cv2
 from PIL import Image
 from pydantic import BaseModel
 
+from homesec.interfaces import VLMAnalyzer
 from homesec.models.filter import FilterResult
 from homesec.models.vlm import (
     AnalysisResult,
@@ -22,7 +23,6 @@ from homesec.models.vlm import (
     VLMConfig,
     VLMPreprocessConfig,
 )
-from homesec.interfaces import VLMAnalyzer
 
 logger = logging.getLogger(__name__)
 
@@ -61,18 +61,18 @@ def _create_json_schema_format(
 
 class OpenAIVLM(VLMAnalyzer):
     """OpenAI-compatible VLM analyzer plugin.
-    
+
     Uses aiohttp for async HTTP calls to OpenAI API.
     Supports structured output with Pydantic schemas.
     """
 
     def __init__(self, config: VLMConfig) -> None:
         """Initialize OpenAI VLM with config validation.
-        
+
         Required config:
             llm.api_key_env: Env var name with API key
             llm.model: Model name (e.g., gpt-4o)
-            
+
         Optional config:
             llm.base_url: API base URL (default: https://api.openai.com/v1)
             llm.token_param: max_tokens or max_completion_tokens
@@ -86,13 +86,13 @@ class OpenAIVLM(VLMAnalyzer):
             raise ValueError("OpenAIVLM requires llm=OpenAILLMConfig")
         llm = config.llm
         preprocess = config.preprocessing
-        
+
         # Get API key from env
         self._api_key_env = llm.api_key_env
         self.api_key = os.getenv(self._api_key_env)
         if not self.api_key:
             raise ValueError(f"API key not found in env: {self._api_key_env}")
-        
+
         self.model = llm.model
         self.base_url = llm.base_url
         self.system_prompt = DEFAULT_SYSTEM_PROMPT
@@ -100,11 +100,11 @@ class OpenAIVLM(VLMAnalyzer):
         self.token_param = llm.token_param
         self.max_tokens = self._resolve_token_limit(llm)
         self.request_timeout = float(llm.request_timeout)
-        
+
         # Create HTTP session
         self._session: aiohttp.ClientSession | None = None
         self._shutdown_called = False
-        
+
         logger.info(
             "OpenAIVLM initialized: model=%s, max_frames=%d, token_param=%s, temperature=%s",
             self.model,
@@ -127,18 +127,18 @@ class OpenAIVLM(VLMAnalyzer):
         config: VLMConfig,
     ) -> AnalysisResult:
         """Analyze video clip using OpenAI VLM.
-        
+
         Extracts frames, encodes as base64, and calls OpenAI API
         with structured output schema.
         """
         if self._shutdown_called:
             raise RuntimeError("VLM has been shut down")
-        
+
         start_time = asyncio.get_running_loop().time()
 
         # Extract frames
         frames = await self._extract_frames_async(video_path, config.preprocessing)
-        
+
         if not frames:
             raise ValueError(f"No frames extracted from {video_path}")
 
@@ -154,10 +154,8 @@ class OpenAIVLM(VLMAnalyzer):
         prompt_tokens = usage.get("prompt_tokens")
         completion_tokens = usage.get("completion_tokens")
         prompt_token_count = prompt_tokens if isinstance(prompt_tokens, int) else None
-        completion_token_count = (
-            completion_tokens if isinstance(completion_tokens, int) else None
-        )
-        
+        completion_token_count = completion_tokens if isinstance(completion_tokens, int) else None
+
         # Parse response
         content = self._extract_content(data)
         analysis = self._parse_sequence_analysis(content)
@@ -236,9 +234,7 @@ class OpenAIVLM(VLMAnalyzer):
         payload: dict[str, object] = {
             "model": self.model,
             "messages": messages,
-            "response_format": _create_json_schema_format(
-                SequenceAnalysis, "sequence_analysis"
-            ),
+            "response_format": _create_json_schema_format(SequenceAnalysis, "sequence_analysis"),
         }
         if self.temperature is not None:
             payload["temperature"] = self.temperature
@@ -260,18 +256,14 @@ class OpenAIVLM(VLMAnalyzer):
         async with session.post(url, json=payload, headers=headers) as resp:
             if resp.status != 200:
                 error_text = await resp.text()
-                raise RuntimeError(
-                    f"OpenAI API error {resp.status}: {error_text}"
-                )
+                raise RuntimeError(f"OpenAI API error {resp.status}: {error_text}")
 
             data = await resp.json()
             if not isinstance(data, dict):
                 raise TypeError("OpenAI API response is not a JSON object")
             return data
 
-    def _log_usage(
-        self, usage: dict[str, object], start_time: float, video_path: Path
-    ) -> None:
+    def _log_usage(self, usage: dict[str, object], start_time: float, video_path: Path) -> None:
         elapsed_s = asyncio.get_running_loop().time() - start_time
         logger.info(
             "VLM token usage",
@@ -317,8 +309,7 @@ class OpenAIVLM(VLMAnalyzer):
             ) from e
         except ValueError as e:
             raise ValueError(
-                f"VLM response does not match SequenceAnalysis schema: {e}. "
-                f"Raw response: {content}"
+                f"VLM response does not match SequenceAnalysis schema: {e}. Raw response: {content}"
             ) from e
 
     def _resolve_token_limit(self, llm: OpenAILLMConfig) -> int:
@@ -336,25 +327,25 @@ class OpenAIVLM(VLMAnalyzer):
         quality: int,
     ) -> list[tuple[str, str]]:
         """Extract and encode frames from video.
-        
+
         Returns list of (base64 JPEG, timestamp) tuples.
         """
         cap = cv2.VideoCapture(str(video_path))
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        
+
         if total_frames == 0:
             cap.release()
             return []
-        
+
         # Calculate frame indices to sample
         if total_frames <= max_frames:
             frame_indices = list(range(total_frames))
         else:
             step = total_frames / max_frames
             frame_indices = [int(i * step) for i in range(max_frames)]
-        
+
         frames_b64: list[tuple[str, str]] = []
-        
+
         for idx in frame_indices:
             cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
             ret, frame = cap.read()
@@ -363,25 +354,26 @@ class OpenAIVLM(VLMAnalyzer):
 
             timestamp_ms = cap.get(cv2.CAP_PROP_POS_MSEC)
             timestamp = self._format_timestamp(timestamp_ms)
-            
+
             # Convert to PIL Image
             rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
             pil_img = Image.fromarray(rgb_frame)
-            
+
             # Resize if needed
             if max(pil_img.size) > max_size:
                 pil_img = self._resize_image(pil_img, max_size)
-            
+
             # Encode as JPEG
             import io
+
             buffer = io.BytesIO()
             pil_img.save(buffer, format="JPEG", quality=quality)
             frame_bytes = buffer.getvalue()
-            
+
             # Base64 encode
             frame_b64 = base64.b64encode(frame_bytes).decode("utf-8")
             frames_b64.append((frame_b64, timestamp))
-        
+
         cap.release()
         return frames_b64
 
@@ -394,17 +386,17 @@ class OpenAIVLM(VLMAnalyzer):
     def _resize_image(self, img: Image.Image, max_size: int) -> Image.Image:
         """Resize image maintaining aspect ratio."""
         width, height = img.size
-        
+
         if width <= max_size and height <= max_size:
             return img
-        
+
         if width > height:
             new_width = max_size
             new_height = int(height * (max_size / width))
         else:
             new_height = max_size
             new_width = int(width * (max_size / height))
-        
+
         return img.resize((new_width, new_height), Image.Resampling.LANCZOS)
 
     async def shutdown(self, timeout: float | None = None) -> None:
@@ -412,10 +404,10 @@ class OpenAIVLM(VLMAnalyzer):
         _ = timeout
         if self._shutdown_called:
             return
-        
+
         self._shutdown_called = True
         logger.info("Shutting down OpenAIVLM...")
-        
+
         if self._session:
             await self._session.close()
 
@@ -433,8 +425,7 @@ def openai_vlm_plugin() -> VLMPlugin:
     Returns:
         VLMPlugin for OpenAI vision-language model
     """
-    from homesec.models.vlm import OpenAILLMConfig, VLMConfig
-    from homesec.interfaces import VLMAnalyzer
+    from homesec.models.vlm import OpenAILLMConfig
 
     def factory(cfg: VLMConfig) -> VLMAnalyzer:
         return OpenAIVLM(cfg)

homesec/plugins/filters/__init__.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 from pydantic import BaseModel
 
@@ -93,9 +94,7 @@ def load_filter_plugin(config: FilterConfig) -> ObjectFilter:
 
     if plugin_name not in FILTER_REGISTRY:
         available = ", ".join(sorted(FILTER_REGISTRY.keys()))
-        raise ValueError(
-            f"Unknown filter plugin: '{plugin_name}'. Available: {available}"
-        )
+        raise ValueError(f"Unknown filter plugin: '{plugin_name}'. Available: {available}")
 
     plugin = FILTER_REGISTRY[plugin_name]
 

homesec/plugins/filters/yolo.py

@@ -5,16 +5,17 @@ from __future__ import annotations
 import asyncio
 import logging
 import shutil
+from collections.abc import Callable
 from concurrent.futures import ProcessPoolExecutor
 from pathlib import Path
-from typing import Callable, cast
+from typing import cast
 
 import cv2
 import torch
 from ultralytics import YOLO  # type: ignore[attr-defined]
 
-from homesec.models.filter import FilterConfig, FilterOverrides, FilterResult, YoloFilterSettings
 from homesec.interfaces import ObjectFilter
+from homesec.models.filter import FilterConfig, FilterOverrides, FilterResult, YoloFilterSettings
 
 logger = logging.getLogger(__name__)
 
@@ -100,7 +101,7 @@ def _get_model(model_path: str, device: str) -> YOLO:
 
 class YOLOv8Filter(ObjectFilter):
     """YOLO-based object detection filter.
-    
+
     Uses ProcessPoolExecutor internally for CPU/GPU-bound inference.
     Supports frame sampling and early exit on detection.
     Bare model filenames resolve under ./yolo_cache and auto-download if missing.
@@ -108,10 +109,10 @@ class YOLOv8Filter(ObjectFilter):
 
     def __init__(self, config: FilterConfig) -> None:
         """Initialize YOLO filter with config validation.
-        
+
         Required config:
             model_path: Path to .pt model file
-            
+
         Optional config:
             classes: List of class names to detect (default: person)
             min_confidence: Minimum confidence threshold (default: 0.5)
@@ -131,11 +132,11 @@ class YOLOv8Filter(ObjectFilter):
             raise FileNotFoundError(f"Model not found: {self.model_path}")
 
         self._class_id_cache: dict[tuple[str, ...], list[int]] = {}
-        
+
         # Initialize executor
         self._executor = ProcessPoolExecutor(max_workers=config.max_workers)
         self._shutdown_called = False
-        
+
         logger.info(
             "YOLOv8Filter initialized: model=%s, classes=%s, confidence=%.2f",
             self.model_path,
@@ -149,13 +150,13 @@ class YOLOv8Filter(ObjectFilter):
         overrides: FilterOverrides | None = None,
     ) -> FilterResult:
         """Detect objects in video clip.
-        
+
         Runs inference in ProcessPoolExecutor to avoid blocking event loop.
         Samples frames at configured rate and exits early on first detection.
         """
         if self._shutdown_called:
             raise RuntimeError("Filter has been shut down")
-        
+
         # Run blocking work in executor
         loop = asyncio.get_running_loop()
         effective = self._apply_overrides(overrides)
@@ -172,7 +173,7 @@ class YOLOv8Filter(ObjectFilter):
             float(effective.min_box_h_ratio),
             int(effective.min_hits),
         )
-        
+
         return result
 
     async def shutdown(self, timeout: float | None = None) -> None:
@@ -180,7 +181,7 @@ class YOLOv8Filter(ObjectFilter):
         _ = timeout
         if self._shutdown_called:
             return
-        
+
         self._shutdown_called = True
         logger.info("Shutting down YOLOv8Filter...")
         self._executor.shutdown(wait=True, cancel_futures=False)
@@ -197,10 +198,7 @@ class YOLOv8Filter(ObjectFilter):
         cached = self._class_id_cache.get(key)
         if cached is not None:
             return cached
-        target_class_ids = [
-            cid for cid, name in HUMAN_ANIMAL_CLASSES.items()
-            if name in classes
-        ]
+        target_class_ids = [cid for cid, name in HUMAN_ANIMAL_CLASSES.items() if name in classes]
         if not target_class_ids:
             raise ValueError(f"No valid classes found in config: {classes}")
         self._class_id_cache[key] = target_class_ids
@@ -217,7 +215,7 @@ def _detect_worker(
     min_hits: int,
 ) -> FilterResult:
     """Worker function for video analysis (must be at module level for pickling).
-    
+
     This runs in a separate process, so it needs to load the model fresh.
     """
     # Determine device
@@ -228,51 +226,51 @@ def _detect_worker(
         if torch.cuda.is_available()
         else "cpu"
     )
-    
+
     # Load model (cached per process)
     model = _get_model(model_path, device)
-    
+
     # Open video
     cap = cv2.VideoCapture(video_path)
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     frame_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     min_box_h = frame_h * min_box_h_ratio
-    
+
     detected_classes: list[str] = []
     max_confidence = 0.0
     sampled_frames = 0
-    
+
     frame_idx = 0
     while frame_idx < total_frames:
         cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
         ret, frame = cap.read()
         if not ret:
             break
-        
+
         sampled_frames += 1
-        
+
         # Run inference
         results = model(frame, verbose=False, conf=min_confidence, classes=target_class_ids)
-        
+
         for result in results:
             for box in result.boxes:
                 cls = int(box.cls[0])
                 class_name = HUMAN_ANIMAL_CLASSES.get(cls)
                 if not class_name:
                     continue
-                
+
                 # Check box height
                 xyxy = box.xyxy[0].tolist()
                 box_h = xyxy[3] - xyxy[1]
                 if box_h < min_box_h:
                     continue
-                
+
                 # Track detection
                 confidence = float(box.conf[0])
                 if class_name not in detected_classes:
                     detected_classes.append(class_name)
                 max_confidence = max(max_confidence, confidence)
-                
+
                 # Early exit if we have enough hits
                 if len(detected_classes) >= min_hits:
                     cap.release()
@@ -282,11 +280,11 @@ def _detect_worker(
                         model=Path(model_path).name,
                         sampled_frames=sampled_frames,
                     )
-        
+
         frame_idx += sample_fps
-    
+
     cap.release()
-    
+
     return FilterResult(
         detected_classes=detected_classes,
         confidence=max_confidence if detected_classes else 0.0,

homesec/plugins/notifiers/__init__.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, TypeVar
+from typing import TypeVar
 
 from pydantic import BaseModel
 

homesec/plugins/notifiers/mqtt.py

@@ -3,29 +3,28 @@
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
 import os
 import threading
 
 import paho.mqtt.client as mqtt
 
+from homesec.interfaces import Notifier
 from homesec.models.alert import Alert
 from homesec.models.config import MQTTConfig
-from homesec.interfaces import Notifier
 
 logger = logging.getLogger(__name__)
 
 
 class MQTTNotifier(Notifier):
     """MQTT notifier for Home Assistant alerts.
-    
+
     Publishes alert messages to configured topics with QoS settings.
     """
 
     def __init__(self, config: MQTTConfig) -> None:
         """Initialize MQTT notifier with config validation.
-        
+
         Args:
             config: MQTTConfig instance
         """
@@ -35,11 +34,11 @@ class MQTTNotifier(Notifier):
         self.qos = int(config.qos)
         self.retain = bool(config.retain)
         self.connection_timeout = float(config.connection_timeout)
-        
+
         # Get credentials from env if provided
         self.username: str | None = None
         self.password: str | None = None
-        
+
         if config.auth and config.auth.username_env:
             username_var = config.auth.username_env
             self.username = os.getenv(username_var)
@@ -51,13 +50,13 @@ class MQTTNotifier(Notifier):
             self.password = os.getenv(password_var)
             if not self.password:
                 logger.warning("MQTT password not found in env: %s", password_var)
-        
+
         # Initialize MQTT client
         self.client = mqtt.Client()
-        
+
         if self.username and self.password:
             self.client.username_pw_set(self.username, self.password)
-        
+
         # Connection state
         self._connected = False
         self._connected_event = threading.Event()
@@ -95,13 +94,13 @@ class MQTTNotifier(Notifier):
     async def send(self, alert: Alert) -> None:
         """Send alert notification to MQTT topic."""
         await self._ensure_connected()
-        
+
         # Format topic
         topic = self.topic_template.format(camera_name=alert.camera_name)
-        
+
         # Serialize alert to JSON
         payload = alert.model_dump_json()
-        
+
         # Publish message
         await asyncio.to_thread(
             self._publish,
@@ -110,7 +109,7 @@ class MQTTNotifier(Notifier):
             self.qos,
             self.retain,
         )
-        
+
         logger.info(
             "Published alert to MQTT: topic=%s, clip_id=%s",
             topic,
@@ -153,9 +152,7 @@ class MQTTNotifier(Notifier):
         if self._connected:
             return
         # Wait for connection with timeout
-        connected = await asyncio.to_thread(
-            self._connected_event.wait, self.connection_timeout
-        )
+        connected = await asyncio.to_thread(self._connected_event.wait, self.connection_timeout)
         if not connected or not self._connected:
             raise RuntimeError(
                 f"MQTT broker not connected after {self.connection_timeout}s timeout"
@@ -164,9 +161,11 @@ class MQTTNotifier(Notifier):
 
 # Plugin registration
 from typing import cast
+
 from pydantic import BaseModel
-from homesec.plugins.notifiers import NotifierPlugin, notifier_plugin
+
 from homesec.interfaces import Notifier
+from homesec.plugins.notifiers import NotifierPlugin, notifier_plugin
 
 
 @notifier_plugin(name="mqtt")

homesec/plugins/notifiers/multiplex.py

@@ -4,11 +4,12 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
-from typing import Any, Callable, Coroutine
+from typing import Any
 
-from homesec.models.alert import Alert
 from homesec.interfaces import Notifier
+from homesec.models.alert import Alert
 
 logger = logging.getLogger(__name__)
 

homesec/plugins/notifiers/sendgrid_email.py

@@ -10,10 +10,10 @@ from collections import defaultdict
 
 import aiohttp
 
+from homesec.interfaces import Notifier
 from homesec.models.alert import Alert
 from homesec.models.config import SendGridEmailConfig
 from homesec.models.vlm import SequenceAnalysis
-from homesec.interfaces import Notifier
 
 logger = logging.getLogger(__name__)
 
@@ -62,9 +62,7 @@ class SendGridEmailNotifier(Notifier):
         async with session.post(url, json=payload, headers=headers) as response:
             if response.status >= 400:
                 details = await response.text()
-                raise RuntimeError(
-                    f"SendGrid email send failed ({response.status}): {details}"
-                )
+                raise RuntimeError(f"SendGrid email send failed ({response.status}): {details}")
 
         logger.info(
             "Sent SendGrid email alert: to=%s clip_id=%s",
@@ -181,9 +179,7 @@ class SendGridEmailNotifier(Notifier):
         items = []
         for key, value in mapping.items():
             rendered_value = self._render_value_html(value)
-            items.append(
-                f"<li><strong>{html.escape(str(key))}:</strong> {rendered_value}</li>"
-            )
+            items.append(f"<li><strong>{html.escape(str(key))}:</strong> {rendered_value}</li>")
         return "<ul>" + "".join(items) + "</ul>"
 
     def _render_list_html(self, items: list[object]) -> str:
@@ -203,9 +199,11 @@ class SendGridEmailNotifier(Notifier):
 
 # Plugin registration
 from typing import cast
+
 from pydantic import BaseModel
-from homesec.plugins.notifiers import NotifierPlugin, notifier_plugin
+
 from homesec.interfaces import Notifier
+from homesec.plugins.notifiers import NotifierPlugin, notifier_plugin
 
 
 @notifier_plugin(name="sendgrid_email")

homesec/plugins/storage/__init__.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, TypeVar
+from typing import TypeVar
 
 from pydantic import BaseModel
 
@@ -88,9 +89,7 @@ def create_storage(config: StorageConfig) -> StorageBackend:
 
     if backend_name not in STORAGE_REGISTRY:
         available = ", ".join(sorted(STORAGE_REGISTRY.keys()))
-        raise RuntimeError(
-            f"Unknown storage backend: '{backend_name}'. Available: {available}"
-        )
+        raise RuntimeError(f"Unknown storage backend: '{backend_name}'. Available: {available}")
 
     plugin = STORAGE_REGISTRY[backend_name]