homesec 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

homesec/app.py

@@ -8,23 +8,15 @@ import signal
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from homesec.config import (
-    load_config,
-    resolve_env_var,
-    validate_camera_references,
-    validate_plugin_names,
-)
+from homesec.config import load_config, resolve_env_var, validate_config, validate_plugin_names
 from homesec.health import HealthServer
 from homesec.interfaces import EventStore
+from homesec.notifiers.multiplex import MultiplexNotifier, NotifierEntry
 from homesec.pipeline import ClipPipeline
 from homesec.plugins.alert_policies import load_alert_policy
 from homesec.plugins.analyzers import load_analyzer
 from homesec.plugins.filters import load_filter
-from homesec.plugins.notifiers import (
-    MultiplexNotifier,
-    NotifierEntry,
-    load_notifier_plugin,
-)
+from homesec.plugins.notifiers import load_notifier_plugin
 from homesec.plugins.registry import PluginType, get_plugin_names
 from homesec.plugins.sources import load_source_plugin
 from homesec.plugins.storage import load_storage_plugin
@@ -252,7 +244,6 @@ class Application:
         """Create alert policy using the plugin registry."""
         return load_alert_policy(
             config.alert_policy,
-            per_camera_overrides=config.per_camera_alert,
             trigger_classes=config.vlm.trigger_classes,
         )
 
@@ -263,7 +254,7 @@ class Application:
         for camera in config.cameras:
             source_cfg = camera.source
             source = load_source_plugin(
-                source_type=source_cfg.type,
+                source_backend=source_cfg.backend,
                 config=source_cfg.config,
                 camera_name=camera.name,
             )
@@ -277,7 +268,6 @@ class Application:
         return self._config
 
     def _validate_config(self, config: Config) -> None:
-        validate_camera_references(config)
         validate_plugin_names(
             config,
             valid_filters=get_plugin_names(PluginType.FILTER),
@@ -287,6 +277,7 @@ class Application:
             valid_alert_policies=get_plugin_names(PluginType.ALERT_POLICY),
             valid_sources=get_plugin_names(PluginType.SOURCE),
         )
+        validate_config(config)
 
     def _setup_signal_handlers(self) -> None:
         """Set up signal handlers for graceful shutdown."""

homesec/cli.py

@@ -13,8 +13,8 @@ load_dotenv()
 import fire  # type: ignore[import-untyped]
 
 from homesec.app import Application
-from homesec.config import ConfigError, load_config
-from homesec.config.validation import validate_camera_references, validate_plugin_names
+from homesec.config import ConfigError, load_config, validate_config
+from homesec.config.validation import validate_plugin_names
 from homesec.logging_setup import configure_logging
 from homesec.maintenance.cleanup_clips import CleanupOptions, run_cleanup
 from homesec.plugins.registry import PluginType, get_plugin_names
@@ -66,7 +66,6 @@ class HomeSec:
             discover_all_plugins()
 
             # Additional validation checks
-            validate_camera_references(cfg)
             validate_plugin_names(
                 cfg,
                 sorted(get_plugin_names(PluginType.FILTER)),
@@ -74,7 +73,9 @@ class HomeSec:
                 valid_storage=sorted(get_plugin_names(PluginType.STORAGE)),
                 valid_notifiers=sorted(get_plugin_names(PluginType.NOTIFIER)),
                 valid_alert_policies=sorted(get_plugin_names(PluginType.ALERT_POLICY)),
+                valid_sources=sorted(get_plugin_names(PluginType.SOURCE)),
             )
+            validate_config(cfg)
 
             print(f"✓ Config valid: {config_path}")
             camera_names = [camera.name for camera in cfg.cameras]
@@ -84,7 +85,7 @@ class HomeSec:
             ]
             print(f"  Storage backend: {cfg.storage.backend}")
             print(f"  Notifiers: {notifier_backends}")
-            print(f"  Filter plugin: {cfg.filter.plugin}")
+            print(f"  Filter backend: {cfg.filter.backend}")
             print(f"  VLM backend: {cfg.vlm.backend}")
             print(f"  VLM trigger classes: {cfg.vlm.trigger_classes}")
             print(f"  Alert policy backend: {cfg.alert_policy.backend}")

homesec/config/__init__.py

@@ -6,7 +6,12 @@ from homesec.config.loader import (
     load_config_from_dict,
     resolve_env_var,
 )
-from homesec.config.validation import validate_camera_references, validate_plugin_names
+from homesec.config.validation import (
+    validate_camera_references,
+    validate_config,
+    validate_plugin_configs,
+    validate_plugin_names,
+)
 
 __all__ = [
     "ConfigError",
@@ -14,5 +19,7 @@ __all__ = [
     "load_config_from_dict",
     "resolve_env_var",
     "validate_camera_references",
+    "validate_config",
+    "validate_plugin_configs",
     "validate_plugin_names",
 ]

homesec/config/loader.py

@@ -48,10 +48,18 @@ def load_config(path: Path) -> Config:
         raise ConfigError(f"Config must be a YAML mapping, got {type(raw).__name__}", path=path)
 
     try:
-        return Config.model_validate(raw)
+        config = Config.model_validate(raw)
     except ValidationError as e:
         raise ConfigError(format_validation_error(e, path), path=path) from e
 
+    # Discover plugins and validate plugin-specific config
+    from homesec.config.validation import validate_config
+    from homesec.plugins import discover_all_plugins
+
+    discover_all_plugins()
+    validate_config(config)
+    return config
+
 
 def load_config_from_dict(data: dict[str, Any]) -> Config:
     """Load and validate configuration from a dict (useful for testing).
@@ -66,10 +74,17 @@ def load_config_from_dict(data: dict[str, Any]) -> Config:
         ConfigError: If validation fails
     """
     try:
-        return Config.model_validate(data)
+        config = Config.model_validate(data)
     except ValidationError as e:
         raise ConfigError(format_validation_error(e, path=None)) from e
 
+    from homesec.config.validation import validate_config
+    from homesec.plugins import discover_all_plugins
+
+    discover_all_plugins()
+    validate_config(config)
+    return config
+
 
 def resolve_env_var(env_var_name: str, required: bool = True) -> str | None:
     """Resolve environment variable by name.

homesec/config/validation.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+from pydantic import BaseModel, ValidationError
+
 from homesec.config.loader import ConfigError
 from homesec.models.config import Config
+from homesec.plugins.registry import PluginType, validate_plugin
 
 
 def validate_camera_references(config: Config, camera_names: list[str] | None = None) -> None:
@@ -22,9 +25,17 @@ def validate_camera_references(config: Config, camera_names: list[str] | None =
     camera_set = set(camera_names)
     errors = []
 
-    for camera in config.per_camera_alert:
+    overrides: dict[str, object] = {}
+    if config.alert_policy.backend == "default":
+        raw = config.alert_policy.config
+        if isinstance(raw, BaseModel):
+            overrides = getattr(raw, "overrides", {}) or {}
+        elif isinstance(raw, dict):
+            overrides = raw.get("overrides", {}) or {}
+
+    for camera in overrides:
         if camera not in camera_set:
-            errors.append(f"per_camera_alert references unknown camera: {camera}")
+            errors.append(f"alert_policy.overrides references unknown camera: {camera}")
 
     if errors:
         raise ConfigError("Invalid camera references:\n  " + "\n  ".join(errors))
@@ -56,9 +67,9 @@ def validate_plugin_names(
     errors = []
 
     valid_filters_lower = {name.lower() for name in valid_filters}
-    if config.filter.plugin.lower() not in valid_filters_lower:
+    if config.filter.backend.lower() not in valid_filters_lower:
         errors.append(
-            f"Unknown filter plugin: {config.filter.plugin} (valid: {sorted(valid_filters_lower)})"
+            f"Unknown filter plugin: {config.filter.backend} (valid: {sorted(valid_filters_lower)})"
         )
 
     valid_vlms_lower = {name.lower() for name in valid_vlms}
@@ -95,11 +106,93 @@ def validate_plugin_names(
     if valid_sources is not None:
         valid_sources_lower = {name.lower() for name in valid_sources}
         for camera in config.cameras:
-            if camera.source.type.lower() not in valid_sources_lower:
+            if camera.source.backend.lower() not in valid_sources_lower:
                 errors.append(
                     f"Unknown source type for camera '{camera.name}': "
-                    f"{camera.source.type} (valid: {sorted(valid_sources_lower)})"
+                    f"{camera.source.backend} (valid: {sorted(valid_sources_lower)})"
                 )
 
     if errors:
         raise ConfigError("Invalid plugin configuration:\n  " + "\n  ".join(errors))
+
+
+def validate_plugin_configs(config: Config) -> None:
+    """Validate plugin configs against registered plugin config models."""
+    errors: list[str] = []
+
+    def _add_error(prefix: str, err: Exception) -> None:
+        if isinstance(err, ValidationError):
+            errors.append(f"{prefix}: {err}")
+        else:
+            errors.append(f"{prefix}: {err}")
+
+    try:
+        validate_plugin(
+            PluginType.STORAGE,
+            config.storage.backend,
+            config.storage.config,
+        )
+    except Exception as exc:
+        _add_error(f"storage[{config.storage.backend}]", exc)
+
+    try:
+        validate_plugin(
+            PluginType.FILTER,
+            config.filter.backend,
+            config.filter.config,
+        )
+    except Exception as exc:
+        _add_error(f"filter[{config.filter.backend}]", exc)
+
+    try:
+        validate_plugin(
+            PluginType.ANALYZER,
+            config.vlm.backend,
+            config.vlm.config,
+        )
+    except Exception as exc:
+        _add_error(f"vlm[{config.vlm.backend}]", exc)
+
+    if config.alert_policy.enabled:
+        try:
+            runtime_context = {}
+            if config.alert_policy.backend == "default":
+                runtime_context["trigger_classes"] = list(config.vlm.trigger_classes)
+            validate_plugin(
+                PluginType.ALERT_POLICY,
+                config.alert_policy.backend,
+                config.alert_policy.config,
+                **runtime_context,
+            )
+        except Exception as exc:
+            _add_error(f"alert_policy[{config.alert_policy.backend}]", exc)
+
+    for index, notifier in enumerate(config.notifiers):
+        try:
+            validate_plugin(
+                PluginType.NOTIFIER,
+                notifier.backend,
+                notifier.config,
+            )
+        except Exception as exc:
+            _add_error(f"notifier[{index}:{notifier.backend}]", exc)
+
+    for camera in config.cameras:
+        try:
+            validate_plugin(
+                PluginType.SOURCE,
+                camera.source.backend,
+                camera.source.config,
+                camera_name=camera.name,
+            )
+        except Exception as exc:
+            _add_error(f"source[{camera.name}:{camera.source.backend}]", exc)
+
+    if errors:
+        raise ConfigError("Invalid plugin config:\n  " + "\n  ".join(errors))
+
+
+def validate_config(config: Config, camera_names: list[str] | None = None) -> None:
+    """Validate config boundaries and plugin configs."""
+    validate_camera_references(config, camera_names)
+    validate_plugin_configs(config)

homesec/interfaces.py

@@ -248,7 +248,7 @@ class ObjectFilter(Shutdownable, ABC):
         - MUST be async (use asyncio.to_thread or run_in_executor for blocking code)
         - CPU/GPU-bound plugins should manage their own ProcessPoolExecutor internally
         - I/O-bound plugins can use async HTTP clients directly
-        - Should respect the instance config max_workers if managing worker pool
+        - If managing a worker pool, use concurrency settings from the plugin's config model
         - Should support early exit on first detection for efficiency
         - overrides apply per-call (model path cannot be overridden)
 
@@ -282,7 +282,7 @@ class VLMAnalyzer(Shutdownable, ABC):
         - MUST be async (use asyncio.to_thread or run_in_executor for blocking code)
         - Local models: manage ProcessPoolExecutor internally
         - API-based: use async HTTP clients (aiohttp, httpx)
-        - Should respect config.max_workers if managing worker pool
+        - If managing a worker pool, use concurrency settings from the plugin's config model
         - Should use filter_result to focus analysis (e.g., detected person at timestamp X)
 
         Returns:

homesec/maintenance/cleanup_clips.py

@@ -19,9 +19,10 @@ from pydantic import BaseModel, Field
 from homesec.config import load_config, resolve_env_var
 from homesec.interfaces import ObjectFilter, StorageBackend
 from homesec.models.clip import ClipStateData
-from homesec.models.filter import FilterConfig, YoloFilterSettings
+from homesec.models.filter import FilterConfig
 from homesec.plugins import discover_all_plugins
 from homesec.plugins.filters import load_filter
+from homesec.plugins.filters.yolo import YoloFilterConfig
 from homesec.plugins.storage import load_storage_plugin
 from homesec.repository.clip_repository import ClipRepository
 from homesec.state.postgres import PostgresStateStore
@@ -115,7 +116,17 @@ def _base_payload(
 
 def _recheck_settings(config: FilterConfig) -> dict[str, object]:
     match config.config:
-        case YoloFilterSettings() as settings:
+        case YoloFilterConfig() as settings:
+            return {
+                "model_path": str(settings.model_path),
+                "min_confidence": float(settings.min_confidence),
+                "sample_fps": int(settings.sample_fps),
+                "min_box_h_ratio": float(settings.min_box_h_ratio),
+                "min_hits": int(settings.min_hits),
+                "classes": list(settings.classes),
+            }
+        case dict() as raw:
+            settings = YoloFilterConfig.model_validate(raw)
             return {
                 "model_path": str(settings.model_path),
                 "min_confidence": float(settings.min_confidence),
@@ -130,8 +141,10 @@ def _recheck_settings(config: FilterConfig) -> dict[str, object]:
 
 def _build_recheck_filter_config(base: FilterConfig, opts: CleanupOptions) -> FilterConfig:
     match base.config:
-        case YoloFilterSettings() as yolo:
+        case YoloFilterConfig() as yolo:
             settings = yolo.model_copy(deep=True)
+        case dict() as raw:
+            settings = YoloFilterConfig.model_validate(raw)
         case _:
             raise ValueError(f"Unsupported filter config type: {type(base.config).__name__}")
 
@@ -144,9 +157,9 @@ def _build_recheck_filter_config(base: FilterConfig, opts: CleanupOptions) -> Fi
         settings.min_box_h_ratio = opts.recheck_min_box_h_ratio
     if opts.recheck_min_hits is not None:
         settings.min_hits = opts.recheck_min_hits
+    settings.max_workers = int(opts.workers)
 
     merged = base.model_copy(deep=True)
-    merged.max_workers = int(opts.workers)
     merged.config = settings
     return merged
 

homesec/models/__init__.py

@@ -4,34 +4,23 @@ from homesec.models.alert import Alert, AlertDecision
 from homesec.models.clip import Clip, ClipStateData, _resolve_forward_refs
 from homesec.models.config import (
     AlertPolicyConfig,
-    AlertPolicyOverrides,
     CameraConfig,
     CameraSourceConfig,
     ConcurrencyConfig,
     Config,
-    DefaultAlertPolicySettings,
-    DropboxStorageConfig,
     HealthConfig,
-    LocalStorageConfig,
-    MQTTAuthConfig,
-    MQTTConfig,
     NotifierConfig,
     RetentionConfig,
     RetryConfig,
-    SendGridEmailConfig,
     StateStoreConfig,
     StorageConfig,
     StoragePathsConfig,
 )
-from homesec.models.enums import RiskLevel, RiskLevelField
-from homesec.models.filter import FilterConfig, FilterOverrides, FilterResult, YoloFilterSettings
-from homesec.models.source.ftp import FtpSourceConfig
-from homesec.models.source.local_folder import LocalFolderSourceConfig
-from homesec.models.source.rtsp import RTSPSourceConfig
+from homesec.models.enums import RiskLevel, RiskLevelField, VLMRunMode
+from homesec.models.filter import FilterConfig, FilterOverrides, FilterResult
 from homesec.models.vlm import (
     AnalysisResult,
     EntityTimeline,
-    OpenAILLMConfig,
     SequenceAnalysis,
     VLMConfig,
     VLMPreprocessConfig,
@@ -44,7 +33,6 @@ __all__ = [
     "Alert",
     "AlertDecision",
     "AlertPolicyConfig",
-    "AlertPolicyOverrides",
     "AnalysisResult",
     "CameraConfig",
     "CameraSourceConfig",
@@ -52,31 +40,21 @@ __all__ = [
     "ClipStateData",
     "ConcurrencyConfig",
     "Config",
-    "DefaultAlertPolicySettings",
-    "DropboxStorageConfig",
     "EntityTimeline",
     "FilterConfig",
     "FilterOverrides",
     "FilterResult",
-    "FtpSourceConfig",
     "HealthConfig",
-    "LocalFolderSourceConfig",
-    "LocalStorageConfig",
-    "MQTTAuthConfig",
-    "MQTTConfig",
     "NotifierConfig",
-    "OpenAILLMConfig",
-    "RTSPSourceConfig",
     "RetentionConfig",
     "RetryConfig",
     "RiskLevel",
     "RiskLevelField",
-    "SendGridEmailConfig",
     "SequenceAnalysis",
     "StateStoreConfig",
     "StorageConfig",
     "StoragePathsConfig",
     "VLMConfig",
     "VLMPreprocessConfig",
-    "YoloFilterSettings",
+    "VLMRunMode",
 ]

homesec/models/clip.py

@@ -25,7 +25,7 @@ class Clip(BaseModel):
     start_ts: datetime
     end_ts: datetime
     duration_s: float
-    source_type: str  # "rtsp", "ftp", etc.
+    source_backend: str  # "rtsp", "ftp", etc.
 
 
 class ClipStateData(BaseModel):