Unit3DwebUp 0.0.14__py3-none-any.whl

use_case/process_all_usecase.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+import json
+
+from use_case.make_torrent_usecase import MakeTorrentUseCase
+from use_case.upload_usecase import UploadUseCase
+from use_case.seed_usecase import SeedUseCase
+
+from fastapi import FastAPI
+from models.media import Media
+
+
+class ProcessAllUseCase:
+    def __init__(self, app: FastAPI, job_list_id: str, torrent_client_name: str):
+        """
+        :param app: the FastAPI app
+        :param job_list_id: the job list id
+        :param torrent_client_name: the torrent client (qbittorrent etc)
+        """
+
+        self.app = app
+        self.job_list_id = job_list_id
+
+        self.media_list = None
+        self.seed_use_case = SeedUseCase(app=app, client=torrent_client_name)
+        self.torrent_use_case = MakeTorrentUseCase(app=app)
+        self.upload_use_case = UploadUseCase(app=app)
+
+    async def execute(self):
+        # LOAD a list of jobs from the cache based on the job_list_id received from the frontend
+        job_list = await self.app.state.job.get_job_list(job_id=self.job_list_id)
+        results = [json.loads(await self.app.state.job.get_job(job_id)) for job_id in job_list]
+
+        # MEDIA: create a media_list
+        self.media_list = [Media.from_dict(item) for item in results]
+
+        # TORRENT: create one or more torrent files
+        await self.torrent_use_case.execute(media_list=self.media_list)
+
+        # UPLOAD: upload to the tracker one or more torrent file
+        await self.upload_use_case.execute(media_list=self.media_list)
+
+        # SEED: seed one or more torrent file
+        await self.seed_use_case.execute(media_list=self.media_list)

use_case/scan_media_usecase.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+import asyncio
+import aiohttp
+
+from repositories.interfaces import JobRepositoryInterface
+from config.constants import MediaStatus
+from config.logger import get_logger
+
+from services.video_service import VideoService, BuildService
+from services.media_service import MediaService, MediaService2
+from services.auto_async_service import AsyncMediaManager
+
+
+class ScanMediaUseCase:
+    """
+    Manage services to search for ID create screenshots and create descriptions sequentially
+    """
+
+    def __init__(
+            self,
+            manager: AsyncMediaManager,
+            media_service: MediaService,
+            media_service2: MediaService2,
+            job_repo: JobRepositoryInterface,
+            session: aiohttp.ClientSession,
+            job_list: list[str],
+    ):
+        """
+        :param manager: instance of the scanner
+        :param media_service: instance of external service tmdb
+        :param media_service2: instance of the external service tvdb
+        :param job_repo: instance of the job repository ( redis)
+        :param session: aiohttp session
+        :param job_list: list of jobs id for the current list
+        """
+        self.manager = manager
+        self.media_services = [media_service, media_service2]
+        self.job_repo = job_repo
+        self.session = session
+        self.job_list = job_list
+        self.logger = get_logger(self.__class__.__name__)
+
+    async def execute(self):
+
+        # Scan the local files and create a Media object for each one
+        media_list = await self.manager.process_all()
+
+        # Process all Media objects concurrently
+        return await asyncio.gather(
+            *(self._process_media(m) for m in media_list)
+        )
+
+    async def _process_media(self, media):
+        # job_id already exists in the job_list ?
+        # if does -> no description created -> job already exist
+        if media.job_id in self.job_list:
+            return media
+
+        # We get a new job_id , search for tmdb and tvdb id !
+        await self._identify_media(media)
+
+        # ops! ( for example ID not found ) #todo split tmdb and tvdb case
+        if media.status == MediaStatus.DB_ERROR:
+            return media
+
+        # return if ffmpeg fail
+        if not await self._generate_video(media):
+            return media
+
+        # Pass the screenshot to the image host and build a html description for the tracker
+        await self._build_description(media)
+
+        # Save to redis
+        await self._save(media)
+
+        # return the current media object
+        return media
+
+    async def _identify_media(self, media):
+        media.status = MediaStatus.DB_NOT_IDENTIFIED
+
+        try:
+            # Search id from tmdb, tvdb
+            # and search imdb id in the tvdb remote_ids list
+            for service in self.media_services:
+                success = await service.fetch(media)
+                if success:
+                    media.status = MediaStatus.DB_IDENTIFIED
+        except Exception as e:
+            await self._handle_error(media, MediaStatus.DB_ERROR, e)
+
+        # save to redis
+        await self._save(media)
+
+    async def _generate_video(self, media):
+
+        try:
+            # Extract the screenshots
+            video_service = VideoService(media)
+            await video_service.generate()
+            media.status = MediaStatus.VIDEO_READY
+            return True
+
+        except Exception as e:
+            await self._handle_error(media, MediaStatus.VIDEO_ERROR, e)
+            return False
+
+    async def _build_description(self, media):
+
+        try:
+            # Upload the screenshot to imagehost and return a html code for the description
+            builder = BuildService(
+                media_list=[media],
+                session=self.session,
+                app= self.manager.app
+            )
+            await builder.description()
+
+        except Exception as e:
+            await self._handle_error(media, MediaStatus.DESCRIPTION_ERROR, e)
+
+    async def _handle_error(self, media, status, error):
+        media.status = status
+        media.error = str(error)
+        self.logger.error(f"{status} {media.file_name} {media.error}")
+        await self._save(media)
+
+    async def _save(self, media):
+
+        await self.job_repo.create_job(
+            job_id=media.job_id,
+            data=media.to_dict()
+        )

use_case/seed_usecase.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+import json
+from pathlib import Path
+
+from services.interfaces import TorrentClientServiceInterface
+from services.torrent_client_service import QbittorrentClientService
+from models.media import Media
+from fastapi import FastAPI, status
+from fastapi.responses import JSONResponse
+
+
+class SeedUseCase:
+    def __init__(self, app: FastAPI, client: str, job_id: str | None = None):
+        """
+        :param app: the fastapi app
+        :param job_id: the job id
+        :param client: torrent client name
+        """
+        self.media_list = None
+        self.app = app
+        self.job_id = job_id
+        self.client = client
+
+    async def execute(self, media_list: list[Media] | None = None) -> JSONResponse:
+        """
+        Execute the seed use case : load one or more jobs, login to client, verify torrent files,
+                                    add torrents file to the client
+
+        :param media_list: list of media to upload used when shared with other services
+        :return:
+        """
+
+        # Create the media list for single torrent based on the job_id
+        if self.job_id and not media_list:
+            results = await self.app.state.job.get_job(job_id=self.job_id)
+            self.media_list = [
+                Media.from_dict(item)
+                for item in [json.loads(results)]
+            ]
+        else:
+            # Receive a list
+            self.media_list = media_list
+
+        # Verify whether the *.torrent files still exist and notify the frontend
+        filtered_torrent_list = []
+        for media in self.media_list:
+            if not Path.exists(media.torrent_file_path):
+                await self.send_message(media=media, message=f"Torrent file not found !")
+            else:
+                # discard the invalid torrent file
+                filtered_torrent_list.append(media)
+
+        # Add torrents to the client
+        if filtered_torrent_list:
+            # Ok - try to login
+            torr_client_service: TorrentClientServiceInterface = await self.get_fact_client(name=self.client)
+            response = await torr_client_service.login()
+
+            # Login failed
+            if not response:
+                await self.broadcast_messages(f"{self.client} Login failed")
+                return JSONResponse(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, content={})
+
+            torrent_path_list = [m.torrent_file_path for m in filtered_torrent_list]
+            save_path = self.app.state.settings.prefs.SCAN_PATH
+
+            # Try to add torrents
+            execution = await torr_client_service.add_torrents(
+                torrent_paths=torrent_path_list,  # Docker path
+                save_path=save_path,  # Host path
+                app=self.app)
+
+            if execution:
+                await self.broadcast_messages(f"Added to {self.client}")
+                return JSONResponse(status_code=status.HTTP_200_OK, content={})
+            else:
+                return JSONResponse(status_code=status.HTTP_409_CONFLICT, content={})
+        return JSONResponse(status_code=status.HTTP_404_NOT_FOUND, content={})
+
+
+
+    @staticmethod
+    async def get_fact_client(name: str) -> TorrentClientServiceInterface | None:
+        """
+        :param name: name of the default torrent client
+        :return:
+        """
+
+        if name == "qbittorrent":
+            return QbittorrentClientService()
+        # TODO: aggiungere un altro client mantenendo gli stessi metodi
+        # in attesa di essere aggiunti
+        # if name == "deluge": return DelugeClientService(...)
+        # if name == "transmission": return TransmissionClientService(...)
+        return None
+
+    async def broadcast_messages(self, message: str):
+        """
+        :param message: Send the message to all posters
+        :return:
+        """
+        for media in self.media_list:
+            await self.app.state.ws_manager.broadcast({
+                "type": "posterLogMessage",
+                "job_id": media.job_id,
+                "message": message})
+
+    async def send_message(self, media: Media, message: str):
+        """
+        :param media: The current Media object
+        :param message: Send the message to single poster
+        :return:
+        """
+        await self.app.state.ws_manager.broadcast({
+            "type": "posterLogMessage",
+            "job_id": media.job_id,
+            "message": message})

use_case/upload_usecase.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+import json
+from typing import Any
+
+from services.interfaces import TrackerServiceInterface
+from services.itt_tracker_service import ITTtrackerService
+from models.media import Media
+
+import asyncio
+import aiohttp
+
+from config.logger import get_logger
+from fastapi import FastAPI
+
+
+class UploadUseCase:
+
+    def __init__(self, app: FastAPI, job_id: str | None = None):
+        """
+        :param app: the FastAPI app
+        :param job_id: the job id. Used for a single service upload
+        """
+
+        self.media_list: list[Media] | None = None
+        self.app = app
+        self.job_id = job_id
+        self.logger = get_logger(self.__class__.__name__)
+
+    async def execute(self, media_list: list[Media] | None = None) -> bool:
+        """
+        Execute the seed use case : load one or more jobs, login to tracker, upload the torrents,
+                                    send message to the frontend
+
+        :param media_list: list of media to upload used when shared with other services
+        :return: true or false
+        """
+        self.media_list = media_list
+        # Create the media list for single torrent
+        if self.job_id and not self.media_list:
+            results = await self.app.state.job.get_job(job_id=self.job_id)
+            self.media_list = [
+                Media.from_dict(item)
+                for item in [json.loads(results)]
+            ]
+
+        async with aiohttp.ClientSession() as session:
+
+            # Tracker instance
+            tracker_service: TrackerServiceInterface = ITTtrackerService(session, self.app)
+
+            # Build a list of media
+            tasks = [tracker_service.upload(media) for media in self.media_list]
+
+            # Concurrent execution
+            uploaded_torrents = await asyncio.gather(*tasks)
+            self.logger.debug(f"Start Uploaded Torrents {uploaded_torrents}")
+
+            # Send a message to frontend for each uploaded media
+            await self.broadcast_messages(uploaded_torrents=uploaded_torrents)
+
+            for torrent in uploaded_torrents:
+                await self.app.state.ws_manager.broadcast({
+                    "type": "posterLogMessage",
+                    "job_id": torrent['job_id'],
+                    "message": f"{torrent['message']}"})
+        return True
+
+    async def broadcast_messages(self, uploaded_torrents: tuple[Any]) -> None:
+        """
+        :param uploaded_torrents: results message from the uploaded torrents
+        :return:
+        """
+        for torrent in uploaded_torrents:
+            await self.app.state.ws_manager.broadcast({
+                "type": "posterLogMessage",
+                "job_id": torrent['job_id'],
+                "message": f"{torrent['message']}"})