Unit3DwebUp 0.0.14__py3-none-any.whl

models/media_info.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+# Based on the old code unit3dup 0.8.21
+import re, os
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any
+
+
+@dataclass(slots=True)
+class MediaFile:
+    """
+        Try to create a dataclass for the MediaInfo result
+        Many of these data need to be sent to the tracker
+    """
+    file_path: str
+    media_to_string: str | None = None
+    video_tracks: List[Dict] = field(default_factory=list)
+    audio_tracks: List[Dict] = field(default_factory=list)
+    general_track: Dict = field(default_factory=dict)
+
+    @property
+    def media_description(self) -> str:
+        return self.media_to_string
+
+    # --------- VIDEO ---------
+    @property
+    def codec_id(self) -> str:
+        return self.video_tracks[0].get("codec_id", "Unknown") if self.video_tracks else "Unknown"
+
+    @property
+    def video_width(self) -> str:
+        return self.video_tracks[0].get("width", "Unknown") if self.video_tracks else "Unknown"
+
+    @property
+    def video_height(self) -> Optional[str]:
+        return self.video_tracks[0].get("height") if self.video_tracks else None
+
+    @property
+    def video_scan_type(self) -> Optional[str]:
+        return self.video_tracks[0].get("scan_type") if self.video_tracks else None
+
+    @property
+    def video_aspect_ratio(self) -> str:
+        return self.video_tracks[0].get("display_aspect_ratio", "Unknown") if self.video_tracks else "Unknown"
+
+    @property
+    def video_frame_rate(self) -> str:
+        return self.video_tracks[0].get("frame_rate", "Unknown") if self.video_tracks else "Unknown"
+
+    @property
+    def video_bit_depth(self) -> str:
+        return self.video_tracks[0].get("bit_depth", "Unknown") if self.video_tracks else "Unknown"
+
+    @property
+    def video_format(self) -> str:
+        return self.video_tracks[0].get("format", "Unknown") if self.video_tracks else "Unknown"
+
+    # --------- AUDIO ---------
+    @property
+    def audio_codec_id(self) -> str:
+        return self.audio_tracks[0].get("codec_id", "Unknown") if self.audio_tracks else "Unknown"
+
+    @property
+    def audio_bit_rate(self) -> str:
+        return self.audio_tracks[0].get("bit_rate", "Unknown") if self.audio_tracks else "Unknown"
+
+    @property
+    def audio_channels(self) -> str:
+        return self.audio_tracks[0].get("channels", "Unknown") if self.audio_tracks else "Unknown"
+
+    @property
+    def audio_sampling_rate(self) -> str:
+        return self.audio_tracks[0].get("sampling_rate", "Unknown") if self.audio_tracks else "Unknown"
+
+    @property
+    def audio_format(self) -> str:
+        return self.audio_tracks[0].get("format", "Unknown") if self.audio_tracks else "Unknown"
+
+    @property
+    def audio_language(self) -> str:
+        return self.audio_tracks[0].get("language", "Unknown") if self.audio_tracks else "Unknown"
+
+    @property
+    def subtitle_tracks(self) -> List[Dict]:
+        return [t for t in self.video_tracks if t.get("track_type") == "Text"]
+
+    @property
+    def available_languages(self) -> list[Any | None] | list[str]:
+        langs = {
+            t.get("language")
+            for t in (self.audio_tracks + self.subtitle_tracks)
+            if t.get("language")
+        }
+        return list(langs) or ["not found"]
+
+    @property
+    def file_size(self) -> str:
+        return self.general_track.get("file_size", "Unknown")
+
+    @property
+    def is_interlaced(self) -> Optional[int]:
+        encoding = self.video_tracks[0].get("encoding_settings") if self.video_tracks else None
+        if not encoding:
+            return None
+        match = re.search(r"interlaced=(\d)", encoding)
+        return int(match.group(1)) if match else None
+
+    def generate_release_name(self, guess_title: str, resolution: str) -> Optional[str]:
+        if not self.video_tracks:
+            return None
+
+        video_format = self.video_tracks[0].get("format", "")
+        audio_format = self.audio_tracks[0].get("format", "")
+        _, ext = os.path.splitext(self.file_path)
+
+        return f"{guess_title}.web-dl.{video_format}.{resolution}.{audio_format}{ext}".lower()
+
+    def to_dict(self) -> Dict:
+        # Converto PosixPath to str
+        return {
+            "file_path": str(self.file_path),
+            "media_to_string": self.media_to_string,
+            "video_tracks": self.video_tracks,
+            "audio_tracks": self.audio_tracks,
+            "general_track": self.general_track,
+        }
+
+    @classmethod
+    # non son più necessarie le virgolette per le classi non ancora completamente costruite ad esempio in "MediaFile"
+    # basta importare annotations
+    def dict_to_mediafile(cls, data: Dict) -> MediaFile:
+        """
+        From dict to Mediafile
+        """
+        return cls(
+            file_path=data.get("file_path", ""),
+            media_to_string=data.get("media_to_string"),
+            video_tracks=data.get("video_tracks", []),
+            audio_tracks=data.get("audio_tracks", []),
+            general_track=data.get("general_track", {}),
+        )

models/movie.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+# Same as the old code unit3dup 0.8.21. Add annotations
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+from config.logger import get_logger
+from models.interfaces import MediaRepoInterface
+
+
+@dataclass(slots=True)
+class Title:
+    """
+         Dataclass for manage result from a TMDB search
+    """
+    iso_3166_1: str
+    title: str
+    type: str | None = None
+
+    @staticmethod
+    def from_data(data: dict[str, any]) -> Title | None:
+        try:
+            return Title(
+                iso_3166_1=data["iso_3166_1"],
+                title=data["title"],
+                type=data.get("type"),
+            )
+        except KeyError as e:
+            print(f"Missing key in Title data: {e}")
+            return None
+        except TypeError as e:
+            print(f"Type error in Title data: {e}")
+            return None
+
+
+@dataclass(slots=True)
+class AltTitle:
+    id: int
+    titles: list[Title]
+
+    @classmethod
+    def validate(cls, json_str: str) -> AltTitle:
+        data = json.loads(json_str)
+        id_ = data.get("id", 0)
+        titles_data = data.get("titles", [])
+        titles = [
+            Title.from_data(title_data)
+            for title_data in titles_data
+            if Title.from_data(title_data) is not None
+        ]
+        return cls(id=id_, titles=titles)
+
+
+@dataclass(slots=True)
+class Genre:
+    id: int
+    name: str
+
+
+@dataclass(slots=True)
+class ProductionCompany:
+    id: int
+    logo_path: str | None
+    name: str
+    origin_country: str
+
+
+@dataclass(slots=True)
+class ProductionCountry:
+    iso_3166_1: str
+    name: str
+
+
+@dataclass(slots=True)
+class SpokenLanguage:
+    english_name: str
+    iso_639_1: str
+    name: str
+
+
+@dataclass(slots=True)
+class MovieDetails(MediaRepoInterface):
+    adult: bool
+    backdrop_path: str | None
+    belongs_to_collection: str | None
+    budget: int
+    genres: list[Genre]
+    homepage: str
+    id: int
+    imdb_id: str
+    origin_country: list[str]
+    original_language: str
+    original_title: str
+    overview: str
+    popularity: float
+    poster_path: str | None
+    production_companies: list[ProductionCompany]
+    production_countries: list[ProductionCountry]
+    release_date: str
+    revenue: int
+    runtime: int
+    spoken_languages: list[SpokenLanguage]
+    status: str
+    tagline: str
+    title: str
+    video: bool
+    vote_average: float
+    vote_count: int
+
+    def get_title(self) -> str:
+        return self.title
+
+    def get_original(self) -> str:
+        return self.original_title
+
+    def get_date(self) -> str:
+        return self.release_date
+
+    def get_id(self) -> int:
+        return self.id
+
+    def get_translations(self) -> dict[str, str] | None:
+        pass
+
+    def get_imdb(self) -> str | None:
+        pass
+
+    def get_poster_path(self) -> str:
+        pass
+
+
+@dataclass(slots=True)
+class NowPlaying:
+    """
+    Represents Nowplaying attributes
+    """
+    adult: bool | None = None
+    backdrop_path: str | None = None
+    genre_ids: list[int] = field(default_factory=list)
+    id: int | None = None
+    original_language: str | None = None
+    original_title: str | None = None
+    overview: str | None = None
+    popularity: float | None = None
+    poster_path: str | None = None
+    release_date: str | None = None
+    title: str | None = None
+    video: bool | None = None
+    vote_average: float | None = None
+    vote_count: int | None = None
+
+    def __repr__(self):
+        """Returns a string """
+        return f"<Movie title={self.title} id={self.id}>"
+
+
+@dataclass(slots=True)
+class NowPlayingByCountry(NowPlaying):
+    """
+    Represents a combined movie object NowPlayIng by Country code
+    """
+    iso_3166_1: str | None = None
+    release_dates: list[dict[str, str]] = field(default_factory=list)
+
+    def __post_init__(self):
+        """Validate data """
+        if self.iso_3166_1 and (len(self.iso_3166_1) != 2 or not self.iso_3166_1.isalpha()):
+            self.iso_3166_1 = None
+
+    @staticmethod
+    def from_data(now_playing: NowPlaying, release_info: MovieReleaseInfo) -> NowPlayingByCountry:
+        """
+        Creates a NowPlayingByCountry instance from NowPlaying and MovieReleaseInfo instances
+        """
+        return NowPlayingByCountry(
+            adult=now_playing.adult,
+            backdrop_path=now_playing.backdrop_path,
+            genre_ids=now_playing.genre_ids,
+            id=now_playing.id,
+            original_language=now_playing.original_language,
+            original_title=now_playing.original_title,
+            overview=now_playing.overview,
+            popularity=now_playing.popularity,
+            poster_path=now_playing.poster_path,
+            release_date=now_playing.release_date,
+            title=now_playing.title,
+            video=now_playing.video,
+            vote_average=now_playing.vote_average,
+            vote_count=now_playing.vote_count,
+            iso_3166_1=release_info.iso_3166_1,
+            release_dates=release_info.release_dates,
+        )
+
+
+@dataclass(slots=True)
+class Movie(MediaRepoInterface):
+    """
+    A movie object for the search endpoint
+    """
+    adult: bool = False
+    backdrop_path: str = ''
+    genre_ids: list[int] = field(default_factory=list)
+    id: int = 0
+    original_language: str = ''
+    original_title: str = ''
+    overview: str = ''
+    popularity: float = 0.0
+    poster_path: str = ''
+    release_date: str = ''
+    title: str = ''
+    video: bool = False
+    vote_average: float = 0.0
+    vote_count: int = 0
+    softcore: str | None = None
+
+    def get_title(self) -> str:
+        return self.title
+
+    def get_original(self) -> str:
+        return self.original_title
+
+    def get_date(self) -> str:
+        return self.release_date
+
+    def get_id(self) -> int:
+        return self.id
+
+    def get_poster_path(self) -> str:
+        return self.poster_path
+
+    def get_imdb(self) -> str | None:
+        # Get remote ids (IMDB) only from tvdb
+        pass
+
+    def get_translations(self) -> list[str] | None:
+        # Get translations list only from tvdb
+        pass
+
+
+@dataclass(slots=True)
+class MovieReleaseInfo:
+    """
+    Represents release information for a movie in a specific country.
+    """
+
+    iso_3166_1: str | None = None
+    release_dates: list[dict[str, Any]] = field(default_factory=list)
+
+    def __repr__(self) -> str:
+        """
+        Returns the MovieReleaseInfo string
+        """
+        return f"<ReleaseInfo iso_3166_1={self.iso_3166_1}, release_dates={self.release_dates}>"
+
+    @classmethod
+    def validate(cls, data: dict) -> MovieReleaseInfo | None:
+        """
+        Validates the data; return None if it's invalid
+        """
+
+        iso_3166_1 = data.get("iso_3166_1")
+        release_dates = data.get("release_dates", {})
+        logger = get_logger(cls.__name__)
+
+        # Validate country code
+        if iso_3166_1 is not None:
+            if (
+                    not isinstance(iso_3166_1, str)
+                    or len(iso_3166_1) != 2
+                    or not iso_3166_1.isupper()
+            ):
+                logger.error(f"Invalid ISO 3166-1 code: {iso_3166_1}")
+                return None
+
+            # Validate release_dates
+        if not isinstance(release_dates, list):
+            logger.error("release_dates must be a list.")
+            return None
+
+        for item in release_dates:
+            if not isinstance(item, dict):
+                logger.error(f"Invalid item in release_dates list: {item}")
+                return None
+
+        return cls(iso_3166_1=iso_3166_1, release_dates=release_dates)

models/tv.py

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+
+# Same as the old code unit3dup 0.8.21
+from dataclasses import dataclass, field
+from models.interfaces import MediaRepoInterface
+
+
+@dataclass(slots=True)
+class Alternative:
+    iso_3166_1: str
+    title: str
+    type: str
+
+
+@dataclass(slots=True)
+class DataResponse:
+    id: int
+    results: list[Alternative]
+
+
+@dataclass(slots=True)
+class CreatedBy:
+    credit_id: str
+    gender: int
+    id: int
+    name: str
+    original_name: str
+    profile_path: str | None = None
+
+
+@dataclass(slots=True)
+class Genre:
+    id: int
+    name: str
+
+
+@dataclass(slots=True)
+class LastEpisodeToAir:
+    air_date: str
+    episode_number: int
+    episode_type: str
+    id: int
+    name: str
+    overview: str
+    production_code: str
+    runtime: int
+    season_number: int
+    show_id: int
+    vote_average: float
+    vote_count: int
+    still_path: str | None = None
+
+
+@dataclass(slots=True)
+class Network:
+    id: int
+    logo_path: str
+    name: str
+    origin_country: str
+
+
+@dataclass(slots=True)
+class ProductionCompany:
+    id: int
+    name: str
+    origin_country: str
+    logo_path: str | None = None
+
+
+@dataclass(slots=True)
+class ProductionCountry:
+    iso_3166_1: str
+    name: str
+
+
+@dataclass(slots=True)
+class Season:
+    episode_count: int
+    id: int
+    name: str
+    overview: str
+    season_number: int
+    vote_average: float
+    air_date: str | None = None
+    poster_path: str | None = None
+
+
+@dataclass(slots=True)
+class SpokenLanguage:
+    english_name: str
+    iso_639_1: str
+    name: str
+
+
+@dataclass(slots=True)
+class TVShowDetails(MediaRepoInterface):
+
+    adult: bool
+    first_air_date: str
+    homepage: str
+    id: int
+    in_production: bool
+    last_air_date: str
+    last_episode_to_air: LastEpisodeToAir
+    name: str
+    number_of_episodes: int
+    number_of_seasons: int
+    original_language: str
+    original_name: str
+    overview: str
+    popularity: float
+    poster_path: str
+    status: str
+    tagline: str
+    type: str
+    vote_average: float
+    vote_count: int
+    languages: list[str] = field(default_factory=list)
+    genres: list[Genre] = field(default_factory=list)
+    backdrop_path: str | None = None
+    created_by: list[CreatedBy] = field(default_factory=list)
+    episode_run_time: list[int] = field(default_factory=list)
+    networks: list[Network] = field(default_factory=list)
+    next_episode_to_air: LastEpisodeToAir | None = None
+    production_companies: list[ProductionCompany] = field(default_factory=list)
+    production_countries: list[ProductionCountry] = field(default_factory=list)
+    seasons: list[Season] = field(default_factory=list)
+    spoken_languages: list[SpokenLanguage] = field(default_factory=list)
+    origin_country: list[str] = field(default_factory=list)
+
+
+    def get_title(self) -> str:
+        return self.name
+
+    def get_original(self) -> str:
+        return self.original_name
+
+    def get_date(self) -> str:
+        return self.first_air_date
+
+    def get_id(self) -> int:
+        return self.id
+
+    def get_translations(self) -> dict[str, str] | None:
+        pass
+
+    def get_imdb(self) -> str | None:
+        pass
+
+    def get_poster_path(self) -> str:
+        pass
+
+
+@dataclass(slots=True)
+class OnTheAir:
+    adult: bool | None = None
+    backdrop_path: str | None = None
+    genre_ids: list[int] | None = None
+    id: int | None = None
+    original_language: str | None = None
+    original_title: str | None = None
+    overview: str | None = None
+    popularity: float | None = None
+    poster_path: str | None = None
+    release_date: str | None = None
+    title: str | None = None
+    video: bool | None = None
+    vote_average: float | None = None
+    vote_count: int | None = None
+    origin_country: list[str] | None = None
+    original_name: str | None = None
+    first_air_date: str | None = None
+    name: str | None = None
+
+
+@dataclass(slots=True)
+class Translation:
+    """
+    Represents a TV show translation
+    """
+    iso_639_1: str
+    """
+    Language code of the translation
+    """
+    english_name: str
+    """
+    English name of the language
+    """
+    name: str
+    """
+    Name of the translation
+    """
+    url: str | None
+    """
+    Optional URL associated with the translation
+    """
+    tagline: str | None
+    """
+    Optional tagline for the translation
+    """
+    description: str | None
+    """
+    Optional description for the translation
+    """
+    country: str | None
+    """
+    Optional country code related to the translation
+    """
+
+
+@dataclass(slots=True)
+class TranslationsResponse:
+    """
+    Contains a list of TV show translations
+    """
+    translations: list[Translation]
+    """
+    List of Translation objects
+    """
+
+
+@dataclass(slots=True)
+class TvShow(MediaRepoInterface):
+    """
+     Dataclass for manage result from a TMDB search
+    """
+
+    id: int
+    name: str
+    first_air_date: str
+    overview: str
+    popularity: float
+    vote_average: float
+    vote_count: int
+    genre_ids: list[int] = field(default_factory=list)
+    origin_country: list[str] = field(default_factory=list)
+    original_language: str = ''
+    original_name: str = ''
+    backdrop_path: str | None = None
+    poster_path: str | None = None
+    adult: bool = False
+    softcore: str | None = None
+
+
+    def get_title(self) -> str:
+        return self.name
+
+    def get_original(self) -> str:
+        return self.original_name
+
+    def get_date(self) -> str:
+        return self.first_air_date
+
+    def get_id(self) -> int:
+        return self.id
+
+    def get_poster_path(self) -> str:
+        return self.poster_path
+
+    def get_imdb(self) -> str | None:
+        # Get remote ids (IMDB) only from tvdb
+        pass
+
+    def get_translations(self) -> list[str] | None:
+        # Get translations list only from tvdb
+        pass