Unit3DwebUp 0.0.14__py3-none-any.whl

services/tmdb.py

@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*-
+from typing import TypeVar
+import aiohttp
+
+from models.movie import (Movie, AltTitle, Title, NowPlaying, MovieDetails, Genre,
+                          ProductionCompany, SpokenLanguage, ProductionCountry)
+from models.tv import (TVShowDetails, CreatedBy, Network, LastEpisodeToAir, Season,
+                       OnTheAir, TvShow, DataResponse, Alternative)
+from models.videos import Videos, Data
+from models.keywords import Keyword
+
+from external.async_http_client_service import AsyncHttpClient
+
+from config.settings import get_settings
+
+settings = get_settings()
+BASE_URL = "https://api.themoviedb.org/3"
+TMDB_APIKEY = settings.tracker.TMDB_APIKEY
+T = TypeVar('T')
+
+
+# Endpoints TMDB
+class TmdbEndpoints:
+    BASE_URL = "https://api.themoviedb.org/3"
+
+    @staticmethod
+    def movie_search(query: str) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/search/movie"
+
+    @staticmethod
+    def tv_search(query: str) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/search/tv"
+
+    @staticmethod
+    def alternative_movie(movie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/movie/{movie_id}/alternative_titles"
+
+    @staticmethod
+    def alternative_show(serie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/tv/{serie_id}/alternative_titles"
+
+    @staticmethod
+    def videos_movie(movie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/movie/{movie_id}/videos"
+
+    @staticmethod
+    def videos_show(serie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/tv/{serie_id}/videos"
+
+    @staticmethod
+    def movie_details(movie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/movie/{movie_id}"
+
+    @staticmethod
+    def tv_details(serie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/tv/{serie_id}"
+
+    @staticmethod
+    def movie_keywords(movie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/movie/{movie_id}/keywords"
+
+    @staticmethod
+    def tv_keywords(serie_id: int) -> str:
+        return f"{TmdbEndpoints.BASE_URL}/tv/{serie_id}/keywords"
+
+    @staticmethod
+    def movie_now_playing() -> str:
+        return f"{TmdbEndpoints.BASE_URL}/movie/now_playing"
+
+    @staticmethod
+    def tv_on_the_air() -> str:
+        return f"{TmdbEndpoints.BASE_URL}/tv/on_the_air"
+
+
+# TMDB async
+class TmdbAsyncAPI:
+    def __init__(self, session: aiohttp.ClientSession | None = None):
+        self.api_key = TMDB_APIKEY
+        self.language = "it-IT"
+        self.session = session or aiohttp.ClientSession()
+        self.http = AsyncHttpClient(self.session)
+
+    async def close(self):
+        await self.session.close()
+
+    async def search(self, query: str, category: str) -> list[T]:
+        """
+        :param query: the title to search for
+        :param category: serie or movie
+        :return:
+        """
+        url = TmdbEndpoints.movie_search(query) if category == "movie" else TmdbEndpoints.tv_search(query)
+        params = {"api_key": self.api_key, "query": query, "language": self.language}
+
+        data = await self.http.get(url, params=params)
+
+        results: list[T] = []
+        if data and "results" in data:
+            items = data["results"]
+            if category == "movie":
+                for item in items:
+                    results.append(Movie(**item))  # converte JSON in dataclass Movie
+            else:  # "tv"
+                for item in items:
+                    results.append(TvShow(**item))  # converte JSON in dataclass TvShow
+
+        return results
+
+    async def alternative(self, movie_id: int, category: str) -> AltTitle | DataResponse | None:
+        """
+        :param movie_id: the movie id
+        :param category: serie or movie
+        :return:
+
+        Get alternative title of a movie or serie
+
+        """
+        url = TmdbEndpoints.alternative_movie(movie_id) if category == "movie" else TmdbEndpoints.alternative_show(
+            movie_id)
+        params = {"api_key": self.api_key, "language": self.language}
+
+        data = await self.http.get(url, params=params)
+
+        if not data:
+            return None
+
+        if category == "movie":
+            titles = [title for t in data.get("titles", []) if (title := Title.from_data(t))]
+
+            return AltTitle(id=data.get("id", 0), titles=titles)
+        else:  # series
+            results = [Alternative(**r) for r in data.get("results", [])]
+            return DataResponse(id=data.get("id", 0), results=results)
+
+    async def videos(self, movie_id: int, category: str) -> Data | None:
+        """
+        :param movie_id: the movie id
+        :param category: serie or movie
+        :return:
+
+        Get trailers o associated video
+        """
+        url = TmdbEndpoints.videos_movie(movie_id) if category == "movie" else TmdbEndpoints.videos_show(movie_id)
+        params = {"api_key": self.api_key, "language": self.language}
+
+        data = await self.http.get(url, params=params)
+
+        if not data:
+            return None
+
+        results = [Videos(**v) for v in data.get("results", [])]
+        return Data(id=data.get("id", 0), results=results)
+
+    async def details(self, video_id: int, category: str) -> MovieDetails | TVShowDetails | None:
+        """
+        :param video_id: the video id
+        :param category: serie or movie
+        :return:
+
+        Get details about a movie or serie
+        """
+        url = TmdbEndpoints.movie_details(video_id) if category == "movie" else TmdbEndpoints.tv_details(video_id)
+        params = {"api_key": self.api_key, "language": self.language}
+
+        data = await self.http.get(url, params=params)
+
+        if not data:
+            return None
+
+        if category == "movie":
+            data["genres"] = [Genre(**g) for g in data.get("genres", [])]
+            data["production_companies"] = [ProductionCompany(**c) for c in data.get("production_companies", [])]
+            data["production_countries"] = [ProductionCountry(**c) for c in data.get("production_countries", [])]
+            data["spoken_languages"] = [SpokenLanguage(**l) for l in data.get("spoken_languages", [])]
+            return MovieDetails(**data)
+
+        else:  # tv
+
+            data["genres"] = [Genre(**g) for g in data.get("genres", [])]
+            data["created_by"] = [CreatedBy(**c) for c in data.get("created_by", [])]
+            data["networks"] = [Network(**n) for n in data.get("networks", [])]
+            data["production_companies"] = [ProductionCompany(**p) for p in data.get("production_companies", [])]
+            data["production_countries"] = [ProductionCountry(**c) for c in data.get("production_countries", [])]
+            data["spoken_languages"] = [SpokenLanguage(**l) for l in data.get("spoken_languages", [])]
+
+            if data.get("last_episode_to_air"):
+                data["last_episode_to_air"] = LastEpisodeToAir(**data["last_episode_to_air"])
+
+            if data.get("next_episode_to_air"):
+                data["next_episode_to_air"] = LastEpisodeToAir(**data["next_episode_to_air"])
+
+            data["seasons"] = [Season(**s) for s in data.get("seasons", [])]
+            return TVShowDetails(**data)
+
+    async def keywords(self, movie_id: int, category: str) -> list[Keyword] | None:
+        """
+        :param movie_id: the movie id
+        :param category: serie or movie
+        :return:
+
+        Get the keywords associated with a movie or serie
+        """
+        url = TmdbEndpoints.movie_keywords(movie_id) if category == "movie" else TmdbEndpoints.tv_keywords(movie_id)
+        params = {"api_key": self.api_key, "language": self.language}
+        data = await self.http.get(url, params=params)
+        if not data:
+            return None
+
+        # TMDB restituisce "keywords" per i film, "results" per TV
+        if category == "movie":
+            items = data.get("keywords", [])
+        else:
+            items = data.get("results", [])
+
+        return [Keyword(**k) for k in items]
+
+    async def playing(self, category: str) -> list[NowPlaying] | list[OnTheAir] | None:
+        """
+        :param category: serie or movie
+        :return:
+
+         Get the last movie/series
+        """
+        if category == "movie":
+            url = TmdbEndpoints.movie_now_playing()
+        elif category == "tv":
+            url = TmdbEndpoints.tv_on_the_air()
+        else:
+            raise ValueError(f"Invalid category: {category}")
+
+        params = {"api_key": self.api_key, "language": self.language}
+
+        data = await self.http.get(url, params=params)
+
+        if not data or "results" not in data:
+            return None
+
+        results = []
+        if category == "movie":
+            for item in data["results"]:
+                results.append(NowPlaying(**item))
+        else:  # tv
+            for item in data["results"]:
+                results.append(OnTheAir(**item))
+
+        return results

services/torrent_client_service.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+import asyncio
+import logging
+
+from fastapi import FastAPI
+
+logging.getLogger("urllib3.connectionpool").setLevel(logging.DEBUG)
+
+from services.interfaces import TorrentClientServiceInterface
+from config.settings import get_settings
+from config.logger import get_logger
+
+import qbittorrentapi
+from qbittorrentapi import APIConnectionError
+
+settings = get_settings()
+
+
+class QbittorrentClientService(TorrentClientServiceInterface):
+    """
+        Qbittorrent client service
+    """
+
+    def __init__(self):
+        self.qbt_client = None
+        self._logged = False
+        self.logger = get_logger(self.__class__.__name__)
+
+    async def login(self) -> bool:
+        """
+        :return: True = success, False = fail
+        """
+        if self._logged and self.qbt_client and self.qbt_client.is_logged_in:
+            return True
+
+        conn_info = dict(
+            host=settings.torrent.QBIT_HOST,
+            port=settings.torrent.QBIT_PORT,
+            username=settings.torrent.QBIT_USER,
+            password=settings.torrent.QBIT_PASS,
+        )
+
+        self.qbt_client = qbittorrentapi.Client(**conn_info)
+
+        try:
+            await asyncio.to_thread(self.qbt_client.auth_log_in)
+            self._logged = True
+            self.logger.info("Login successfully")
+            return True
+
+        except qbittorrentapi.LoginFailed as e:
+            self.logger.error(e)
+            return False
+        except APIConnectionError as e:
+            self.logger.error(e)
+            return False
+
+    async def add_torrents(self, torrent_paths: list[str], save_path: str, app: FastAPI) -> bool:
+        """
+        Add torrents to torrent client
+
+        :param torrent_paths: If Docker = true, torrent_path must refer the docker mounted path
+        :param save_path: The folder with data file, host path
+        :param app: app.state
+        :return: success or fail
+        """
+        if not self.qbt_client or not self.qbt_client.is_logged_in:
+            await self.login()
+
+        try:
+            await asyncio.to_thread(
+            self.qbt_client.torrents_add,
+            torrent_files=torrent_paths, # Docker
+            save_path=save_path, # Host
+            autoTMM=False,
+            paused=False,
+            is_skip_checking=True
+            )
+        except qbittorrentapi.exceptions.TorrentFileError as e:
+            logging.info(f"Add torrents {e}")
+            return False
+        # File is already seeding
+        except qbittorrentapi.exceptions.Conflict409Error as e:
+            logging.info(f"Add torrents {e}")
+            return False
+        return True
+
+    async def list_torrents(self) -> list:
+        pass
+
+    async def remove_torrent(self, torrent_id: str) -> bool:
+        pass

services/torrent_service.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+import asyncio
+
+from services.create_torrent_service import MyTorrentService
+from models.media import Media
+from threading import Thread
+from fastapi import FastAPI
+from multiprocessing import Manager
+
+
+class TorrentService:
+    """
+        Accept a list of Media objects and create torrents in batch mode
+        TODO For the moment n° workers and batch_size are hardcoded
+    """
+
+    def __init__(self, app: FastAPI):
+        """
+        :param app: FastApi
+        """
+
+        # Process media
+        self.media_list: list[Media] | None = None
+
+        # FastApi instance app
+        self.app = app
+
+        # Torrent creation
+        self.torr_service = MyTorrentService(app=app)
+
+        # Use the queue to get the progress % during the torrent creation process
+        self.manager = Manager()
+        self.progress_queue = self.manager.Queue()
+        self.result_queue = self.manager.Queue()
+
+    def run_batch(self):
+        """
+             Try to process group of files to avoid ssd saturation
+        :return:
+        """
+
+        # TODO: ha senso spingere con i workers se il mio ssd lavoro già al 100%?
+        try:
+            results = self.torr_service.start(self.media_list, batch_size=16, workers=4,
+                                              progress_queue=self.progress_queue)
+            self.result_queue.put(results)
+        except Exception as e:
+            print(e)
+
+    async def start(self, media_list: list[Media]):
+        """
+            Start the torrent service
+        :return:
+        """
+        self.media_list = media_list
+
+        # Run run_batch() in background
+        thread = Thread(target=self.run_batch)
+        thread.start()
+
+        # Keep looping while the thread is running or the queue is not empty
+        all_progress = {}
+        while thread.is_alive() or not self.progress_queue.empty():
+            while not self.progress_queue.empty():
+                # The worker fill the queue, here we consume it and forward the progress to the client
+                update = self.progress_queue.get()
+
+                # For each torrent send the current progress...
+                all_progress[update['torrent']] = update['progress']
+                await self.app.state.ws_manager.broadcast({
+                    "type": "progress",
+                    "level": "progress",
+                    "job_id": update['job_id'],
+                    "process": "Torrent",
+                    "progress": update['progress'],
+                    "message": f"[New torrent] {update['torrent']} - {round(update['progress'], 2)}",
+                })
+
+                print("log", "progress", update['job_id'], update['progress'],
+                      f"[New torrent] {update['torrent']} - {round(update['progress'], 2)}")
+
+            await asyncio.sleep(0.1)
+
+        thread.join()
+        results = self.result_queue.get()
+
+        # Invio log finali
+        for torrent in results:
+            if torrent.get('status') == '200':
+                await self.app.state.ws_manager.broadcast({
+                    "type": "progress",
+                    "level": "progress",
+                    "job_id": torrent['job_id'],
+                    "process": "Completed",
+                    "progress": 100.0,
+                    "message": f"[New torrent] {torrent['message'].name} from {torrent['message'].parent}"
+                })
+
+            if torrent.get('status') == '409':
+                await self.app.state.ws_manager.broadcast({
+                    "type": "progress",
+                    "level": "progress",
+                    "job_id": torrent['job_id'],
+                    "process": "Error",
+                    "progress": 100.0,
+                    "message": f"[Reloaded] {torrent['message'].name} from {torrent['message'].parent}"
+                })

services/tvdb.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+from typing import TypeVar
+
+from models.tvdb_search import TvdbSearchResult
+from models.interfaces import MediaRepoInterface
+
+from external.async_http_client_service import AsyncHttpClient
+from config.settings import get_settings
+
+import aiohttp
+
+settings = get_settings()
+T = TypeVar('T')
+
+
+class TvdbAsyncAPI:
+    def __init__(self, session: aiohttp.ClientSession | None = None):
+        """
+        :param session: an active aiohttp session
+        """
+        # Use the apikey received from the website (apikey for project)
+        self.api_key = settings.tracker.TVDB_APIKEY
+        # get a new session
+        self.session = session or aiohttp.ClientSession()
+        # an http async client instance
+        self.http = AsyncHttpClient(self.session)
+        # the classe state for tvdb token
+        self.token = None
+
+    async def tvdb_login(self) -> str:
+        """
+        Pass the api_key to Tvdb wait for a new jwt token
+        :return: None
+        """
+        if self.token:
+            return self.token
+        url = "https://api4.thetvdb.com/v4/login"
+        payload = {"apikey": self.api_key}
+
+        resp = await self.session.post(url, json=payload)
+        data = await resp.json()
+        self.token = data["data"]["token"]
+        return self.token
+
+    async def search(self, query: str, category: str = "series") -> list[MediaRepoInterface]:
+        """
+        :param query: the searched title
+        :param category: restrict search to 'movies' or 'series'
+        :return: a TVDB repository implementing the MediaRepoInterface
+        """
+        if not self.token:
+            self.token = await self.tvdb_login()
+
+        url = f"https://api4.thetvdb.com/v4/search?query={query}&type={category}"
+        headers = {"Authorization": f"Bearer {self.token}"}
+
+        resp = await self.session.get(url, headers=headers)
+        resp.raise_for_status()
+        payload = await resp.json()
+
+        # Build TvdbSearchResult objects
+        return [
+            TvdbSearchResult.from_dict(item)
+            for item in payload.get("data", [])
+        ]