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

homesec/models/config.py

@@ -2,34 +2,14 @@
 
 from __future__ import annotations
 
-from typing import Any, TypeVar
+from typing import Any
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
-from homesec.models.enums import RiskLevel, RiskLevelField
 from homesec.models.filter import FilterConfig
-from homesec.models.source import FtpSourceConfig, LocalFolderSourceConfig, RTSPSourceConfig
 from homesec.models.vlm import VLMConfig
 
 
-class AlertPolicyOverrides(BaseModel):
-    """Per-camera alert policy overrides (only non-None fields override base)."""
-
-    min_risk_level: RiskLevelField | None = None
-    notify_on_activity_types: list[str] | None = None
-    notify_on_motion: bool | None = None
-
-
-class DefaultAlertPolicySettings(BaseModel):
-    """Default alert policy settings."""
-
-    min_risk_level: RiskLevelField = RiskLevel.MEDIUM
-    notify_on_activity_types: list[str] = Field(default_factory=list)
-    notify_on_motion: bool = False
-    overrides: dict[str, AlertPolicyOverrides] = Field(default_factory=dict, exclude=True)
-    trigger_classes: list[str] = Field(default_factory=list, exclude=True)
-
-
 class AlertPolicyConfig(BaseModel):
     """Alert policy plugin configuration."""
 
@@ -44,31 +24,6 @@ class AlertPolicyConfig(BaseModel):
             return value.lower()
         return value
 
-    @model_validator(mode="after")
-    def _validate_alert_policy(self) -> AlertPolicyConfig:
-        # Validate and reassign config for built-in backends
-        if self.backend == "default" and isinstance(self.config, dict):
-            validated = DefaultAlertPolicySettings.model_validate(self.config)
-            object.__setattr__(self, "config", validated)
-        return self
-
-
-class DropboxStorageConfig(BaseModel):
-    """Dropbox storage configuration."""
-
-    root: str
-    token_env: str = "DROPBOX_TOKEN"
-    app_key_env: str = "DROPBOX_APP_KEY"
-    app_secret_env: str = "DROPBOX_APP_SECRET"
-    refresh_token_env: str = "DROPBOX_REFRESH_TOKEN"
-    web_url_prefix: str = "https://www.dropbox.com/home"
-
-
-class LocalStorageConfig(BaseModel):
-    """Local storage configuration."""
-
-    root: str = "./storage"
-
 
 class StoragePathsConfig(BaseModel):
     """Logical storage paths for different artifact types."""
@@ -79,17 +34,12 @@ class StoragePathsConfig(BaseModel):
 
 
 class StorageConfig(BaseModel):
-    """Storage backend configuration.
+    """Storage backend configuration."""
 
-    Note: Backend names are validated against the registry at runtime via
-    validate_plugin_names(). This allows third-party storage plugins via entry points.
-    """
-
-    model_config = {"extra": "allow"}  # Allow third-party backend configs
+    model_config = {"extra": "forbid"}
 
     backend: str = "dropbox"
-    dropbox: DropboxStorageConfig | None = None
-    local: LocalStorageConfig | None = None
+    config: dict[str, Any] | BaseModel = Field(default_factory=dict)
     paths: StoragePathsConfig = Field(default_factory=StoragePathsConfig)
 
     @field_validator("backend", mode="before")
@@ -99,30 +49,6 @@ class StorageConfig(BaseModel):
             return value.lower()
         return value
 
-    @model_validator(mode="after")
-    def _validate_builtin_backends(self) -> StorageConfig:
-        """Validate that built-in backends have their required config.
-
-        Third-party backends are validated later in load_storage_plugin().
-        """
-        match self.backend:
-            case "dropbox":
-                if self.dropbox is None:
-                    raise ValueError(
-                        "storage.dropbox is required when backend=dropbox. "
-                        "Add 'storage.dropbox' section to your config."
-                    )
-            case "local":
-                if self.local is None:
-                    raise ValueError(
-                        "storage.local is required when backend=local. "
-                        "Add 'storage.local' section to your config."
-                    )
-            case _:
-                # Third-party backend - validation happens in load_storage_plugin()
-                pass
-        return self
-
 
 class StateStoreConfig(BaseModel):
     """State store configuration."""
@@ -137,81 +63,12 @@ class StateStoreConfig(BaseModel):
         return self
 
 
-class MQTTAuthConfig(BaseModel):
-    """MQTT auth configuration using env var names."""
-
-    username_env: str | None = None
-    password_env: str | None = None
-
-
-class MQTTConfig(BaseModel):
-    """MQTT notifier configuration."""
-
-    host: str
-    port: int = 1883
-    auth: MQTTAuthConfig | None = None
-    topic_template: str = "homecam/alerts/{camera_name}"
-    qos: int = 1
-    retain: bool = False
-    connection_timeout: float = 10.0
-
-
-class SendGridEmailConfig(BaseModel):
-    """SendGrid email notifier configuration."""
-
-    api_key_env: str = "SENDGRID_API_KEY"
-    from_email: str
-    from_name: str | None = None
-    to_emails: list[str] = Field(min_length=1)
-    cc_emails: list[str] = Field(default_factory=list)
-    bcc_emails: list[str] = Field(default_factory=list)
-    subject_template: str = "[HomeSec] {camera_name}: {activity_type} ({risk_level})"
-    text_template: str = (
-        "HomeSec alert\n"
-        "Camera: {camera_name}\n"
-        "Clip: {clip_id}\n"
-        "Risk: {risk_level}\n"
-        "Activity: {activity_type}\n"
-        "Reason: {notify_reason}\n"
-        "Summary: {summary}\n"
-        "View: {view_url}\n"
-        "Storage: {storage_uri}\n"
-        "Time: {ts}\n"
-        "Upload failed: {upload_failed}\n"
-    )
-    html_template: str = (
-        "<html><body>"
-        "<h2>HomeSec alert</h2>"
-        "<p><strong>Camera:</strong> {camera_name}</p>"
-        "<p><strong>Clip:</strong> {clip_id}</p>"
-        "<p><strong>Risk:</strong> {risk_level}</p>"
-        "<p><strong>Activity:</strong> {activity_type}</p>"
-        "<p><strong>Reason:</strong> {notify_reason}</p>"
-        "<p><strong>Summary:</strong> {summary}</p>"
-        '<p><strong>View:</strong> <a href="{view_url}">{view_url}</a></p>'
-        "<p><strong>Storage:</strong> {storage_uri}</p>"
-        "<p><strong>Time:</strong> {ts}</p>"
-        "<p><strong>Upload failed:</strong> {upload_failed}</p>"
-        "<h3>Structured analysis</h3>"
-        "{analysis_html}"
-        "</body></html>"
-    )
-    request_timeout_s: float = 10.0
-    api_base: str = "https://api.sendgrid.com/v3"
-
-    @model_validator(mode="after")
-    def _validate_templates(self) -> SendGridEmailConfig:
-        if not self.text_template and not self.html_template:
-            raise ValueError("sendgrid_email requires at least one of text_template/html_template")
-        return self
-
-
 class NotifierConfig(BaseModel):
     """Notifier configuration entry."""
 
     backend: str
     enabled: bool = True
-    config: dict[str, Any] = Field(default_factory=dict)
+    config: dict[str, Any] | BaseModel = Field(default_factory=dict)
 
     @field_validator("backend", mode="before")
     @classmethod
@@ -252,72 +109,20 @@ class HealthConfig(BaseModel):
 
 
 class CameraSourceConfig(BaseModel):
-    """Camera source configuration wrapper.
-
-    The `type` field is a string to allow external plugins to register new source types.
-    Built-in types ("rtsp", "local_folder", "ftp") have their configs validated here.
-    External plugin configs are validated by the plugin at load time.
-    """
+    """Camera source configuration wrapper."""
 
     model_config = {"extra": "forbid"}
 
-    type: str
-    config: RTSPSourceConfig | LocalFolderSourceConfig | FtpSourceConfig | dict[str, Any]
+    backend: str
+    config: dict[str, Any] | BaseModel = Field(default_factory=dict)
 
-    @model_validator(mode="before")
-    @classmethod
-    def _parse_source_config(cls, data: object) -> object:
-        if not isinstance(data, dict):
-            return data
-        source_type = data.get("type")
-        raw_config = data.get("config")
-        if isinstance(raw_config, (RTSPSourceConfig, LocalFolderSourceConfig, FtpSourceConfig)):
-            return data
-
-        config_data = raw_config or {}
-        updated = dict(data)
-        if isinstance(source_type, str):
-            source_type = source_type.lower()
-            updated["type"] = source_type
-        match source_type:
-            case "rtsp":
-                updated["config"] = RTSPSourceConfig.model_validate(config_data)
-            case "local_folder":
-                updated["config"] = LocalFolderSourceConfig.model_validate(config_data)
-            case "ftp":
-                updated["config"] = FtpSourceConfig.model_validate(config_data)
-            case _:
-                # External plugin source type - keep config as dict
-                # Plugin will validate at load time
-                updated["config"] = config_data if isinstance(config_data, dict) else {}
-        return updated
-
-    @field_validator("type", mode="before")
+    @field_validator("backend", mode="before")
     @classmethod
-    def _normalize_type(cls, value: Any) -> Any:
+    def _normalize_backend(cls, value: Any) -> Any:
         if isinstance(value, str):
             return value.lower()
         return value
 
-    @model_validator(mode="after")
-    def _validate_source_config(self) -> CameraSourceConfig:
-        match self.type:
-            case "rtsp":
-                if not isinstance(self.config, RTSPSourceConfig):
-                    raise ValueError("camera.source.config must be RTSPSourceConfig for type=rtsp")
-            case "local_folder":
-                if not isinstance(self.config, LocalFolderSourceConfig):
-                    raise ValueError(
-                        "camera.source.config must be LocalFolderSourceConfig for type=local_folder"
-                    )
-            case "ftp":
-                if not isinstance(self.config, FtpSourceConfig):
-                    raise ValueError("camera.source.config must be FtpSourceConfig for type=ftp")
-            case _:
-                # External plugin source type - validation happens at plugin load time
-                pass
-        return self
-
 
 class CameraConfig(BaseModel):
     """Camera configuration and clip source selection."""
@@ -326,9 +131,6 @@ class CameraConfig(BaseModel):
     source: CameraSourceConfig
 
 
-TConfig = TypeVar("TConfig", bound=BaseModel)
-
-
 class Config(BaseModel):
     """Main configuration with per-camera override support."""
 
@@ -345,59 +147,8 @@ class Config(BaseModel):
     vlm: VLMConfig
     alert_policy: AlertPolicyConfig
 
-    # Per-camera overrides (alert policy only)
-    per_camera_alert: dict[str, AlertPolicyOverrides] = Field(default_factory=dict)
-
     @model_validator(mode="after")
     def _validate_notifiers(self) -> Config:
         if not self.notifiers:
             raise ValueError("notifiers must include at least one notifier")
         return self
-
-    @model_validator(mode="after")
-    def _validate_builtin_plugin_configs(self) -> Config:
-        """Validate built-in plugin configs for early error detection.
-
-        Third-party plugin configs are validated later during plugin loading.
-        """
-        # Validate built-in filter configs
-        if self.filter.plugin == "yolo":
-            from homesec.models.filter import YoloFilterSettings
-
-            if isinstance(self.filter.config, dict):
-                validated_filter_config = YoloFilterSettings.model_validate(self.filter.config)
-                # Replace dict with validated object for built-in plugins
-                object.__setattr__(self.filter, "config", validated_filter_config)
-
-        # Validate built-in VLM configs
-        if self.vlm.backend == "openai":
-            from homesec.models.vlm import OpenAILLMConfig
-
-            if isinstance(self.vlm.llm, dict):
-                validated_llm_config = OpenAILLMConfig.model_validate(self.vlm.llm)
-                # Replace dict with validated object for built-in plugins
-                object.__setattr__(self.vlm, "llm", validated_llm_config)
-
-        return self
-
-    def _merge_overrides(
-        self, base: TConfig, overrides: BaseModel, model_type: type[TConfig]
-    ) -> TConfig:
-        merged = {
-            **base.model_dump(),
-            **overrides.model_dump(exclude_none=True),
-        }
-        return model_type.model_validate(merged)
-
-    def get_default_alert_policy(self, camera_name: str) -> DefaultAlertPolicySettings:
-        """Get merged default alert policy settings for a specific camera."""
-        if self.alert_policy.backend != "default":
-            raise ValueError(
-                f"default alert policy requested but backend is {self.alert_policy.backend}"
-            )
-        base = DefaultAlertPolicySettings.model_validate(self.alert_policy.config)
-        if camera_name not in self.per_camera_alert:
-            return base
-
-        overrides = self.per_camera_alert[camera_name]
-        return self._merge_overrides(base, overrides, DefaultAlertPolicySettings)

homesec/models/enums.py

@@ -66,6 +66,14 @@ class ClipStatus(StrEnum):
     DELETED = "deleted"
 
 
+class VLMRunMode(StrEnum):
+    """Policy for when to run VLM analysis."""
+
+    TRIGGER_ONLY = "trigger_only"
+    ALWAYS = "always"
+    NEVER = "never"
+
+
 class RiskLevel(IntEnum):
     """VLM risk assessment levels.
 

homesec/models/events.py

@@ -26,7 +26,7 @@ class ClipRecordedEvent(ClipEvent):
     event_type: Literal[EventType.CLIP_RECORDED] = EventType.CLIP_RECORDED
     camera_name: str
     duration_s: float
-    source_type: str
+    source_backend: str
 
 
 class ClipDeletedEvent(ClipEvent):

homesec/models/filter.py

@@ -16,23 +16,6 @@ class FilterResult(BaseModel):
     sampled_frames: int
 
 
-class YoloFilterSettings(BaseModel):
-    """YOLO filter settings.
-
-    model_path accepts a filename; bare names resolve under ./yolo_cache.
-    """
-
-    model_config = {"extra": "forbid"}
-
-    model_path: str = "yolo11n.pt"
-    classes: list[str] = Field(default_factory=lambda: ["person"], min_length=1)
-    min_confidence: float = Field(default=0.5, ge=0.0, le=1.0)
-    sample_fps: int = Field(default=2, ge=1)
-    min_box_h_ratio: float = Field(default=0.1, ge=0.0, le=1.0)
-    min_hits: int = Field(default=1, ge=1)
-    max_workers: int = Field(default=4, ge=1)
-
-
 class FilterOverrides(BaseModel):
     """Runtime overrides for filter settings (model path not allowed)."""
 
@@ -58,13 +41,12 @@ class FilterConfig(BaseModel):
 
     model_config = {"extra": "forbid"}
 
-    plugin: str
-    max_workers: int = Field(default=4, ge=1)
+    backend: str
     config: dict[str, Any] | BaseModel  # Dict before validation, BaseModel after
 
-    @field_validator("plugin", mode="before")
+    @field_validator("backend", mode="before")
     @classmethod
-    def _normalize_plugin(cls, value: Any) -> Any:
+    def _normalize_backend(cls, value: Any) -> Any:
         if isinstance(value, str):
             return value.lower()
         return value

homesec/models/vlm.py

@@ -6,7 +6,7 @@ from typing import Any, Literal
 
 from pydantic import BaseModel, Field, field_validator
 
-from homesec.models.enums import RiskLevelField
+from homesec.models.enums import RiskLevelField, VLMRunMode
 
 __all__ = ["AnalysisResult", "VLMConfig", "VLMPreprocessConfig"]
 
@@ -67,26 +67,10 @@ class VLMPreprocessConfig(BaseModel):
     quality: int = 85
 
 
-class OpenAILLMConfig(BaseModel):
-    """OpenAI-compatible LLM configuration."""
-
-    model_config = {"extra": "forbid"}
-    api_key_env: str
-    model: str
-    base_url: str = "https://api.openai.com/v1"
-    token_param: Literal["max_tokens", "max_completion_tokens"] = "max_completion_tokens"
-    max_completion_tokens: int = 10_000
-    max_tokens: int | None = None
-    temperature: float | None = 0.0
-    request_timeout: float = 60.0
-    trigger_classes: list[str] = Field(default_factory=lambda: ["person"])
-    max_workers: int = Field(default=2, ge=1)
-
-
 class VLMConfig(BaseModel):
     """Base VLM configuration.
 
-    LLM-specific config is stored in the 'llm' field.
+    Backend-specific config is stored in the 'config' field.
     - During YAML parsing: dict[str, Any] (preserves all third-party fields)
     - After plugin discovery: BaseModel subclass (validated against plugin.config_model)
 
@@ -97,8 +81,8 @@ class VLMConfig(BaseModel):
     model_config = {"extra": "forbid"}
     backend: str
     trigger_classes: list[str] = Field(default_factory=lambda: ["person"])
-    max_workers: int = Field(default=2, ge=1)
-    llm: dict[str, Any] | BaseModel  # Dict before validation, BaseModel after
+    run_mode: VLMRunMode = VLMRunMode.TRIGGER_ONLY
+    config: dict[str, Any] | BaseModel  # Dict before validation, BaseModel after
     preprocessing: VLMPreprocessConfig = Field(default_factory=VLMPreprocessConfig)
 
     @field_validator("backend", mode="before")
@@ -107,3 +91,10 @@ class VLMConfig(BaseModel):
         if isinstance(value, str):
             return value.lower()
         return value
+
+    @field_validator("run_mode", mode="before")
+    @classmethod
+    def _normalize_run_mode(cls, value: Any) -> Any:
+        if isinstance(value, str):
+            return value.lower()
+        return value

homesec/pipeline/__init__.py

@@ -1,6 +1,5 @@
 """Pipeline module - clip processing orchestration."""
 
-from homesec.pipeline.alert_policy import DefaultAlertPolicy
 from homesec.pipeline.core import ClipPipeline
 
-__all__ = ["ClipPipeline", "DefaultAlertPolicy"]
+__all__ = ["ClipPipeline"]

homesec/pipeline/core.py

@@ -16,7 +16,7 @@ from homesec.models.clip import Clip
 from homesec.models.config import Config
 from homesec.models.filter import FilterResult
 from homesec.models.vlm import AnalysisResult
-from homesec.plugins.notifiers.multiplex import NotifierEntry
+from homesec.notifiers.multiplex import NotifierEntry
 from homesec.repository import ClipRepository
 from homesec.storage_paths import build_clip_path
 
@@ -194,7 +194,7 @@ class ClipPipeline:
             # Stage 3: VLM (conditional)
             analysis_result: AnalysisResult | None = None
             vlm_failed = False
-            if self._should_run_vlm(clip.camera_name, filter_res):
+            if self._should_run_vlm(filter_res):
                 vlm_result = await self._vlm_stage(clip, filter_res)
                 match vlm_result:
                     case VLMError() as vlm_err:
@@ -418,7 +418,7 @@ class ClipPipeline:
                 on_attempt_failure=on_attempt_failure,
             )
         except Exception as e:
-            return FilterError(clip.clip_id, plugin_name=self._config.filter.plugin, cause=e)
+            return FilterError(clip.clip_id, plugin_name=self._config.filter.backend, cause=e)
 
     async def _vlm_stage(
         self, clip: Clip, filter_result: FilterResult
@@ -564,15 +564,14 @@ class ClipPipeline:
                 return type(exc.cause).__name__
         return type(exc).__name__
 
-    def _should_run_vlm(self, camera_name: str, filter_result: FilterResult) -> bool:
+    def _should_run_vlm(self, filter_result: FilterResult) -> bool:
         """Check if VLM should run based on detected classes and config."""
-        if self._config.alert_policy.backend == "default":
-            alert_config = self._config.get_default_alert_policy(camera_name)
-            # If notify_on_motion enabled, always run VLM for richer context
-            if alert_config.notify_on_motion:
-                return True
+        run_mode = self._config.vlm.run_mode
+        if run_mode == "never":
+            return False
+        if run_mode == "always":
+            return True
 
-        # Otherwise check if detected classes intersect trigger classes
         detected = set(filter_result.detected_classes)
         trigger = set(self._config.vlm.trigger_classes)
         return bool(detected & trigger)

homesec/plugins/alert_policies/__init__.py

@@ -6,7 +6,6 @@ import logging
 from typing import Any, cast
 
 from homesec.interfaces import AlertPolicy
-from homesec.models.config import AlertPolicyOverrides
 from homesec.plugins.alert_policies.noop import NoopAlertPolicySettings
 from homesec.plugins.registry import PluginType, load_plugin
 
@@ -15,14 +14,12 @@ logger = logging.getLogger(__name__)
 
 def load_alert_policy(
     config: Any,  # AlertPolicyConfig but trying to avoid circular import if possible
-    per_camera_overrides: dict[str, AlertPolicyOverrides],
     trigger_classes: list[str],
 ) -> AlertPolicy:
     """Load and instantiate an alert policy plugin.
 
     Args:
         config: Alert policy configuration (AlertPolicyConfig)
-        per_camera_overrides: Map of camera name to override settings
         trigger_classes: List of object classes that trigger analysis
 
     Returns:
@@ -39,14 +36,17 @@ def load_alert_policy(
             ),
         )
 
+    runtime_context: dict[str, Any] = {}
+    if config.backend == "default":
+        runtime_context["trigger_classes"] = list(trigger_classes)
+
     return cast(
         AlertPolicy,
         load_plugin(
             PluginType.ALERT_POLICY,
             config.backend,
             config.config,
-            overrides=per_camera_overrides,
-            trigger_classes=trigger_classes,
+            **runtime_context,
         ),
     )
 

homesec/plugins/alert_policies/default.py

@@ -2,15 +2,34 @@
 
 from __future__ import annotations
 
+from pydantic import BaseModel, Field
+
 from homesec.interfaces import AlertPolicy
 from homesec.models.alert import AlertDecision
-from homesec.models.config import DefaultAlertPolicySettings
-from homesec.models.enums import RiskLevel
+from homesec.models.enums import RiskLevel, RiskLevelField
 from homesec.models.filter import FilterResult
 from homesec.models.vlm import AnalysisResult
 from homesec.plugins.registry import PluginType, plugin
 
 
+class AlertPolicyOverrides(BaseModel):
+    """Per-camera alert policy overrides (only non-None fields override base)."""
+
+    min_risk_level: RiskLevelField | None = None
+    notify_on_activity_types: list[str] | None = None
+    notify_on_motion: bool | None = None
+
+
+class DefaultAlertPolicySettings(BaseModel):
+    """Default alert policy settings."""
+
+    min_risk_level: RiskLevelField = RiskLevel.MEDIUM
+    notify_on_activity_types: list[str] = Field(default_factory=list)
+    notify_on_motion: bool = False
+    overrides: dict[str, AlertPolicyOverrides] = Field(default_factory=dict)
+    trigger_classes: list[str] = Field(default_factory=list)
+
+
 @plugin(plugin_type=PluginType.ALERT_POLICY, name="default")
 class DefaultAlertPolicy(AlertPolicy):
     """Default alert policy implementation."""

homesec/plugins/analyzers/__init__.py

@@ -30,9 +30,7 @@ def load_analyzer(config: VLMConfig) -> VLMAnalyzer:
         load_plugin(
             PluginType.ANALYZER,
             config.backend,
-            config.llm,
-            trigger_classes=config.trigger_classes,
-            max_workers=config.max_workers,
+            config.config,
         ),
     )