spatelier 0.3.0__py3-none-any.whl

core/service_factory.py

@@ -0,0 +1,295 @@
+"""
+Consolidated service factory for dependency injection.
+
+This module provides a single factory for creating and managing all services,
+eliminating duplication and ensuring consistent service lifecycle management.
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy.orm import Session
+
+from core.config import Config
+from core.database_service import DatabaseServiceFactory, RepositoryContainer
+from core.interfaces import (
+    IDatabaseService,
+    IMetadataService,
+    IPlaylistService,
+    IRepositoryContainer,
+    IServiceFactory,
+    ITranscriptionService,
+    IVideoDownloadService,
+)
+from core.logger import get_logger
+
+if TYPE_CHECKING:
+    from core.job_queue import JobQueue
+
+
+class ServiceFactory(IServiceFactory):
+    """
+    Consolidated factory for creating and managing all services.
+
+    Supports context manager usage and lazy-loaded service properties.
+    Replaces ServiceContainer with a cleaner, more direct approach.
+    """
+
+    def __init__(self, config: Config, verbose: bool = False):
+        """
+        Initialize service factory.
+
+        Args:
+            config: Configuration instance
+            verbose: Enable verbose logging
+        """
+        self.config = config
+        self.verbose = verbose
+        self.logger = get_logger("ServiceFactory", verbose=verbose)
+
+        # Services will be created lazily
+        self._database_service: Optional[IDatabaseService] = None
+        self._repositories: Optional[IRepositoryContainer] = None
+        self._video_download_service: Optional[IVideoDownloadService] = None
+        self._metadata_service: Optional[IMetadataService] = None
+        self._transcription_service: Optional[ITranscriptionService] = None
+        self._playlist_service: Optional[IPlaylistService] = None
+        self._job_queue: Optional["JobQueue"] = None
+
+    def create_database_service(
+        self, config: Optional[Config] = None, verbose: Optional[bool] = None
+    ) -> IDatabaseService:
+        """
+        Create database service.
+
+        Args:
+            config: Optional config override (defaults to instance config)
+            verbose: Optional verbose override (defaults to instance verbose)
+        """
+        if self._database_service is None:
+            use_config = config if config is not None else self.config
+            use_verbose = verbose if verbose is not None else self.verbose
+            self._database_service = DatabaseServiceFactory(
+                use_config, verbose=use_verbose
+            )
+        return self._database_service
+
+    def create_video_download_service(
+        self, config: Optional[Config] = None, verbose: Optional[bool] = None
+    ) -> IVideoDownloadService:
+        """
+        Create video download service.
+
+        Args:
+            config: Optional config override (defaults to instance config)
+            verbose: Optional verbose override (defaults to instance verbose)
+        """
+        if self._video_download_service is None:
+            use_config = config if config is not None else self.config
+            use_verbose = verbose if verbose is not None else self.verbose
+            # Get database service for dependency injection
+            db_service = self.create_database_service(use_config, use_verbose)
+            # Import here to avoid circular imports
+            from modules.video.services import VideoDownloadService
+
+            self._video_download_service = VideoDownloadService(
+                use_config, verbose=use_verbose, db_service=db_service
+            )
+        return self._video_download_service
+
+    def create_metadata_service(
+        self, config: Optional[Config] = None, verbose: Optional[bool] = None
+    ) -> IMetadataService:
+        """
+        Create metadata service.
+
+        Args:
+            config: Optional config override (defaults to instance config)
+            verbose: Optional verbose override (defaults to instance verbose)
+        """
+        if self._metadata_service is None:
+            use_config = config if config is not None else self.config
+            use_verbose = verbose if verbose is not None else self.verbose
+            # Get database service for dependency injection
+            db_service = self.create_database_service(use_config, use_verbose)
+            # Import here to avoid circular imports
+            from modules.video.services import MetadataService
+
+            self._metadata_service = MetadataService(
+                use_config, verbose=use_verbose, db_service=db_service
+            )
+        return self._metadata_service
+
+    def create_transcription_service(
+        self, config: Optional[Config] = None, verbose: Optional[bool] = None
+    ) -> ITranscriptionService:
+        """
+        Create transcription service.
+
+        Args:
+            config: Optional config override (defaults to instance config)
+            verbose: Optional verbose override (defaults to instance verbose)
+        """
+        if self._transcription_service is None:
+            use_config = config if config is not None else self.config
+            use_verbose = verbose if verbose is not None else self.verbose
+            # Get database service for dependency injection
+            db_service = self.create_database_service(use_config, use_verbose)
+            # Import here to avoid circular imports
+            from modules.video.services.transcription_service import (
+                TranscriptionService,
+            )
+
+            self._transcription_service = TranscriptionService(
+                use_config, verbose=use_verbose, db_service=db_service
+            )
+        return self._transcription_service
+
+    def create_playlist_service(
+        self, config: Optional[Config] = None, verbose: Optional[bool] = None
+    ) -> IPlaylistService:
+        """
+        Create playlist service.
+
+        Args:
+            config: Optional config override (defaults to instance config)
+            verbose: Optional verbose override (defaults to instance verbose)
+        """
+        if self._playlist_service is None:
+            use_config = config if config is not None else self.config
+            use_verbose = verbose if verbose is not None else self.verbose
+            # Get database service for dependency injection
+            db_service = self.create_database_service(use_config, use_verbose)
+            # Import here to avoid circular imports
+            from modules.video.services import PlaylistService
+
+            self._playlist_service = PlaylistService(
+                use_config, verbose=use_verbose, db_service=db_service
+            )
+        return self._playlist_service
+
+    # Property-based access for convenience (replaces ServiceContainer properties)
+    @property
+    def database(self) -> IDatabaseService:
+        """Get database service (lazy-loaded)."""
+        return self.create_database_service()
+
+    @property
+    def repositories(self) -> IRepositoryContainer:
+        """Get repository container (lazy-loaded, initializes database)."""
+        if self._repositories is None:
+            self._repositories = self.database.initialize()
+        return self._repositories
+
+    @property
+    def video_download(self) -> IVideoDownloadService:
+        """Get video download service (lazy-loaded)."""
+        return self.create_video_download_service()
+
+    @property
+    def metadata(self) -> IMetadataService:
+        """Get metadata service (lazy-loaded)."""
+        return self.create_metadata_service()
+
+    @property
+    def transcription(self) -> ITranscriptionService:
+        """Get transcription service (lazy-loaded)."""
+        return self.create_transcription_service()
+
+    @property
+    def playlist(self) -> IPlaylistService:
+        """Get playlist service (lazy-loaded)."""
+        return self.create_playlist_service()
+
+    @property
+    def job_queue(self) -> "JobQueue":
+        """Get job queue (lazy-loaded)."""
+        if self._job_queue is None:
+            from core.job_queue import JobQueue
+
+            self._job_queue = JobQueue(self.config, self.verbose)
+        return self._job_queue
+
+    def initialize_database(self) -> IRepositoryContainer:
+        """
+        Initialize database and return repositories.
+
+        Returns:
+            RepositoryContainer with all repositories
+        """
+        return self.repositories
+
+    def close_all_services(self):
+        """Close all services and connections."""
+        if self._database_service:
+            self._database_service.close_connections()
+
+        # Reset all services
+        self._database_service = None
+        self._repositories = None
+        self._video_download_service = None
+        self._metadata_service = None
+        self._transcription_service = None
+        self._playlist_service = None
+        self._job_queue = None
+
+    def get_database_service(self) -> Optional[IDatabaseService]:
+        """Get existing database service."""
+        return self._database_service
+
+    def get_video_download_service(self) -> Optional[IVideoDownloadService]:
+        """Get existing video download service."""
+        return self._video_download_service
+
+    def get_metadata_service(self) -> Optional[IMetadataService]:
+        """Get existing metadata service."""
+        return self._metadata_service
+
+    def get_transcription_service(self) -> Optional[ITranscriptionService]:
+        """Get existing transcription service."""
+        return self._transcription_service
+
+    def get_playlist_service(self) -> Optional[IPlaylistService]:
+        """Get existing playlist service."""
+        return self._playlist_service
+
+    def reset_services(self):
+        """Reset all services (useful for testing)."""
+        self.close_all_services()
+
+    # Context manager support
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close_all_services()
+
+
+# Legacy global factory support (for backward compatibility during transition)
+# Note: This is deprecated and will be removed. Use ServiceFactory(config, verbose) directly.
+_service_factory: Optional[ServiceFactory] = None
+
+
+def get_service_factory() -> ServiceFactory:
+    """
+    Get global service factory instance.
+
+    DEPRECATED: Use ServiceFactory(config, verbose) directly instead.
+    This function exists only for backward compatibility during transition.
+    """
+    global _service_factory
+    if _service_factory is None:
+        # Create with default config - this is not ideal but maintains compatibility
+        _service_factory = ServiceFactory(Config(), verbose=False)
+    return _service_factory
+
+
+def reset_service_factory():
+    """
+    Reset global service factory (useful for testing).
+
+    DEPRECATED: Use ServiceFactory(config, verbose) directly instead.
+    """
+    global _service_factory
+    _service_factory = None

core/streaming.py

@@ -0,0 +1,299 @@
+"""
+Streaming video processing utilities.
+
+This module provides streaming capabilities for processing large video files
+without loading them entirely into memory.
+"""
+
+import json
+import os
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterator, Optional
+
+import ffmpeg
+
+from core.logger import get_logger
+from core.progress import track_progress
+
+
+class VideoStreamProcessor:
+    """Stream-based video processor for large files."""
+
+    def __init__(self, config, verbose: bool = False):
+        """
+        Initialize streaming video processor.
+
+        Args:
+            config: Configuration instance
+            verbose: Enable verbose logging
+        """
+        self.config = config
+        self.verbose = verbose
+        self.logger = get_logger("VideoStreamProcessor", verbose=verbose)
+
+    def get_video_info(self, video_path: Path) -> Dict[str, Any]:
+        """
+        Get video information using ffmpeg-python without loading the entire file.
+
+        Args:
+            video_path: Path to video file
+
+        Returns:
+            Dictionary with video metadata
+        """
+        try:
+            probe = ffmpeg.probe(str(video_path))
+            return probe
+
+        except ffmpeg.Error as e:
+            self.logger.error(f"FFmpeg probe failed: {e}")
+            raise RuntimeError(f"Failed to probe video: {e}")
+        except Exception as e:
+            self.logger.error(f"Failed to get video info: {e}")
+            raise
+
+    def stream_video_segments(
+        self, video_path: Path, segment_duration: int = 60
+    ) -> Iterator[Path]:
+        """
+        Stream video in segments for processing.
+
+        Args:
+            video_path: Path to video file
+            segment_duration: Duration of each segment in seconds
+
+        Yields:
+            Path to temporary segment files
+        """
+        temp_dir = Path(tempfile.mkdtemp(prefix="spatelier_segments_"))
+
+        try:
+            # Get video duration
+            info = self.get_video_info(video_path)
+            duration = float(info["format"]["duration"])
+
+            self.logger.info(
+                f"Streaming video: {duration:.1f}s total, {segment_duration}s segments"
+            )
+
+            segment_count = int(duration // segment_duration) + 1
+
+            with track_progress(
+                f"Creating {segment_count} video segments", total=segment_count
+            ) as progress:
+                for i in range(segment_count):
+                    start_time = i * segment_duration
+                    segment_path = temp_dir / f"segment_{i:03d}.mp4"
+
+                    try:
+                        # Extract segment using ffmpeg-python
+                        (
+                            ffmpeg.input(
+                                str(video_path), ss=start_time, t=segment_duration
+                            )
+                            .output(
+                                str(segment_path),
+                                c="copy",
+                                avoid_negative_ts="make_zero",
+                            )
+                            .overwrite_output()
+                            .run(quiet=True)
+                        )
+
+                        progress.update(1, f"Created segment {i + 1}/{segment_count}")
+                        yield segment_path
+
+                    except ffmpeg.Error as e:
+                        self.logger.warning(f"Failed to create segment {i}: {e}")
+                        continue
+
+        except Exception as e:
+            self.logger.error(f"Streaming failed: {e}")
+            # Cleanup on error
+            self._cleanup_temp_dir(temp_dir)
+            raise
+
+    def process_video_stream(
+        self,
+        video_path: Path,
+        processor_func: Callable[[Path], Any],
+        segment_duration: int = 60,
+    ) -> Iterator[Any]:
+        """
+        Process video in streaming fashion.
+
+        Args:
+            video_path: Path to video file
+            processor_func: Function to process each segment
+            segment_duration: Duration of each segment in seconds
+
+        Yields:
+            Results from processing each segment
+        """
+        try:
+            for segment_path in self.stream_video_segments(
+                video_path, segment_duration
+            ):
+                try:
+                    result = processor_func(segment_path)
+                    yield result
+                except Exception as e:
+                    self.logger.error(f"Failed to process segment {segment_path}: {e}")
+                    yield None
+                finally:
+                    # Clean up segment file
+                    if segment_path.exists():
+                        segment_path.unlink()
+
+        except Exception as e:
+            self.logger.error(f"Stream processing failed: {e}")
+            raise
+
+    def _cleanup_temp_dir(self, temp_dir: Path):
+        """Clean up temporary directory."""
+        try:
+            import shutil
+
+            if temp_dir.exists():
+                shutil.rmtree(temp_dir)
+        except Exception as e:
+            self.logger.warning(f"Failed to cleanup temp dir {temp_dir}: {e}")
+
+
+class AudioStreamProcessor:
+    """Stream-based audio processor for large files."""
+
+    def __init__(self, config, verbose: bool = False):
+        """
+        Initialize streaming audio processor.
+
+        Args:
+            config: Configuration instance
+            verbose: Enable verbose logging
+        """
+        self.config = config
+        self.verbose = verbose
+        self.logger = get_logger("AudioStreamProcessor", verbose=verbose)
+
+    def stream_audio_chunks(
+        self, audio_path: Path, chunk_duration: int = 30
+    ) -> Iterator[Path]:
+        """
+        Stream audio in chunks for processing.
+
+        Args:
+            audio_path: Path to audio file
+            chunk_duration: Duration of each chunk in seconds
+
+        Yields:
+            Path to temporary chunk files
+        """
+        temp_dir = Path(tempfile.mkdtemp(prefix="spatelier_audio_chunks_"))
+
+        try:
+            # Get audio duration using ffmpeg-python
+            info = ffmpeg.probe(str(audio_path))
+            duration = float(info["format"]["duration"])
+
+            self.logger.info(
+                f"Streaming audio: {duration:.1f}s total, {chunk_duration}s chunks"
+            )
+
+            chunk_count = int(duration // chunk_duration) + 1
+
+            with track_progress(
+                f"Creating {chunk_count} audio chunks", total=chunk_count
+            ) as progress:
+                for i in range(chunk_count):
+                    start_time = i * chunk_duration
+                    chunk_path = temp_dir / f"chunk_{i:03d}.wav"
+
+                    try:
+                        # Extract chunk using ffmpeg-python
+                        (
+                            ffmpeg.input(
+                                str(audio_path), ss=start_time, t=chunk_duration
+                            )
+                            .output(str(chunk_path), acodec="pcm_s16le")
+                            .overwrite_output()
+                            .run(quiet=True)
+                        )
+
+                        progress.update(1, f"Created chunk {i + 1}/{chunk_count}")
+                        yield chunk_path
+
+                    except ffmpeg.Error as e:
+                        self.logger.warning(f"Failed to create chunk {i}: {e}")
+                        continue
+
+        except Exception as e:
+            self.logger.error(f"Audio streaming failed: {e}")
+            # Cleanup on error
+            self._cleanup_temp_dir(temp_dir)
+            raise
+
+    def _cleanup_temp_dir(self, temp_dir: Path):
+        """Clean up temporary directory."""
+        try:
+            import shutil
+
+            if temp_dir.exists():
+                shutil.rmtree(temp_dir)
+        except Exception as e:
+            self.logger.warning(f"Failed to cleanup temp dir {temp_dir}: {e}")
+
+
+@contextmanager
+def stream_video_processing(video_path: Path, segment_duration: int = 60):
+    """
+    Context manager for streaming video processing.
+
+    Args:
+        video_path: Path to video file
+        segment_duration: Duration of each segment in seconds
+
+    Usage:
+        with stream_video_processing(video_path) as processor:
+            for segment in processor.segments:
+                # Process segment
+                result = process_segment(segment)
+    """
+    from core.config import Config
+
+    config = Config()
+    processor = VideoStreamProcessor(config)
+
+    try:
+        yield processor
+    finally:
+        # Cleanup is handled by the processor
+        pass
+
+
+@contextmanager
+def stream_audio_processing(audio_path: Path, chunk_duration: int = 30):
+    """
+    Context manager for streaming audio processing.
+
+    Args:
+        audio_path: Path to audio file
+        chunk_duration: Duration of each chunk in seconds
+
+    Usage:
+        with stream_audio_processing(audio_path) as processor:
+            for chunk in processor.chunks:
+                # Process chunk
+                result = process_chunk(chunk)
+    """
+    from core.config import Config
+
+    config = Config()
+    processor = AudioStreamProcessor(config)
+
+    try:
+        yield processor
+    finally:
+        # Cleanup is handled by the processor
+        pass