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

homesec/plugins/analyzers/openai.py

@@ -8,7 +8,7 @@ import json
 import logging
 import os
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 aiohttp: Any
 cv2: Any
@@ -31,13 +31,7 @@ from pydantic import BaseModel
 
 from homesec.interfaces import VLMAnalyzer
 from homesec.models.filter import FilterResult
-from homesec.models.vlm import (
-    AnalysisResult,
-    OpenAILLMConfig,
-    SequenceAnalysis,
-    VLMConfig,
-    VLMPreprocessConfig,
-)
+from homesec.models.vlm import AnalysisResult, SequenceAnalysis, VLMConfig, VLMPreprocessConfig
 from homesec.plugins.registry import PluginType, plugin
 
 logger = logging.getLogger(__name__)
@@ -61,6 +55,20 @@ Focus on KEY EVENTS ONLY:
 Keep observations list concise (short bullet points of security-relevant actions)."""
 
 
+class OpenAIConfig(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
+
+
 def _ensure_openai_dependencies() -> None:
     """Fail fast with a clear error if OpenAI VLM dependencies are missing."""
     if aiohttp is None or cv2 is None or Image is None:
@@ -92,18 +100,17 @@ class OpenAIVLM(VLMAnalyzer):
     Supports structured output with Pydantic schemas.
     """
 
-    config_cls = OpenAILLMConfig
+    config_cls = OpenAIConfig
 
     @classmethod
-    def create(cls, config: OpenAILLMConfig) -> VLMAnalyzer:
+    def create(cls, config: OpenAIConfig) -> VLMAnalyzer:
         return cls(config)
 
-    def __init__(self, llm_config: OpenAILLMConfig) -> None:
+    def __init__(self, llm_config: OpenAIConfig) -> None:
         """Initialize OpenAI VLM with validated LLM config.
 
         Args:
             llm_config: OpenAI-specific configuration (API key, model, etc.)
-                        Also assumes injected runtime fields (trigger_classes, max_workers)
         """
         _ensure_openai_dependencies()
         self._config = llm_config
@@ -335,7 +342,7 @@ class OpenAIVLM(VLMAnalyzer):
                 f"VLM response does not match SequenceAnalysis schema: {e}. Raw response: {content}"
             ) from e
 
-    def _resolve_token_limit(self, llm: OpenAILLMConfig) -> int:
+    def _resolve_token_limit(self, llm: OpenAIConfig) -> int:
         if self.token_param == "max_completion_tokens":
             value = llm.max_completion_tokens or llm.max_tokens or 1000
         else:

homesec/plugins/filters/__init__.py

@@ -29,9 +29,8 @@ def load_filter(config: FilterConfig) -> ObjectFilter:
         ObjectFilter,
         load_plugin(
             PluginType.FILTER,
-            config.plugin,
+            config.backend,
             config.config,
-            max_workers=config.max_workers,
         ),
     )
 

homesec/plugins/filters/yolo.py

@@ -27,12 +27,32 @@ else:
     torch = _torch
     YOLO_CLASS = _YOLO
 
+from pydantic import BaseModel, Field
+
 from homesec.interfaces import ObjectFilter
-from homesec.models.filter import FilterOverrides, FilterResult, YoloFilterSettings
+from homesec.models.filter import FilterOverrides, FilterResult
 from homesec.plugins.registry import PluginType, plugin
 
 logger = logging.getLogger(__name__)
 
+
+class YoloFilterConfig(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)
+
+
 # COCO classes for humans and animals
 HUMAN_ANIMAL_CLASSES = {
     0: "person",
@@ -159,13 +179,13 @@ class YOLOFilter(ObjectFilter):
     Bare model filenames resolve under ./yolo_cache and auto-download if missing.
     """
 
-    config_cls = YoloFilterSettings
+    config_cls = YoloFilterConfig
 
     @classmethod
-    def create(cls, config: YoloFilterSettings) -> ObjectFilter:
+    def create(cls, config: YoloFilterConfig) -> ObjectFilter:
         return cls(config)
 
-    def __init__(self, settings: YoloFilterSettings) -> None:
+    def __init__(self, settings: YoloFilterConfig) -> None:
         """Initialize YOLO filter with validated settings.
 
         Args:
@@ -243,7 +263,7 @@ class YOLOFilter(ObjectFilter):
         # Executor is considered healthy if not shut down
         return True
 
-    def _apply_overrides(self, overrides: FilterOverrides | None) -> YoloFilterSettings:
+    def _apply_overrides(self, overrides: FilterOverrides | None) -> YoloFilterConfig:
         if overrides is None:
             return self._settings
         update = overrides.model_dump(exclude_none=True)

homesec/plugins/notifiers/__init__.py

@@ -8,7 +8,6 @@ from typing import cast
 from pydantic import BaseModel
 
 from homesec.interfaces import Notifier
-from homesec.plugins.notifiers.multiplex import MultiplexNotifier, NotifierEntry
 from homesec.plugins.registry import PluginType, load_plugin
 
 logger = logging.getLogger(__name__)
@@ -38,8 +37,4 @@ def load_notifier_plugin(backend: str, config: dict[str, object] | BaseModel) ->
     )
 
 
-__all__ = [
-    "MultiplexNotifier",
-    "NotifierEntry",
-    "load_notifier_plugin",
-]
+__all__ = ["load_notifier_plugin"]

homesec/plugins/notifiers/mqtt.py

@@ -17,14 +17,34 @@ except Exception:
 else:
     mqtt = _mqtt
 
+from pydantic import BaseModel
+
 from homesec.interfaces import Notifier
 from homesec.models.alert import Alert
-from homesec.models.config import MQTTConfig
 from homesec.plugins.registry import PluginType, plugin
 
 logger = logging.getLogger(__name__)
 
 
+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
+
+
 @plugin(plugin_type=PluginType.NOTIFIER, name="mqtt")
 class MQTTNotifier(Notifier):
     """MQTT notifier for Home Assistant alerts.

homesec/plugins/notifiers/sendgrid_email.py

@@ -19,15 +19,66 @@ else:
     aiohttp = _aiohttp
 
 
+from pydantic import BaseModel, Field, model_validator
+
 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.plugins.registry import PluginType, plugin
 
 logger = logging.getLogger(__name__)
 
 
+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
+
+
 def _ensure_sendgrid_dependencies() -> None:
     """Fail fast with a clear error if SendGrid dependencies are missing."""
     if aiohttp is None:

homesec/plugins/registry.py

@@ -95,6 +95,19 @@ class PluginRegistry(Generic[ConfigT, PluginInterfaceT]):
         # 3. Create instance
         return plugin_cls.create(validated_config)
 
+    def validate(self, name: str, config_dict: dict[str, Any], **runtime_context: Any) -> BaseModel:
+        """Validate configuration for a plugin without instantiating it."""
+        if name not in self._plugins:
+            available = ", ".join(sorted(self._plugins.keys()))
+            raise ValueError(f"Unknown {self.plugin_type} plugin: '{name}'. Available: {available}")
+
+        plugin_cls = self._plugins[name]
+
+        merged_config = config_dict.copy()
+        merged_config.update(runtime_context)
+
+        return plugin_cls.config_cls.model_validate(merged_config)
+
     def get_all(self) -> dict[str, type[PluginProtocol[ConfigT, PluginInterfaceT]]]:
         """Return all registered plugins."""
         return self._plugins.copy()
@@ -155,6 +168,20 @@ def load_plugin(
     return registry.load(name, config_dict, **runtime_context)
 
 
+def validate_plugin(
+    plugin_type: PluginType, name: str, config: dict[str, Any] | BaseModel, **runtime_context: Any
+) -> BaseModel:
+    """Validate plugin configuration without instantiating it."""
+    registry = _REGISTRIES[plugin_type]
+
+    if isinstance(config, BaseModel):
+        config_dict = config.model_dump()
+    else:
+        config_dict = config
+
+    return registry.validate(name, config_dict, **runtime_context)
+
+
 def get_plugin_names(plugin_type: PluginType) -> list[str]:
     """Get list of registered plugin names for a given type."""
     return sorted(_REGISTRIES[plugin_type].get_all().keys())

homesec/plugins/sources/__init__.py

@@ -14,14 +14,14 @@ logger = logging.getLogger(__name__)
 
 
 def load_source_plugin(
-    source_type: str,
+    source_backend: str,
     config: dict[str, object] | BaseModel,
     camera_name: str,
 ) -> ClipSource:
     """Load and instantiate a source plugin.
 
     Args:
-        source_type: Name of the source plugin (e.g., "rtsp", "local_folder")
+        source_backend: Name of the source plugin (e.g., "rtsp", "local_folder")
         config: Raw config dict or validated BaseModel
         camera_name: Name of the camera (runtime context)
 
@@ -29,13 +29,13 @@ def load_source_plugin(
         Instantiated ClipSource
 
     Raises:
-        ValueError: If source_type is unknown or config validation fails
+        ValueError: If source_backend is unknown or config validation fails
     """
     return cast(
         ClipSource,
         load_plugin(
             PluginType.SOURCE,
-            source_type,
+            source_backend,
             config,
             camera_name=camera_name,
         ),

homesec/plugins/sources/ftp.py

@@ -3,11 +3,11 @@
 from __future__ import annotations
 
 from homesec.interfaces import ClipSource
-from homesec.models.source.ftp import FtpSourceConfig
 from homesec.plugins.registry import PluginType, plugin
 
 # Import the actual implementation from sources module
 from homesec.sources.ftp import FtpSource as FtpSourceImpl
+from homesec.sources.ftp import FtpSourceConfig
 
 
 @plugin(plugin_type=PluginType.SOURCE, name="ftp")

homesec/plugins/sources/local_folder.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 from homesec.interfaces import ClipSource
-from homesec.models.source.local_folder import LocalFolderSourceConfig
 from homesec.plugins.registry import PluginType, plugin
 from homesec.sources.local_folder import LocalFolderSource as LocalFolderSourceImpl
+from homesec.sources.local_folder import LocalFolderSourceConfig
 
 
 @plugin(plugin_type=PluginType.SOURCE, name="local_folder")

homesec/plugins/sources/rtsp.py

@@ -5,9 +5,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from homesec.interfaces import ClipSource
-from homesec.models.source.rtsp import RTSPSourceConfig
 from homesec.plugins.registry import PluginType, plugin
 from homesec.sources.rtsp.core import RTSPSource as RTSPSourceImpl
+from homesec.sources.rtsp.core import RTSPSourceConfig
 
 if TYPE_CHECKING:
     pass

homesec/plugins/storage/__init__.py

@@ -24,20 +24,12 @@ def load_storage_plugin(config: StorageConfig) -> StorageBackend:
     Raises:
         ValueError: If backend is unknown or backend-specific config is missing
     """
-    # Extract backend-specific config using attribute access
-    specific_config = getattr(config, config.backend.lower(), None)
-    if specific_config is None:
-        raise ValueError(
-            f"Missing '{config.backend.lower()}' config in storage section. "
-            f"Add 'storage.{config.backend.lower()}' to your config."
-        )
-
     return cast(
         StorageBackend,
         load_plugin(
             PluginType.STORAGE,
             config.backend,
-            specific_config,
+            config.config,
         ),
     )
 

homesec/plugins/storage/dropbox.py

@@ -18,8 +18,9 @@ else:
     dropbox = _dropbox
 
 
+from pydantic import BaseModel
+
 from homesec.interfaces import StorageBackend
-from homesec.models.config import DropboxStorageConfig
 from homesec.models.storage import StorageUploadResult
 from homesec.plugins.registry import PluginType, plugin
 
@@ -28,6 +29,17 @@ logger = logging.getLogger(__name__)
 CHUNK_SIZE = 4 * 1024 * 1024
 
 
+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"
+
+
 @plugin(plugin_type=PluginType.STORAGE, name="dropbox")
 class DropboxStorage(StorageBackend):
     """Dropbox storage backend.

homesec/plugins/storage/local.py

@@ -7,14 +7,21 @@ import logging
 import shutil
 from pathlib import Path, PurePosixPath
 
+from pydantic import BaseModel
+
 from homesec.interfaces import StorageBackend
-from homesec.models.config import LocalStorageConfig
 from homesec.models.storage import StorageUploadResult
 from homesec.plugins.registry import PluginType, plugin
 
 logger = logging.getLogger(__name__)
 
 
+class LocalStorageConfig(BaseModel):
+    """Local storage configuration."""
+
+    root: str = "./storage"
+
+
 @plugin(plugin_type=PluginType.STORAGE, name="local")
 class LocalStorage(StorageBackend):
     """Local storage backend for development and tests."""

homesec/repository/clip_repository.py

@@ -73,7 +73,7 @@ class ClipRepository:
             timestamp=datetime.now(),
             camera_name=clip.camera_name,
             duration_s=clip.duration_s,
-            source_type=clip.source_type,
+            source_backend=clip.source_backend,
         )
 
         await self._safe_upsert(clip.clip_id, state)

homesec/sources/__init__.py

@@ -1,12 +1,9 @@
 """Clip source implementations."""
 
-from homesec.models.source.ftp import FtpSourceConfig
-from homesec.models.source.local_folder import LocalFolderSourceConfig
-from homesec.models.source.rtsp import RTSPSourceConfig
 from homesec.sources.base import ThreadedClipSource
-from homesec.sources.ftp import FtpSource
-from homesec.sources.local_folder import LocalFolderSource
-from homesec.sources.rtsp.core import RTSPSource
+from homesec.sources.ftp import FtpSource, FtpSourceConfig
+from homesec.sources.local_folder import LocalFolderSource, LocalFolderSourceConfig
+from homesec.sources.rtsp.core import RTSPSource, RTSPSourceConfig
 
 __all__ = [
     "FtpSource",

homesec/sources/ftp.py

@@ -9,13 +9,106 @@ from pathlib import Path
 from threading import Thread
 from typing import Any
 
+from pydantic import BaseModel, Field, field_validator
+
 from homesec.models.clip import Clip
-from homesec.models.source.ftp import FtpSourceConfig
 from homesec.sources.base import ThreadedClipSource
 
 logger = logging.getLogger(__name__)
 
 
+class FtpSourceConfig(BaseModel):
+    """FTP source configuration."""
+
+    model_config = {"extra": "forbid"}
+
+    camera_name: str | None = Field(
+        default=None,
+        description="Optional human-friendly camera name.",
+    )
+    host: str = Field(
+        default="0.0.0.0",
+        description="FTP bind address.",
+    )
+    port: int = Field(
+        default=2121,
+        ge=0,
+        le=65535,
+        description="FTP listen port (0 lets the OS choose an ephemeral port).",
+    )
+    root_dir: str = Field(
+        default="./ftp_incoming",
+        description="FTP root directory for uploads.",
+    )
+    ftp_subdir: str | None = Field(
+        default=None,
+        description="Optional subdirectory under root_dir.",
+    )
+    anonymous: bool = Field(
+        default=True,
+        description="Allow anonymous FTP uploads.",
+    )
+    username_env: str | None = Field(
+        default=None,
+        description="Environment variable containing FTP username.",
+    )
+    password_env: str | None = Field(
+        default=None,
+        description="Environment variable containing FTP password.",
+    )
+    perms: str = Field(
+        default="elw",
+        description="pyftpdlib permissions string.",
+    )
+    passive_ports: str | None = Field(
+        default=None,
+        description="Passive ports range (e.g., '60000-60100' or '60000,60010').",
+    )
+    masquerade_address: str | None = Field(
+        default=None,
+        description="Optional masquerade address for passive mode.",
+    )
+    heartbeat_s: float = Field(
+        default=30.0,
+        ge=0.0,
+        description="Seconds between FTP health checks.",
+    )
+    allowed_extensions: list[str] = Field(
+        default_factory=lambda: [".mp4"],
+        description="Allowed file extensions for uploaded clips.",
+    )
+    delete_non_matching: bool = Field(
+        default=True,
+        description="Delete files with disallowed extensions.",
+    )
+    delete_incomplete: bool = Field(
+        default=True,
+        description="Delete incomplete uploads when enabled.",
+    )
+    default_duration_s: float = Field(
+        default=10.0,
+        ge=0.0,
+        description="Fallback clip duration when timestamps are missing.",
+    )
+    log_level: str = Field(
+        default="INFO",
+        description="FTP server log level.",
+    )
+
+    @field_validator("allowed_extensions")
+    @classmethod
+    def _normalize_extensions(cls, value: list[str]) -> list[str]:
+        cleaned: list[str] = []
+        for item in value:
+            ext = str(item).strip().lower()
+            if not ext:
+                continue
+            if not ext.startswith("."):
+                ext = f".{ext}"
+            cleaned.append(ext)
+        return cleaned
+
+
 def _parse_passive_ports(spec: str | None) -> list[int] | None:
     if not spec:
         return None
@@ -164,7 +257,7 @@ class FtpSource(ThreadedClipSource):
             start_ts=mtime - timedelta(seconds=duration_s),
             end_ts=mtime,
             duration_s=duration_s,
-            source_type="ftp",
+            source_backend="ftp",
         )
 
     def _resolve_env(self, name: str | None) -> str | None:

homesec/sources/local_folder.py

@@ -12,14 +12,39 @@ from datetime import datetime, timedelta
 from pathlib import Path
 
 from anyio import Path as AsyncPath
+from pydantic import BaseModel, Field
 
 from homesec.models.clip import Clip
-from homesec.models.source.local_folder import LocalFolderSourceConfig
 from homesec.sources.base import AsyncClipSource
 
 logger = logging.getLogger(__name__)
 
 
+class LocalFolderSourceConfig(BaseModel):
+    """Local folder source configuration."""
+
+    model_config = {"extra": "forbid"}
+
+    camera_name: str | None = Field(
+        default=None,
+        description="Optional human-friendly camera name.",
+    )
+    watch_dir: str = Field(
+        default="recordings",
+        description="Directory to watch for new clips.",
+    )
+    poll_interval: float = Field(
+        default=1.0,
+        ge=0.0,
+        description="Polling interval in seconds.",
+    )
+    stability_threshold_s: float = Field(
+        default=3.0,
+        ge=0.0,
+        description="Seconds to wait for file size to stabilize before accepting a clip.",
+    )
+
+
 class LocalFolderSource(AsyncClipSource):
     """Watches a local folder for new video clips.
 
@@ -215,5 +240,5 @@ class LocalFolderSource(AsyncClipSource):
             start_ts=mtime_dt - timedelta(seconds=duration_s),
             end_ts=mtime_dt,
             duration_s=duration_s,
-            source_type="local_folder",
+            source_backend="local_folder",
         )