homesec 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

homesec/repository/clip_repository.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, TypeVar
 
 from homesec.models.clip import Clip, ClipStateData
 from homesec.models.config import RetryConfig
+from homesec.models.enums import ClipStatus, RiskLevelField
 from homesec.models.events import (
     AlertDecisionMadeEvent,
     ClipDeletedEvent,
@@ -63,7 +64,7 @@ class ClipRepository:
         """Create initial state + record clip received event."""
         state = ClipStateData(
             camera_name=clip.camera_name,
-            status="queued_local",
+            status=ClipStatus.QUEUED_LOCAL,
             local_path=str(clip.local_path),
         )
 
@@ -105,8 +106,13 @@ class ClipRepository:
 
         state.storage_uri = storage_uri
         state.view_url = view_url
-        if state.status not in ("analyzed", "done", "error", "deleted"):
-            state.status = "uploaded"
+        if state.status not in (
+            ClipStatus.ANALYZED,
+            ClipStatus.DONE,
+            ClipStatus.ERROR,
+            ClipStatus.DELETED,
+        ):
+            state.status = ClipStatus.UPLOADED
 
         event = UploadCompletedEvent(
             clip_id=clip_id,
@@ -208,8 +214,8 @@ class ClipRepository:
         if state is None:
             return None
 
-        if state.status != "deleted":
-            state.status = "error"
+        if state.status != ClipStatus.DELETED:
+            state.status = ClipStatus.ERROR
         await self._safe_upsert(clip_id, state)
         return state
 
@@ -238,8 +244,8 @@ class ClipRepository:
             return None
 
         state.analysis_result = result
-        if state.status != "deleted":
-            state.status = "analyzed"
+        if state.status != ClipStatus.DELETED:
+            state.status = ClipStatus.ANALYZED
 
         event = VLMCompletedEvent(
             clip_id=clip_id,
@@ -294,7 +300,7 @@ class ClipRepository:
         clip_id: str,
         decision: AlertDecision,
         detected_classes: list[str] | None,
-        vlm_risk: str | None,
+        vlm_risk: RiskLevelField | None,
     ) -> ClipStateData | None:
         """Record alert decision + update state."""
         state = await self._load_state(clip_id, action="alert decision")
@@ -328,8 +334,8 @@ class ClipRepository:
         if state is None:
             return None
 
-        if state.status != "deleted":
-            state.status = "done"
+        if state.status != ClipStatus.DELETED:
+            state.status = ClipStatus.DONE
 
         event = NotificationSentEvent(
             clip_id=clip_id,
@@ -380,7 +386,7 @@ class ClipRepository:
         if state is None:
             return None
 
-        state.status = "deleted"
+        state.status = ClipStatus.DELETED
 
         event = ClipDeletedEvent(
             clip_id=clip_id,
@@ -411,7 +417,7 @@ class ClipRepository:
         state = await self._load_state(clip_id, action="clip recheck")
         if state is None:
             return None
-        if state.status == "deleted":
+        if state.status == ClipStatus.DELETED:
             return state
 
         state.filter_result = result
@@ -464,10 +470,10 @@ class ClipRepository:
         if state is None:
             return None
 
-        if state.status in ("done", "deleted"):
+        if state.status in (ClipStatus.DONE, ClipStatus.DELETED):
             return state
 
-        state.status = "done"
+        state.status = ClipStatus.DONE
         await self._safe_upsert(clip_id, state)
         return state
 

homesec/sources/base.py

@@ -23,6 +23,7 @@ class ThreadedClipSource(ClipSource, ABC):
         self._thread: Thread | None = None
         self._stop_event = Event()
         self._last_heartbeat = time.monotonic()
+        self._started = False
 
     def register_callback(self, callback: Callable[[Clip], None]) -> None:
         """Register callback to be invoked when a new clip is ready."""
@@ -34,6 +35,7 @@ class ThreadedClipSource(ClipSource, ABC):
             logger.warning("%s already started", self.__class__.__name__)
             return
 
+        self._started = True
         self._stop_event.clear()
         self._on_start()
         self._thread = Thread(target=self._run_wrapper, daemon=True)
@@ -68,12 +70,21 @@ class ThreadedClipSource(ClipSource, ABC):
         """Return monotonic timestamp of last heartbeat update."""
         return self._last_heartbeat
 
+    async def ping(self) -> bool:
+        """Health check - verify source is operational.
+
+        Returns True if:
+        - Source not started yet (ready to start)
+        - Background thread is alive
+        """
+        return self._thread_is_healthy()
+
     def _touch_heartbeat(self) -> None:
         self._last_heartbeat = time.monotonic()
 
     def _thread_is_healthy(self) -> bool:
         if self._thread is None:
-            return True
+            return not self._started
         return self._thread.is_alive()
 
     def _emit_clip(self, clip: Clip) -> None:
@@ -126,6 +137,7 @@ class AsyncClipSource(ClipSource, ABC):
         self._task: asyncio.Task[None] | None = None
         self._stop_event = asyncio.Event()
         self._last_heartbeat = time.monotonic()
+        self._started = False
 
     def register_callback(self, callback: Callable[[Clip], None]) -> None:
         """Register callback to be invoked when a new clip is ready."""
@@ -137,6 +149,7 @@ class AsyncClipSource(ClipSource, ABC):
             logger.warning("%s already started", self.__class__.__name__)
             return
 
+        self._started = True
         self._stop_event.clear()
         self._on_start()
         self._task = asyncio.create_task(self._run_wrapper())
@@ -174,12 +187,21 @@ class AsyncClipSource(ClipSource, ABC):
         """Return timestamp (monotonic) of last successful operation."""
         return self._last_heartbeat
 
+    async def ping(self) -> bool:
+        """Health check - verify source is operational.
+
+        Returns True if:
+        - Source not started yet (ready to start)
+        - Background task is running
+        """
+        return self._task_is_healthy()
+
     def _touch_heartbeat(self) -> None:
         self._last_heartbeat = time.monotonic()
 
     def _task_is_healthy(self) -> bool:
         if self._task is None:
-            return True
+            return not self._started
         return not self._task.done()
 
     def _emit_clip(self, clip: Clip) -> None:

homesec/sources/local_folder.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
 import time
 from collections import OrderedDict
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 from anyio import Path as AsyncPath
 
@@ -17,9 +17,6 @@ from homesec.models.clip import Clip
 from homesec.models.source import LocalFolderSourceConfig
 from homesec.sources.base import AsyncClipSource
 
-if TYPE_CHECKING:
-    from homesec.interfaces import StateStore
-
 logger = logging.getLogger(__name__)
 
 
@@ -34,38 +31,38 @@ class LocalFolderSource(AsyncClipSource):
     def __init__(
         self,
         config: LocalFolderSourceConfig,
-        camera_name: str = "local",
-        state_store: StateStore | None = None,
+        camera_name: str | None = None,
     ) -> None:
         """Initialize folder watcher.
 
         Args:
             config: LocalFolder source configuration
-            camera_name: Name of the camera (used in Clip objects)
-            state_store: Optional state store for deduplication via clip_states table.
-                If None, falls back to in-memory cache only (may reprocess files after restart).
+            camera_name: Name of the camera (overrides config.camera_name).
         """
         super().__init__()
         self.watch_dir = Path(config.watch_dir)
-        self.camera_name = camera_name
+        # Use config's camera_name if not explicitly passed, else default to "local"
+        self.camera_name = camera_name or config.camera_name or "local"
         self.poll_interval = float(config.poll_interval)
         self.stability_threshold_s = float(config.stability_threshold_s)
-        self._state_store = state_store
 
         # Ensure watch dir exists
         self.watch_dir.mkdir(parents=True, exist_ok=True)
 
-        # Bounded in-memory cache for performance (avoid DB query on every scan)
-        # 10,000 files ≈ 100 days for 1 camera @ 100 clips/day (≈500 KB memory)
-        # When limit exceeded, oldest half are removed (FIFO eviction)
-        # This is just an optimization - clip_states table is source of truth
+        # Local State Manifest (replaces StateStore dependency)
+        # This file tracks which clips have been processed to avoid re-emitting on restart.
+        self._state_file = self.watch_dir / ".homesec_state.json"
+        self._processed_files: set[str] = set()
+        self._load_local_state()
+
+        # Bounded in-memory cache for performance (avoid checking set on every scan)
         self._seen_files: OrderedDict[str, None] = OrderedDict()
         self._max_seen_files = 10000
 
         logger.info(
-            "LocalFolderSource initialized: watch_dir=%s, has_state_store=%s",
+            "LocalFolderSource initialized: watch_dir=%s, camera_name=%s",
             self.watch_dir,
-            state_store is not None,
+            self.camera_name,
         )
 
     def register_callback(self, callback: Callable[[Clip], None]) -> None:
@@ -74,12 +71,7 @@ class LocalFolderSource(AsyncClipSource):
         logger.debug("Callback registered for %s", self.camera_name)
 
     def is_healthy(self) -> bool:
-        """Check if source is healthy.
-
-        Returns True if:
-        - Watch directory exists and is readable
-        - Watch task is alive (if started)
-        """
+        """Check if source is healthy."""
         if not self.watch_dir.exists():
             return False
 
@@ -101,12 +93,34 @@ class LocalFolderSource(AsyncClipSource):
     def _on_stopped(self) -> None:
         logger.info("LocalFolderSource stopped")
 
-    async def _run(self) -> None:
-        """Background task that polls for new files.
+    def _load_local_state(self) -> None:
+        """Load processed files from local JSON manifest."""
+        if not self._state_file.exists():
+            return
+        try:
+            with open(self._state_file) as f:
+                data = json.load(f)
+                if isinstance(data, list):
+                    self._processed_files = set(data)
+                elif isinstance(data, dict) and "processed_files" in data:
+                    self._processed_files = set(data["processed_files"])
+            logger.info("Loaded %d processed files from local state", len(self._processed_files))
+        except Exception as e:
+            logger.warning("Failed to load local state file: %s", e)
 
-        Uses anyio.Path for non-blocking filesystem operations to avoid
-        stalling the event loop on slow/network filesystems.
-        """
+    def _save_local_state(self) -> None:
+        """Save processed files to local JSON manifest."""
+        # Simple atomic write
+        try:
+            temp_file = self._state_file.with_suffix(".tmp")
+            with open(temp_file, "w") as f:
+                json.dump({"processed_files": list(self._processed_files)}, f)
+            temp_file.replace(self._state_file)
+        except Exception as e:
+            logger.warning("Failed to save local state file: %s", e)
+
+    async def _run(self) -> None:
+        """Background task that polls for new files."""
         logger.info("Watch loop started")
 
         # Create async path wrapper for watch directory
@@ -117,13 +131,18 @@ class LocalFolderSource(AsyncClipSource):
                 # Update heartbeat
                 self._touch_heartbeat()
 
+                new_files_processed = False
+
                 # Scan for new .mp4 files (async to avoid blocking event loop)
                 async for async_file_path in async_watch_dir.glob("*.mp4"):
                     file_path = Path(async_file_path)  # Convert to regular Path for Clip
                     file_id = str(file_path)
                     clip_id = file_path.stem
 
-                    # Check in-memory cache first (fast path)
+                    # Check if already processed (Session cache OR Persistent Manifest)
+                    if clip_id in self._processed_files:
+                        continue
+
                     if file_id in self._seen_files:
                         continue
 
@@ -144,16 +163,10 @@ class LocalFolderSource(AsyncClipSource):
                         logger.warning("Failed to stat file %s: %s", file_path, e, exc_info=True)
                         continue
 
-                    # Check clip_states table (source of truth for deduplication)
-                    # This prevents reprocessing files even after cache eviction or restart
-                    if await self._has_clip_state(clip_id):
-                        # File was already processed - add to cache and skip
-                        self._add_to_cache(file_id)
-                        logger.debug("Skipping already-processed file: %s", file_path.name)
-                        continue
-
-                    # Mark as seen in cache
+                    # Mark as seen
+                    self._processed_files.add(clip_id)
                     self._add_to_cache(file_id)
+                    new_files_processed = True
 
                     # Create Clip object (reuse mtime from async stat to avoid blocking)
                     clip = self._create_clip(file_path, mtime=mtime)
@@ -162,6 +175,11 @@ class LocalFolderSource(AsyncClipSource):
                     logger.info("New clip detected: %s", file_path.name)
                     self._emit_clip(clip)
 
+                # Check for removed files to clean up manifest (OPTIONAL, maybe too expensive?)
+                # For now, let's just save if we added anything.
+                if new_files_processed:
+                    await asyncio.to_thread(self._save_local_state)
+
             except Exception as e:
                 logger.error("Error in watch loop: %s", e, exc_info=True)
 
@@ -183,50 +201,11 @@ class LocalFolderSource(AsyncClipSource):
                 self._seen_files.popitem(last=False)
             logger.debug("Evicted %d old entries from seen files cache", evict_count)
 
-    async def _has_clip_state(self, clip_id: str) -> bool:
-        """Check if clip_id exists in clip_states table.
-
-        Returns:
-            True if clip_state exists (any status including 'deleted'), False otherwise
-        """
-        if self._state_store is None:
-            return False
-
-        try:
-            # Direct async DB access - no threading complexity!
-            state = await asyncio.wait_for(
-                self._state_store.get(clip_id),
-                timeout=5.0,
-            )
-            return state is not None
-        except asyncio.TimeoutError:
-            logger.warning(
-                "DB query timeout for clip_states check: %s (assuming not seen)",
-                clip_id,
-            )
-            return False
-        except Exception as e:
-            logger.warning(
-                "Error checking clip_states for %s: %s (assuming not seen)",
-                clip_id,
-                e,
-                exc_info=True,
-            )
-            return False
-
     def _create_clip(self, file_path: Path, mtime: float) -> Clip:
-        """Create Clip object from file path.
-
-        Args:
-            file_path: Path to the video file
-            mtime: File modification timestamp (from async stat)
-
-        Estimates timestamps based on file modification time.
-        """
+        """Create Clip object from file path."""
         mtime_dt = datetime.fromtimestamp(mtime)
 
         # Estimate clip duration (assume 10s if we can't determine)
-        # In production, would parse from filename or video metadata
         duration_s = 10.0
 
         return Clip(

homesec/sources/rtsp.py

@@ -219,6 +219,7 @@ class RTSPSource(ThreadedClipSource):
         self.reconnect_backoff_s = float(config.reconnect_backoff_s)
         self.rtsp_connect_timeout_s = float(config.rtsp_connect_timeout_s)
         self.rtsp_io_timeout_s = float(config.rtsp_io_timeout_s)
+        self.ffmpeg_flags = list(config.ffmpeg_flags)
 
         if config.disable_hwaccel:
             logger.info("Hardware acceleration manually disabled")
@@ -551,9 +552,31 @@ class RTSPSource(ThreadedClipSource):
             "-f",
             "mp4",
             "-y",
-            str(output_file),
         ]
 
+        user_flags = self.ffmpeg_flags
+
+        # Naive check to see if user overrode defaults
+        # If user supplies ANY -loglevel, we don't add ours.
+        # If user supplies ANY -fflags, we don't add ours (to avoid concatenation complexity).
+        # This allows full user control.
+        has_loglevel = any(x == "-loglevel" for x in user_flags)
+        if not has_loglevel:
+            cmd.extend(["-loglevel", "warning"])
+
+        has_fflags = any(x == "-fflags" for x in user_flags)
+        if not has_fflags:
+            cmd.extend(["-fflags", "+genpts+igndts"])
+
+        has_fps_mode = any(x == "-fps_mode" or x == "-vsync" for x in user_flags)
+        if not has_fps_mode:
+            cmd.extend(["-vsync", "0"])
+
+        # Add user flags last so they can potentially override or add to the above
+        cmd.extend(user_flags)
+
+        cmd.extend([str(output_file)])
+
         safe_cmd = list(cmd)
         try:
             idx = safe_cmd.index("-i")
@@ -753,6 +776,7 @@ class RTSPSource(ThreadedClipSource):
 
         cmd = ["ffmpeg"]
 
+        # 1. Global Flags (Hardware Acceleration)
         if self.hwaccel_config.is_available and not self._hwaccel_failed:
             hwaccel = self.hwaccel_config.hwaccel
             if hwaccel is not None:
@@ -762,6 +786,23 @@ class RTSPSource(ThreadedClipSource):
         elif self._hwaccel_failed:
             logger.info("Hardware acceleration disabled due to previous failures")
 
+        # 2. Global Flags (Robustness & Logging)
+        user_flags = self.ffmpeg_flags
+
+        has_loglevel = any(x == "-loglevel" for x in user_flags)
+        if not has_loglevel:
+            cmd.extend(["-loglevel", "warning"])
+
+        has_fflags = any(x == "-fflags" for x in user_flags)
+        if not has_fflags:
+            cmd.extend(["-fflags", "+genpts+igndts"])
+
+        # Add all user flags to global scope.
+        # Users who want input-specific flags (before -i) must rely on ffmpeg parsing them correctly
+        # or we would need a more complex config structure.
+        # For now, most robustness flags (-re, -rtsp_transport, etc) work as global or are handled below.
+        cmd.extend(user_flags)
+
         base_input_args = [
             "-rtsp_transport",
             "tcp",
@@ -778,11 +819,10 @@ class RTSPSource(ThreadedClipSource):
         ]
 
         timeout_us_connect = str(int(max(0.1, self.rtsp_connect_timeout_s) * 1_000_000))
-        timeout_us_io = str(int(max(0.1, self.rtsp_io_timeout_s) * 1_000_000))
         attempts: list[tuple[str, list[str]]] = [
             (
-                "stimeout+rw_timeout",
-                ["-stimeout", timeout_us_connect, "-rw_timeout", timeout_us_io] + base_input_args,
+                "stimeout",
+                ["-stimeout", timeout_us_connect] + base_input_args,
             ),
             ("stimeout", ["-stimeout", timeout_us_connect] + base_input_args),
             ("no_timeouts", base_input_args),
@@ -790,6 +830,7 @@ class RTSPSource(ThreadedClipSource):
 
         process: subprocess.Popen[bytes] | None = None
         stderr_file: Any | None = None
+
         for label, extra_args in attempts:
             cmd_attempt = list(cmd) + extra_args
             logger.debug("Starting frame pipeline (%s), logging to: %s", label, stderr_log)

homesec/state/postgres.py

@@ -18,6 +18,7 @@ from sqlalchemy import (
     func,
     or_,
     select,
+    text,
 )
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.dialects.postgresql import insert as pg_insert
@@ -27,6 +28,7 @@ from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 from homesec.interfaces import EventStore, StateStore
 from homesec.models.clip import ClipStateData
+from homesec.models.enums import EventType
 from homesec.models.events import (
     AlertDecisionMadeEvent,
     ClipDeletedEvent,
@@ -52,23 +54,25 @@ from homesec.models.events import (
 
 logger = logging.getLogger(__name__)
 
+# Map EventType enum to event model classes
+# Using enum values ensures consistency with event models
 _EVENT_TYPE_MAP: dict[str, type[ClipEventModel]] = {
-    "clip_recorded": ClipRecordedEvent,
-    "clip_deleted": ClipDeletedEvent,
-    "clip_rechecked": ClipRecheckedEvent,
-    "upload_started": UploadStartedEvent,
-    "upload_completed": UploadCompletedEvent,
-    "upload_failed": UploadFailedEvent,
-    "filter_started": FilterStartedEvent,
-    "filter_completed": FilterCompletedEvent,
-    "filter_failed": FilterFailedEvent,
-    "vlm_started": VLMStartedEvent,
-    "vlm_completed": VLMCompletedEvent,
-    "vlm_failed": VLMFailedEvent,
-    "vlm_skipped": VLMSkippedEvent,
-    "alert_decision_made": AlertDecisionMadeEvent,
-    "notification_sent": NotificationSentEvent,
-    "notification_failed": NotificationFailedEvent,
+    EventType.CLIP_RECORDED: ClipRecordedEvent,
+    EventType.CLIP_DELETED: ClipDeletedEvent,
+    EventType.CLIP_RECHECKED: ClipRecheckedEvent,
+    EventType.UPLOAD_STARTED: UploadStartedEvent,
+    EventType.UPLOAD_COMPLETED: UploadCompletedEvent,
+    EventType.UPLOAD_FAILED: UploadFailedEvent,
+    EventType.FILTER_STARTED: FilterStartedEvent,
+    EventType.FILTER_COMPLETED: FilterCompletedEvent,
+    EventType.FILTER_FAILED: FilterFailedEvent,
+    EventType.VLM_STARTED: VLMStartedEvent,
+    EventType.VLM_COMPLETED: VLMCompletedEvent,
+    EventType.VLM_FAILED: VLMFailedEvent,
+    EventType.VLM_SKIPPED: VLMSkippedEvent,
+    EventType.ALERT_DECISION_MADE: AlertDecisionMadeEvent,
+    EventType.NOTIFICATION_SENT: NotificationSentEvent,
+    EventType.NOTIFICATION_FAILED: NotificationFailedEvent,
 }
 
 
@@ -338,7 +342,7 @@ class PostgresStateStore(StateStore):
         """Parse JSONB payload from SQLAlchemy into a dict."""
         return _parse_jsonb_payload(raw)
 
-    def create_event_store(self) -> PostgresEventStore | NoopEventStore:
+    def create_event_store(self) -> EventStore:
         """Create a Postgres-backed event store or a no-op fallback."""
         if self._engine is None:
             return NoopEventStore()
@@ -455,6 +459,19 @@ class PostgresEventStore(EventStore):
             logger.error("Failed to get events for %s: %s", clip_id, e, exc_info=e)
             return []
 
+    async def shutdown(self, timeout: float | None = None) -> None:
+        """Shutdown is handled by PostgresStateStore which owns the engine."""
+        _ = timeout
+
+    async def ping(self) -> bool:
+        """Health check - verify database is reachable."""
+        try:
+            async with self._engine.connect() as conn:
+                await conn.execute(text("SELECT 1"))
+            return True
+        except Exception:
+            return False
+
 
 class NoopEventStore(EventStore):
     """Event store that drops events (used when Postgres is unavailable)."""
@@ -469,6 +486,14 @@ class NoopEventStore(EventStore):
     ) -> list[ClipLifecycleEvent]:
         return []
 
+    async def shutdown(self, timeout: float | None = None) -> None:
+        """No resources to clean up."""
+        _ = timeout
+
+    async def ping(self) -> bool:
+        """Noop store is always 'unhealthy' - indicates no real backend."""
+        return False
+
 
 class NoopStateStore(StateStore):
     """State store that drops writes and returns no data."""
@@ -498,3 +523,7 @@ class NoopStateStore(StateStore):
 
     async def ping(self) -> bool:
         return False
+
+    def create_event_store(self) -> EventStore:
+        """Return NoopEventStore."""
+        return NoopEventStore()

{homesec-1.1.1.dist-info → homesec-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: homesec
-Version: 1.1.1
+Version: 1.2.0
 Summary: Pluggable async home security camera pipeline with detection, VLM analysis, and alerts.
 Project-URL: Homepage, https://github.com/lan17/homesec
 Project-URL: Source, https://github.com/lan17/homesec