Clean Architecture Principles

from dataclasses import dataclass, field
from typing import Optional, List
import re
from domain.models.actor import Actor

@dataclass
class Movie:
    """
    Modelo de dominio que representa una película y valida su propia integridad.
    """
    id: Optional[int]
    imdb_id: str
    title: str
    year: int
    rating: float
    duration_minutes: Optional[int]
    metascore: Optional[int]
    actors: List[Actor] = field(default_factory=list)

    def __post_init__(self):
        """Realiza validaciones en los datos después de que el objeto es creado."""
        # Limpieza de datos
        self.title = self.title.strip()
        self.imdb_id = self.imdb_id.strip()

        # Reglas de validación
        if not re.match(r"^tt\d{7,}$", self.imdb_id):
            raise ValueError(f"IMDb ID inválido: '{self.imdb_id}'")
        if not self.title:
            raise ValueError("El título no puede estar vacío.")
        if not (1888 <= self.year <= 2030):
            raise ValueError(f"Año inválido: {self.year}")
        if not (0.0 <= self.rating <= 10.0):
            raise ValueError(f"Rating inválido: {self.rating}")

from abc import ABC, abstractmethod
from typing import Optional
from domain.models.movie import Movie

class MovieRepository(ABC):
    """
    Interfaz de repositorio para la entidad Movie.
    Define el contrato que deben cumplir las implementaciones.
    """

    @abstractmethod
    def save(self, movie: Movie) -> Movie:
        """Guarda una película y retorna la entidad guardada."""
        pass

    @abstractmethod
    def find_by_imdb_id(self, imdb_id: str) -> Optional[Movie]:
        """Busca una película por su ID de IMDb."""
        pass

from abc import ABC, abstractmethod
from typing import List
from domain.models.movie import Movie

class ScraperInterface(ABC):
    """
    Interfaz base para scrapers de películas.
    """

    @abstractmethod
    def scrape(self) -> List[Movie]:
        """Ejecuta el proceso de scraping."""
        pass

from concurrent.futures import ThreadPoolExecutor
from typing import List
from domain.models.movie import Movie
from domain.interfaces.use_case_interface import UseCaseInterface

class CompositeSaveMovieWithActorsUseCase(UseCaseInterface):
    """
    Caso de uso compuesto que orquesta múltiples casos de uso
    de forma concurrente.
    """

    def __init__(self, use_cases: List[UseCaseInterface]):
        self.use_cases = use_cases
        self.max_workers = len(use_cases)

    def execute(self, movie: Movie) -> None:
        """Ejecuta todos los casos de uso en paralelo."""
        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            list(executor.map(lambda uc: uc.execute(movie), self.use_cases))

from domain.repositories.movie_repository import MovieRepository
from domain.models.movie import Movie
import csv

class MovieCsvRepository(MovieRepository):
    """Implementación concreta del repositorio usando CSV."""
    
    def save(self, movie: Movie) -> Movie:
        # Implementation details...
        pass
    
    def find_by_imdb_id(self, imdb_id: str) -> Optional[Movie]:
        # Implementation details...
        pass

from domain.repositories.movie_repository import MovieRepository
from domain.models.movie import Movie

class MoviePostgresRepository(MovieRepository):
    """Implementación concreta del repositorio usando PostgreSQL."""
    
    def __init__(self, connection):
        self.connection = connection
    
    def save(self, movie: Movie) -> Movie:
        # SQL implementation...
        pass
    
    def find_by_imdb_id(self, imdb_id: str) -> Optional[Movie]:
        # SQL implementation...
        pass

from infrastructure.factory.dependency_container import DependencyContainer
from shared.config import config
import logging

logger = logging.getLogger(__name__)

def main():
    logger.info("Inicializando contenedor de dependencias...")
    container = DependencyContainer(config)
    
    try:
        logger.info("Construyendo scraper...")
        scraper = container.get_scraper()
        
        logger.info("Iniciando proceso de scraping...")
        scraper.scrape()
        logger.info("Proceso de scraping finalizado exitosamente.")

    except Exception as e:
        logger.critical(f"Error fatal: {e}", exc_info=True)
    finally:
        logger.info("Cerrando recursos...")
        container.close_db_connection()

if __name__ == "__main__":
    main()