Unit3DwebUp 0.0.14__py3-none-any.whl

models/tvdb_search.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from models.interfaces import MediaRepoInterface
+
+
+# slots, non avendo la necessità di aggiungere nuovi attributi al volo
+@dataclass(slots=True)
+class TvdbRemoteID:
+    id: str
+    sourceName: str
+    type: int
+
+
+@dataclass(slots=True)
+class TvdbSearchResult(MediaRepoInterface):
+    """
+        Dataclass for manage result from a TVDB search
+        TMDB e TVDB share the same interface
+    """
+    id: str
+    tvdb_id: str
+    name: str
+    extended_title: str | None
+    slug: str | None
+    type: str
+    primary_type: str
+    status: str | None
+    year: str | None
+    first_air_time: str | None
+    country: str | None
+    primary_language: str | None
+    director: str | None  # for movies
+
+    studios: list[str] = field(default_factory=list)
+    genres: list[str] = field(default_factory=list)
+
+    overview: str | None = None
+    overviews: dict[str, str] = field(default_factory=dict)
+    translations: dict[str, str] = field(default_factory=dict)
+
+    image_url: str | None = None
+    thumbnail: str | None = None
+
+    # for imdb id
+    remote_ids: list[TvdbRemoteID] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, item: dict) -> TvdbSearchResult:
+        remote_ids = [TvdbRemoteID(**r) for r in item.get("remote_ids", [])]
+
+        return cls(
+            id=item.get("id", ""),
+            tvdb_id=item.get("tvdb_id", "0"),
+            name=item.get("name", ""),
+            extended_title=item.get("extended_title"),
+            slug=item.get("slug"),
+            type=item.get("type", ""),
+            primary_type=item.get("primary_type", ""),
+            status=item.get("status"),
+            year=item.get("year"),
+            first_air_time=item.get("first_air_time"),
+            country=item.get("country"),
+            primary_language=item.get("primary_language"),
+            director=item.get("director"),
+            studios=item.get("studios", []),
+            genres=item.get("genres", []),
+            overview=item.get("overview"),
+            overviews=item.get("overviews", {}),
+            translations=item.get("translations", {}),
+            image_url=item.get("image_url"),
+            thumbnail=item.get("thumbnail"),
+            remote_ids=remote_ids,
+        )
+
+    def get_title(self) -> str:
+        return self.name
+
+    def get_original(self) -> str:
+        return self.extended_title or self.name
+
+    def get_date(self) -> str:
+        return self.first_air_time or ""
+
+    def get_id(self) -> int:
+        try:
+            return int(self.tvdb_id)
+        except ValueError:
+            return 0
+
+    def get_poster_path(self) -> str:
+        return self.image_url or ""
+
+    def get_imdb(self) -> str | None:
+        for r in self.remote_ids:
+            if 'IMDB' in r.sourceName.upper():
+                return r.id.lower().replace('tt', '')
+        return None
+
+    def get_translations(self) -> dict[str, str] | None:
+        return self.translations

models/videos.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class Videos:
+    """
+     Dataclass for manage result from a TMDB search : Trailers
+    """
+    id: str
+    iso_3166_1: str
+    iso_639_1: str
+    key: str
+    name: str
+    official: bool
+    published_at: str
+    site: str
+    size: int
+    type: str
+
+
+@dataclass(slots=True)
+class Data:
+    id: int
+    results: list[Videos]

repositories/db_online.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+from typing import TypeVar
+import aiohttp
+
+from models.interfaces import MediaRepoInterface
+from models.movie import AltTitle, NowPlaying
+from models.tv import OnTheAir, DataResponse
+from models.keywords import Keyword
+from models.videos import Data
+
+from repositories.interfaces import MovieRepositoryInterface
+
+from services.tmdb import TmdbAsyncAPI
+from services.tvdb import TvdbAsyncAPI
+
+T = TypeVar('T')
+
+
+class Tmdb(TmdbAsyncAPI, MovieRepositoryInterface):
+    """
+    the purpose is providing a common interface for calling service classes
+    while keeping the service implementations separate
+    It is an update of the old code unit3dup 0.8.21
+    """
+
+    def __init__(self, session: aiohttp.ClientSession | None = None):
+        super().__init__(session)
+
+    async def search(self, query: str, category: str) -> list[T] | None:
+        result = await super().search(query=query, category=category)
+        return result
+
+    async def alternative(self, movie_id: int, category: str) -> AltTitle | DataResponse | None:
+        return await super().alternative(movie_id=movie_id, category=category)
+
+    async def videos(self, movie_id: int, category: str) -> Data | None:
+        return await super().videos(movie_id=movie_id, category=category)
+
+    async def details(self, video_id: int, category: str) -> Data | None:
+        return await super().details(video_id=video_id, category=category)
+
+    async def keywords(self, movie_id: int, category: str) -> Keyword | None:
+        return await super().keywords(movie_id=movie_id, category=category)
+
+    async def playing(self, category: str) -> list[NowPlaying] | list[OnTheAir] | None:
+        return await super().playing(category=category)
+
+    async def close(self):
+        await self.session.close()
+
+
+class Tvdb(TvdbAsyncAPI, MovieRepositoryInterface):
+    """
+    the purpose is providing a common interface for calling service classes
+    while keeping the service implementations separate
+    It is an update of the old code unit3dup 0.8.21
+    """
+
+    def __init__(self, session: aiohttp.ClientSession | None = None):
+        super().__init__(session)
+
+    async def search(self, query: str, category: str = None) -> list[MediaRepoInterface]:
+        await super().tvdb_login()
+        return await super().search(query=query, category=category)
+
+    async def alternative(self, movie_id: int, category: str) -> AltTitle | DataResponse | None:
+        pass
+
+    async def videos(self, movie_id: int, category: str) -> Data | None:
+        pass
+
+    async def details(self, video_id: int, category: str) -> Data | None:
+        pass
+
+    async def keywords(self, movie_id: int, category: str) -> Keyword | None:
+        pass
+
+    async def playing(self, category: str) -> list[NowPlaying] | list[OnTheAir] | None:
+        pass
+
+    async def close(self):
+        await self.session.close()

repositories/interfaces.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+from abc import ABC, abstractmethod
+
+from models.interfaces import MediaRepoInterface
+from models.movie import Movie, NowPlaying
+from models.keywords import Keyword
+from models.videos import Data
+
+from fastapi import FastAPI
+
+
+class MovieRepositoryInterface(ABC):
+    """
+    an Interface class for TMDB and TVDB to share the same methods
+    """
+
+    @abstractmethod
+    async def search(self, query: str, category: str = None) -> list[MediaRepoInterface]: ...
+
+    @abstractmethod
+    async def alternative(self, movie_id: int, category: str) -> list: ...
+
+    @abstractmethod
+    async def videos(self, movie_id: int, category: str) -> Data: ...
+
+    @abstractmethod
+    async def details(self, movie_id: int, category: str) -> Movie: ...
+
+    @abstractmethod
+    async def keywords(self, movie_id: int, category: str) -> list[Keyword]: ...
+
+    @abstractmethod
+    async def playing(self, category: str) -> list[NowPlaying]: ...
+
+    @abstractmethod
+    async def close(self) -> None: ...
+
+
+class JobRepositoryInterface(ABC):
+    """
+    an Interface class for Redis to share the same methods with other repositories that are not yet implemented
+    """
+    @abstractmethod
+    async def connect(self, app: FastAPI): ...
+
+    @abstractmethod
+    async def create_job(self, job_id: str, data: dict): ...
+
+    @abstractmethod
+    async def create_profile(self, data: dict): ...
+
+    @abstractmethod
+    async def update_job(self, job_id: str, new_job: dict): ...
+
+    @abstractmethod
+    async def delete_job_list(self, job_id: str): ...
+
+    @abstractmethod
+    async def close(self): ...

repositories/job_repos.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+
+import json
+import os
+import signal
+from config.logger import get_logger
+from fastapi import FastAPI
+
+from repositories.interfaces import JobRepositoryInterface
+import redis.asyncio as redis
+from redis import exceptions as redis_exceptions, Redis
+
+
+class JobRedisRepo(JobRepositoryInterface):
+    """
+    Manage Redis connections
+
+    Save Media data to Redis
+
+    Redis instance is stored in FastAPi app.state
+
+    The purpose is to avoid waste calls to scanner and share data across endpoints and other..(later)
+
+    """
+
+    def __init__(self, url: str):
+        """
+        :param url: Redis server url
+        """
+        self.redis = redis.from_url(url, decode_responses=True)
+        self.logger = get_logger(self.__class__.__name__)
+
+    async def connect(self, app: FastAPI) -> Redis | None:
+        """
+        :param app: FastAPi app instance
+        :return: the redis instance stored in the fastapi app
+        """
+        app.state.redis = self.redis
+
+        try:
+            if await self.redis.ping(): print("INfO:     DB connected to redis://localhost:6379")
+            return self.redis
+        except redis_exceptions.ConnectionError as e:
+            self.logger.error("Database connection error")
+            os.kill(os.getpid(), signal.SIGTERM)
+            return None
+
+    async def create_job(self, job_id: str, data: dict):
+        """
+        :param job_id: Job id is the file or folder path hashed stored in the Media class object
+        :param data: a dict che store the data of Media object ( media to dict())
+        :return:
+
+        Create a new job
+        Each job represents a Media file or folder
+
+        Every Media object contains a job_id (hash)
+        """
+        try:
+            await self.redis.hset(job_id, mapping={
+                "data": json.dumps(data),
+            })
+        except Exception as e:
+           self.logger.error(e)
+        return job_id
+
+    async def create_job_list(self, job_id: str, job_list: list):
+        """
+        :param job_id: Job id is the scan path hashed
+        :param job_list: a list of job id
+        :return:
+
+        It represents a page on the frontend that is a list of Poster
+
+        We use joblist to manage group of posters
+
+        Each poster is a job id
+        """
+        await self._save_list(job_id, job_list)
+
+    async def get_job_list(self, job_id: str) -> list:
+        """
+        :param job_id: the job id list
+        :return: a list of job id
+
+        Get a list of Jobs ID
+
+        it represents a page on the frontend
+
+        For example we load the page on start to avoid running a new scan on the ssd and requests to TMDB,TVDB
+        """
+        ids = await self.redis.smembers(f"{job_id}:ids")
+        return list(set(ids))
+
+    async def create_profile(self, data: dict):
+        """
+        :param data: a dict che store the configuration file read from the server
+        :return:
+
+        Create a new job that includes the user preferences read from the configuration file
+
+        You can see the preferences on the preferences page
+        """
+        await self.create_job(job_id='0', data=data)
+
+    async def get_job(self, job_id: str):
+        """
+        :param job_id: Job id is the file or folder path hashed stored in the Media class object
+        :return: a dict that stores data about Media object
+        """
+        return await self.redis.hget(job_id, 'data')
+
+    async def update_job(self, job_id: str, new_data: dict):
+        """
+        :param job_id: Job id is the file or folder path hashed stored in the Media class object
+        :param new_data: a dict that stores new data
+        :return:
+
+        Update a specific field of a job
+        """
+
+        current = await self.redis.hget(job_id, "data")
+        if current:
+            data = json.loads(current)
+        else:
+            data = {}
+
+        data.update(new_data)
+
+        await self.redis.hset(job_id, mapping={
+            "data": json.dumps(data),
+        })
+
+        return job_id
+
+    async def _save_list(self, job_id: str, job_list_id: list):
+        """
+        :param job_id: the job id list
+        :param job_list_id: a list of job id
+        :return:
+
+        Replace an old job list with a new one
+
+        for example if the user moves or deletes or adds new file in the scan folder
+
+        """
+        await self.redis.delete(f"{job_id}:ids")
+        await self.redis.sadd(f"{job_id}:ids", *job_list_id)
+
+    async def delete_job_list(self, job_id: str):
+        """
+        :param job_id: the job id list
+        :return:
+
+        Delete an old job list
+
+        For example if the user wipes the scan folder
+        """
+
+        await self.redis.delete(f"{job_id}:ids")
+
+    async def close(self):
+        """
+        Close connection to Redis server
+        """
+        await self.redis.close()

repositories/media_info_factory.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+import asyncio
+
+from pymediainfo import MediaInfo
+from models.media_info import MediaFile
+
+
+class MediaFileFactory:
+
+    @staticmethod
+    async def from_path(path: str) -> MediaFile:
+        """
+        Try to run pymediainfo without blocking
+        """
+        info = await asyncio.to_thread(MediaInfo.parse, path)
+        data = info.to_data().get("tracks", [])
+
+        video = [track for track in data if track.get("track_type") == "Video"]
+        audio = [track for track in data if track.get("track_type") == "Audio"]
+        general = next((track for track in data if track.get("track_type") == "General"), {})
+
+        return MediaFile(
+            file_path=path,
+            video_tracks=video,
+            audio_tracks=audio,
+            general_track=general,
+        )