Unit3DwebUp 0.0.14__py3-none-any.whl

services/video_service.py

@@ -0,0 +1,356 @@
+# -*- coding: utf-8 -*-
+import aiohttp
+import base64
+import os
+import io
+
+from pathlib import Path
+from PIL import Image
+
+from services.interfaces import VideoServiceInterface, DescriptionBuilderInterface
+from config.host_data import upload_hosts, master_uploaders
+from external.async_http_client_service import AsyncHttpClient
+from config.constants import MediaStatus
+from config.settings import get_settings
+from config.logger import get_logger
+from models.media import Media
+
+from pymediainfo import MediaInfo
+from aiohttp import FormData
+from fastapi import FastAPI
+import numpy as np
+import asyncio
+
+
+
+# Based on the old code unit3dup 0.8.21
+class VideoFrame:
+    def __init__(self, video_path: str, num_screenshots: int, webp_filepath=None):
+        self.video_path = Path(video_path)
+        self.webp_filepath = Path(webp_filepath) if webp_filepath else None
+        self.num_screenshots = num_screenshots
+        self.logger = get_logger(self.__class__.__name__)
+
+    async def create(self):
+        """
+        return list of extract screenshots from the video
+        """
+        frames = await self._extract()
+        frames_in_bytes = []
+        is_hd = 0
+
+        for frame in frames:
+            img_bytes = self.image_to_bytes(frame)
+            if frame.height >= 720:
+                is_hd = 1
+            frames_in_bytes.append(img_bytes)
+
+        webp = []
+        if self.webp_filepath:
+            webp = await self.create_webp_from_video(video_path=self.video_path, output_path=self.webp_filepath)
+
+        return frames_in_bytes + (webp or []), is_hd
+
+    @staticmethod
+    def image_to_bytes(frame: Image.Image) -> bytes:
+        """
+        Convert frame bytes to Jpeg with no compression
+        """
+        buffered = io.BytesIO()
+        frame.save(buffered, format="JPEG", optimize=False, compress_level=4)
+        return buffered.getvalue()
+
+    async def _get_video_duration(self) -> float:
+        """
+        return the video duration
+
+        -show_entries format: Get video duration
+
+        -of default=noprint_wrappers=1:nokey=1:  output formatted to get only the number ( duration value)
+        """
+        command = [
+            "ffprobe",
+            "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            str(self.video_path),
+        ]
+        proc = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, _ = await proc.communicate()
+        return float(stdout.decode().strip())
+
+    async def _extract(self):
+        """
+            FFPROBE
+            - "-v",                                       show the errore only
+            - "-select_streams", "v:0",                   extract only the first stream
+            - "-show_entries", "stream=width,height",     return only Height and Width value
+            - "-of", "default=nw=1:nk=1",                 print only the numeric value ( WxH value)
+
+            - FFMPEG
+            - "-ss", str(t),                              seek at time t(secondi)
+            - "-i", str(self.video_path),                 video file path
+            - "-vframes", "1",                            extract only one frame
+            - "-f", "rawvideo",                           output format rawvideo
+            - "-pix_fmt", "rgb24",                        24-bit rgb  - todo: problema con formato png?
+            - "-" : output to stdout
+
+        :return:
+        """
+
+        duration = await self._get_video_duration()
+        # todo: Hardcoded values
+        start_time = duration * 0.35
+        end_time = duration * 0.85
+
+        times = np.linspace(start_time, end_time, self.num_screenshots, endpoint=True)
+
+        command = [
+            "ffprobe",
+            "-v", "error",
+            "-select_streams", "v:0",
+            "-show_entries", "stream=width,height",
+            "-of", "default=nw=1:nk=1",
+            str(self.video_path)
+
+        ]
+        proc = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, _ = await proc.communicate()
+        w, h = stdout.decode().strip().splitlines()
+        width, height = int(w), int(h)
+
+        frames = []
+        for t in times:
+            command = [
+                "ffmpeg",
+                "-ss", str(t),
+                "-i", str(self.video_path),
+                "-vframes", "1",
+                "-f", "rawvideo",
+                "-pix_fmt", "rgb24",  # ho avuto un problema con png
+                "-"
+            ]
+            proc = await asyncio.create_subprocess_exec(
+                *command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.DEVNULL
+            )
+            stdout, _ = await proc.communicate()
+            img = Image.fromarray(np.frombuffer(stdout, dtype=np.uint8).reshape((height, width, 3)))
+            frames.append(img)
+
+        return frames
+
+
+    async def create_webp_from_video(self, video_path, output_path):
+        """
+        - "-y",                                            overwrite output if it exists
+        - "-ss", '70',                                     start time at 70 seconds
+        - "-t", '10',                                      extracts 10 seconds
+        - "-i", video_path,                                video file path
+        - "-vf", f"fps=7,scale=650:-1:flags=lanczos",      set fps and scale to 650 ( aspect ratio ok)
+        - "-c:v", "libwebp",                               encode video as WebP
+        - "-quality", "50",                                quality
+        - "-loop", "0",                                    repeat the animation
+        - "-speed", "9",                                   encoding speed (1 = slowest, 10 = fastest)
+        - "-threads", "8",                                 number of threads
+        - "-f", "webp",                                    webp format
+        - "output_path"                                    output file path
+        """
+        command = [
+            "ffmpeg",
+            "-y",
+            "-ss", '70',
+            "-t", '10',
+            "-i", video_path,
+            "-vf", f"fps=7,scale=650:-1:flags=lanczos",
+            "-c:v", "libwebp",
+            "-quality", "50",
+            "-loop", "0",
+            "-speed", "9",
+            "-threads", "8",
+            "-f", "webp",
+            output_path
+        ]
+        proc = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        await proc.communicate()
+
+        if not os.path.isfile(output_path):
+            self.logger.error(f"file {output_path} doesn't exist!")
+            return None
+
+        # todo: vorrei non dover scrivere su file ma in memoria ram
+        with open(output_path, "rb") as webp_file:
+            webp_file_content = webp_file.read()
+        os.remove(output_path)
+        return [webp_file_content]
+
+
+class VideoService(VideoServiceInterface):
+    """ Build a description for the torrent page: screenshots, mediainfo, trailers, metadata """
+
+    def __init__(self, media: Media):
+        """
+        :param media: The Media object
+        """
+
+        self.media = media
+        self.file_name: str = media.file_name
+        self.display_name: str = media.display_name
+        self.webp_filepath: str | None = None
+        settings = get_settings()
+
+        if settings.prefs.WEBP_ENABLED:
+            self.webp_filepath = f"{media.display_name}.webp"
+
+        # Load the video frames
+        # if web_enabled is off set the number of screenshots to an even number
+        if not settings.prefs.WEBP_ENABLED:
+            if settings.prefs.NUMBER_OF_SCREENSHOTS % 2 != 0:
+                settings.prefs.NUMBER_OF_SCREENSHOTS += 1
+
+        samples_n = max(2, min(settings.prefs.NUMBER_OF_SCREENSHOTS, 10))
+
+        self.video_frames: VideoFrame = VideoFrame(video_path=self.file_name,
+                                                   num_screenshots=samples_n, webp_filepath=self.webp_filepath)
+
+    async def generate(self):
+        """Build the information to send to the tracker"""
+
+        # Extract the frames
+        self.media.extracted_frames, self.media.is_hd = await self.video_frames.create()
+        # Add Media description
+        self.media.media_to_string = await asyncio.to_thread(MediaInfo.parse, self.media.file_name,
+                                                             output="STRING", full=False)
+        return None
+
+
+class BuildService(DescriptionBuilderInterface):
+    """
+        Upload all previously created screenshots to hostimage, get their URLs, build a description for the tracker
+    """
+
+    def __init__(self, media_list: list[Media], app: FastAPI, session: aiohttp.ClientSession | None = None):
+        """
+        :param media_list: a list of Media objects
+        :param session: aiohttp.ClientSession | None
+        """
+        self.session = session or aiohttp.ClientSession()
+        self.http = AsyncHttpClient(self.session)
+        self.media_list = media_list
+        self.app = app
+        self.screenshots = []
+        self.logger = get_logger(self.__class__.__name__)
+        settings = get_settings()
+        self.sign = (
+            f"[url=https://github.com/31December99/Unit3DWebUp][code][color=#00BFFF][size=14]Uploaded with Unit3DwebUp"
+            f" {settings.unit3DwebUp.VERSION}[/size][/color][/code][/url]")
+
+    async def description(self):
+
+        settings = get_settings()
+        priority_map = {
+            'ImgBB': settings.prefs.IMGBB_PRIORITY,
+            'PtScreens': settings.prefs.PTSCREENS_PRIORITY,
+            'LensDump': settings.prefs.LENSDUMP_PRIORITY,
+            'ImgFi': settings.prefs.IMGFI_PRIORITY,
+            'PassIMA': settings.prefs.PASSIMA_PRIORITY,
+            'ImaRide': settings.prefs.IMARIDE_PRIORITY,
+            'Freeimage': settings.prefs.FREE_IMAGE_PRIORITY,
+        }
+
+        user_order = sorted(master_uploaders, key=lambda uploader: priority_map[uploader])
+
+        async def upload_frame(media: Media, index: int, image_bytes: bytes) -> str:
+            """
+            :param media: the Media object
+            :param index: enumeration for the screenshot
+            :param image_bytes: the image data
+            :return:
+
+            Upload single frame
+            """
+
+            image_name = f"{media.display_name}.id_{index}"
+            image_base64 = base64.b64encode(image_bytes).decode('utf-8')
+            timeout = 30
+
+            host = upload_hosts[user_order[0]]
+            form = FormData()
+            form.add_field('key', host['data']['key'])
+
+            # passtheima host
+            if host.get('data', {}).get('fieldname', None):
+                form.add_field(host['data']['fieldname'], image_name)
+            form.add_field('image', image_base64)
+
+            try:
+                response = await self.session.post(host['url'], data=form, timeout=timeout)
+                response.raise_for_status()
+                result = await response.json()
+                if result.get('data', None):
+                    img_url = result["data"]["image"]["url"]
+                else:
+                    img_url = result["image"]["url"]
+                self.logger.info(f"[OK] Uploaded {img_url}")
+                self.screenshots.append(img_url)
+                media.status = MediaStatus.DESCRIPTION_READY
+                return f"[url={img_url}][img=650]{img_url}[/img][/url]"
+            except Exception as e:
+                self.logger.error(f"[ERROR] Upload frame {image_name}: {e}")
+                media.status = MediaStatus.DESCRIPTION_ERROR
+                return ""
+
+        async def upload_media(media: Media) -> str | None:
+            """
+            :param media: the Media object
+            :return:
+
+            upload media screenshot to hostimage
+            """
+            tasks = [upload_frame(media, idx, img_bytes) for idx, img_bytes in enumerate(media.extracted_frames)]
+            uploaded_frames = await asyncio.gather(*tasks)
+
+            media.screen_shots = self.screenshots
+            if media.status == MediaStatus.DESCRIPTION_READY:
+                description = "[center]\n" + "".join(uploaded_frames)
+                if media.trailer:
+                    description += (
+                        f"\n[/center][b][spoiler=Spoiler:"
+                        f" PLAY TRAILER][center][youtube]{media.trailer}[/youtube]"
+                        f"[/center][/spoiler][/b]")
+                description+=self.sign
+                return description
+            return None
+
+        # Upload
+        all_descriptions = await asyncio.gather(*[upload_media(media) for media in self.media_list])
+        # Add description
+        for media, desc in zip(self.media_list, all_descriptions):
+            if media.status == MediaStatus.DESCRIPTION_READY:
+                media.description = desc
+            else:
+                self.logger.warning("Description error")
+                # Send a message to the frontend by ws
+                await self.app.state.ws_manager.broadcast({
+                    "type": "log",
+                    "level": "error",
+                    "message": f"Failed to build description for {media.file_name}",
+                })
+
+        return None
+
+    async def close(self) -> None:
+        await self.session.close()

unit3dwebup-0.0.14.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: Unit3DwebUp
+Version: 0.0.14
+Summary: A Unit3D uploader with a web interface
+Author: Parzival
+License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/31December99/Unit3DupWeb
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp==3.13.3
+Requires-Dist: fastapi==0.129.0
+Requires-Dist: guessit==3.8.0
+Requires-Dist: numpy==2.4.2
+Requires-Dist: pathvalidate==3.3.1
+Requires-Dist: pillow==12.1.1
+Requires-Dist: pydantic==2.12.5
+Requires-Dist: pydantic_core==2.41.5
+Requires-Dist: pymediainfo==7.0.1
+Requires-Dist: pydantic-settings==2.12.0
+Requires-Dist: qbittorrent-api==2025.11.1
+Requires-Dist: python-dotenv==1.2.1
+Requires-Dist: redis==7.1.1
+Requires-Dist: thefuzz==0.22.1
+Requires-Dist: torf==4.3.1
+Requires-Dist: watchdog==6.0.0
+Requires-Dist: uvicorn[standard]==0.40.0
+
+# Unit3DupWeb
+
+![version](https://img.shields.io/pypi/v/unit3dupWeb.svg)
+![online](https://img.shields.io/badge/Online-green)
+![status](https://img.shields.io/badge/Status-Active-brightgreen)
+![python](https://img.shields.io/badge/Python-3.12+-blue)
+![ubuntu](https://img.shields.io/badge/Ubuntu-22+-blue)
+![debian](https://img.shields.io/badge/Debian-12+-blue)
+![windows](https://img.shields.io/badge/Windows-11-blue)
+
+---
+
+# Auto Torrent Generator and Uploader
+
+Reworked from the original [Unit3Dup](https://github.com/31December99/Unit3Dup)
+
+This code is under testing.
+
+![Home](images/home.png)
+
+---
+
+## Demo video
+
+[Here](https://streamable.com/agoizj)
+
+---
+
+## What it does
+
+* Scan folder and subfolders
+* Compiles metadata to create a torrent
+* Extracts screenshots from video
+* Adds webp images to torrent page description
+* Searches IDs on TMDB, IMDb, TVDB
+* Adds trailer from TMDB or YouTube
+* Seeds in qBittorrent
+* Generates metadata from video
+* Creates and uploads torrents/pages
+
+---
+
+## NOT YET TESTED
+
+* Extracts cover from PDF documents
+* Reseeding multiple torrents
+* Cross-OS seeding
+* Custom season titles
+* MediaInfo-based metadata generation
+* Extract first page of PDFs via xpdf and upload it
+* Windows support improvements
+
+---
+
+## NOT YET IMPLEMENTED
+
+* Game metadata generation
+* Transmission / rTorrent seeding
+
+---
+
+## Install from Docker Hub
+
+* Complete `.env.example`
+* Rename to `.env`
+* Run:
+
+```bash
+docker-compose pull
+```
+
+---
+
+## How it works
+
+The backend provides FastAPI endpoints.
+
+For each video file, a job_id is generated from the hash of its path.
+
+* job_ids form a job_list (page view)
+* each page has a job_list_id based on scan path hash
+
+WebSocket is used for:
+
+* progress updates
+* logs to frontend
+
+### Scan process
+
+* Search files/folders
+* Extract title
+* Query TMDB (movie/series)
+* Query TVDB and get IMDb ID
+* Create screenshots
+* Build description with MediaInfo + screenshots
+
+### Editing
+
+If poster has issues (TMDB/IMDb mismatch):
+
+* click poster
+* edit fields
+* create torrent / upload / seed
+
+---
+
+## Frontend build
+
+```bash
+flutter pub get
+flutter build web --release --wasm
+```
+
+---
+
+## Backend build
+
+```bash
+docker-compose -f build.yml build --no-cache
+docker-compose up
+```
+
+---
+
+## Docker Hub
+
+```bash
+docker login
+
+docker tag unit3dwebup-backend:latest parzival2025/backend_app:x.y.z
+docker tag unit3dwebup-frontend:latest parzival2025/frontend_app:x.y.z
+
+docker push parzival2025/backend_app:x.y.z
+docker push parzival2025/frontend_app:x.y.z
+```
+
+---
+
+## Trackers
+
+The Italian tracker community: people with technical and social backgrounds
+united by torrents.
+
+| Tracker | Description                                          |
+| ------- | ---------------------------------------------------- |
+| ITT     | [https://itatorrents.xyz/](https://itatorrents.xyz/) |
+
+---
+
+## Discord
+
+[Join Discord](https://discord.gg/8RpwN2Khcz)
+
+![Discord](https://img.shields.io/discord/1214696147600408698?label=Discord\&logo=discord\&style=flat)
+
+---
+
+## AstraeLabs
+
+[GitHub Project](https://github.com/AstraeLabs/VibraVid)
+
+Open-source script for downloading movies, TV shows, and anime.
+
+![AstraeLabs](https://img.shields.io/badge/AstraeLabs-blue.svg)

unit3dwebup-0.0.14.dist-info/RECORD

@@ -0,0 +1,53 @@
+config/__init__.py,sha256=38D2YRz9kUehElDnmAjshs4IQNdI9Ueop1ze-lU8wxQ,114
+config/api_data.py,sha256=WPC334sgcl25sqCiLEm61VKG9Hq4jH6QOxykEtjbuS8,822
+config/constants.py,sha256=EginqIQt_TJh-BDvbddCqPN9HW83JfniOHAOkALA-Qc,773
+config/host_data.py,sha256=H3tIMPbKCtbw-wYOsOr1Tg6ZfvD8ZfJq7c5NtahrDSU,1613
+config/itt.py,sha256=V2tUAqE1F8H9CUcb8-44xCefohdRqltrzW9VUAn5HRI,3317
+config/logger.py,sha256=lucl0ySM6fSchu-YMalYTCrgDzZTLYQhQwYUwfO9Uss,1025
+config/settings.py,sha256=-Dm52cukiE7i_oXI-RNVGKvqrgP8zQNJZsefyxhYkYY,6628
+config/sis.py,sha256=_hp5Z6kLc7QLkm5o0NyKp0lZ1L4l3jYK4xTDNSAJqoI,2562
+config/tags.py,sha256=fF5vTugAMQCNpqcIFLGgNd934ZQKWPRDeNDvUfozKQE,11360
+config/trackers.py,sha256=1jZOt4WfYIbP53F5S9kLVCsGDaPmkwBAjUSKILA4fVI,1458
+external/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+external/async_http_client_service.py,sha256=OCrqLzLyqZW4T1PdEPs6W7np9eG5XgttogBaJGSIRL0,1465
+external/websocket.py,sha256=LP_bPb3hnZbR1XtC-k9BVTELnyc0iXyGh0oGZxHq3mY,1082
+models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+models/interfaces.py,sha256=VYYSJ_FdKTBjiGIdSuhCShjRrDLbzVlsCIQpQXe2e60,751
+models/keywords.py,sha256=GzZ-xPZyYLiZlFNb93793Mf8u4_LVulFvd0RzFrpDQg,247
+models/media.py,sha256=gTNwmKd1irHW1julWCLCr4nzvVE-mXLzfXOsE3IBFnE,19724
+models/media_info.py,sha256=WmYHyFCG-A0RP4fQ5XlGJF8NBvpqQotH_1p7sZPrr0Y,5059
+models/movie.py,sha256=G3GM_WEAsfQCOpeUnvHEtcOc3DN10w1FElZWHs2eQqw,7618
+models/tv.py,sha256=Ibo7C6XzFxHq0pmD-qJDspM10DxSQRV6conNnqzGDKQ,5789
+models/tvdb_search.py,sha256=rqxhp6JX2DnFAWEz-KpmhEF7F138h82Crd2ITuukzrk,3034
+models/videos.py,sha256=TaoPt9zIlMweKFmhw5vyWqNuFFfn3gllbEfCC8X-Xvo,413
+repositories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+repositories/db_online.py,sha256=jx1tHwekNRH0f6TYi5ITWskMDflfC1RFIEBrwPDP0uY,2890
+repositories/interfaces.py,sha256=r5UonODzBHUMzItJJjgiFsa1Eu5zfqtrRH_h1DjvO6E,1616
+repositories/job_repos.py,sha256=4vU6_Z9ZxwyzyP-0RNIIPzSvHpSPqf0P2P1sXcJOTBg,4854
+repositories/media_info_factory.py,sha256=_QCx2q4Dd9bUpCwmmYyg0uORLMLIlM5hbw1J1H4DiJM,810
+services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+services/auto_async_service.py,sha256=Y6c8eSCBVo4ugm-TUiT1yJLbqqKoSJhy05XtdS2MSGs,8931
+services/create_torrent_service.py,sha256=VN7bKkoayBHl0k8opGTM2VVCLRY8ruzaLBPV_Guvry0,3584
+services/interfaces.py,sha256=CQHTxugH8vscv0GEC5fjJV5Tu6Bjyn8B9eQlW03uIkE,1832
+services/itt_tracker_helper.py,sha256=U-HhkP_F-P4jYzBRrgbSHQL7TzDIZbS98PRXg_gG6ps,16194
+services/itt_tracker_service.py,sha256=X6CxnLt9hJq5Fm5OqKE_TK_yCfFq1m_z8LiknoNpxtU,3358
+services/lifespan_service.py,sha256=4yjFtSa-37nw8TbhDYd1mQxrGrLRDH6QlFWvX390k5c,2657
+services/media_service.py,sha256=fF-u-jyB3KiJFYs-PnkhxTNyMrQQ4fp4RsX-jjbiPbo,5195
+services/tags_service.py,sha256=k2lFCOc1FOfBj058j3_kq1drm2upo7kObiGBS3lOqzQ,14998
+services/tmdb.py,sha256=sMxP3lGQpWCkcbje0SeR9R4wUarb-ebASl_Ou7ympEg,8834
+services/torrent_client_service.py,sha256=6R8xeHHadfbmViddbi9sDHMCJ-yJS7Y-I3znD1mmiAM,2758
+services/torrent_service.py,sha256=Y6yIZb1FL_lkU7sPi7pp5dCuZO_vw2P8Vv4iG2mQBGE,3841
+services/tvdb.py,sha256=4xU7i5kLz5aMA39hsOOMnedH6gbX53mJFcjfpWI9kE8,2105
+services/utility.py,sha256=jis0CiCMuzO6st08a3CN1GsOY86LRS1dc36OSZ0gwtU,13401
+services/video_service.py,sha256=WwMJNIY5AXe7gemF6zeOS8x-k4twt2lUa4eEtSSo_H8,13560
+use_case/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+use_case/make_torrent_usecase.py,sha256=6iwph0waXix90kBfnFJpRj8fpPZenIMuGMSDw1kdeRo,2227
+use_case/process_all_usecase.py,sha256=MstzTeBqy3dSjEDjYzdVB1l7YRV_-ddVRAMtlj6bh40,1618
+use_case/scan_media_usecase.py,sha256=j1zJIqJ1gxfRDiXQlVhAFvRK2QC9297o3X_oe2dF_8Y,4375
+use_case/seed_usecase.py,sha256=5lDulS0MtAN9LVZ8H8loH_pyLsIYXLq8qZf0k3s61lg,4408
+use_case/upload_usecase.py,sha256=8Eu1q8QFsxlodDeCNaBGpFHDQYdJLJ_FDH8a4aCaLQc,2748
+unit3dwebup-0.0.14.dist-info/METADATA,sha256=xoK_SIL2B-mAU9QUKi3kaYbFpkpHbRe6NzskRWgurLk,4060
+unit3dwebup-0.0.14.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+unit3dwebup-0.0.14.dist-info/entry_points.txt,sha256=09JdfHldw7AOMJA8Dh9Na3pnd6_4bdSKjQsnMQZsFKY,43
+unit3dwebup-0.0.14.dist-info/top_level.txt,sha256=vt_gnbJJYqpYlLBQNYiAh2DtiFVJBh7enVITw-wImV0,54
+unit3dwebup-0.0.14.dist-info/RECORD,,

unit3dwebup-0.0.14.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

unit3dwebup-0.0.14.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+unit3dupweb = start:main

unit3dwebup-0.0.14.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+config
+external
+models
+repositories
+services
+use_case

use_case/make_torrent_usecase.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+import json
+import os
+from pathlib import Path
+
+from services.torrent_service import TorrentService
+from models.media import Media
+from fastapi import FastAPI
+
+
+class MakeTorrentUseCase:
+    def __init__(self, app: FastAPI, job_id: str | None = None):
+        """
+        Create one or more torrents
+
+        :param app: the fastapi app
+        :param job_id: the job id
+        """
+        self.media_list = None
+        self.app = app
+        self.job_id = job_id
+
+    async def execute(self, media_list: list[Media] | None = None) -> bool:
+        """
+        Execute the torrent use case: create one or more torrents , notify to frontend
+        :param media_list: list of media objects used to create torrents
+        :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
+
+        # FILTER: filter for existing torrent. Ensures that only new torrents are created
+        filtered_torrent_list = []
+        for media in self.media_list:
+            if Path.exists(media.torrent_file_path):
+                # notify the frontend
+                await self.send_message(media=media, message=f"Torrent file exists")
+            else:
+                # Add media objects for the new torrents
+                filtered_torrent_list.append(media)
+
+        if filtered_torrent_list:
+            torrent_service = TorrentService(app=self.app)
+            await torrent_service.start(media_list=filtered_torrent_list)
+            return True
+
+        return False
+
+    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})