ittup 1.1.0__py3-none-any.whl

ittup/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

ittup/__main__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from ittup.core.__main__ import main
+
+if __name__ == "__main__":
+    main()

ittup/common/__init__.py

@@ -0,0 +1,4 @@
+from ittup.common.settings import Load
+
+config_settings = Load.load_config()
+

ittup/common/about.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+from importlib.metadata import PackageNotFoundError, version as _package_version
+
+APP_NAME = "ittup"
+APP_DESCRIPTION = "ItaTorrents uploader"
+REPO_URL = "https://github.com/TehMaat/ittup"
+
+# The version is defined only in pyproject.toml and read from the installed package metadata
+try:
+    __version__ = _package_version(APP_NAME)
+except PackageNotFoundError:
+    # Running from a source checkout without installing the package
+    __version__ = "0.0.0+unknown"
+
+USER_AGENT = f"{APP_NAME}/{__version__} (+{REPO_URL})"

ittup/common/bdinfo_string.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+
+class BDInfo:
+    """
+    A class to represent information about a Blu-ray disc.
+
+    Attributes:
+        disc_label (str): The label or name of the disc.
+        disc_size (str): The size of the disc.
+        protection (str): The type of protection applied to the disc.
+        playlist (str): The playlist information.
+        size (str): The size of the content on the disc.
+        length (str): The length of the content on the disc.
+        total_bitrate (str): The total bitrate of the disc content.
+        video (str): The video specifications.
+        audio (list[str]): A list of audio specifications.
+        languages (list[str]): A list of languages extracted from audio specifications.
+        subtitles (list[str]): A list of subtitle specifications.
+
+    Methods:
+        from_bdinfo_string(bd_info_string: str) -> 'BDInfo':
+            Creates an instance of BDInfo from a formatted string.
+    """
+
+    def __init__(
+        self,
+        disc_label: str,
+        disc_size: str,
+        protection: str,
+        playlist: str,
+        size: str,
+        length: str,
+        total_bitrate: str,
+        video: str,
+        audio: list[str],
+        languages: list[str],
+        subtitles: list[str],
+    ):
+        self.disc_label = disc_label
+        self.disc_size = disc_size
+        self.protection = protection
+        self.playlist = playlist
+        self.size = size
+        self.length = length
+        self.total_bitrate = total_bitrate
+        self.video = video
+        self.audio = audio
+        self.languages = languages
+        self.subtitles = subtitles
+
+    @classmethod
+    def from_bdinfo_string(cls, bd_info_string: str) -> 'BDInfo':
+        """
+        Creates an instance of BDInfo from a formatted string.
+
+        Args:
+            bd_info_string (str): A string containing Blu-ray disc information formatted with labels and values.
+
+        Returns:
+            BDInfo: An instance of the BDInfo class with attributes populated from the input string.
+        """
+        lines = bd_info_string.strip().split("\n")
+        data = {"audio": [], "subtitles": []}
+
+        for line in lines:
+            # Parsing Audio
+            if ": " in line:
+                key, value = line.split(": ", 1)
+                key = key.strip().replace(" ", "_").lower()
+
+                if key == "audio":
+                    data["audio"].append(value.strip().lower())
+                elif key == "subtitle":
+                    data["subtitles"].append(value.strip().lower())
+                else:
+                    data[key] = value.strip()
+
+        # Parsing Languages
+        languages_parsed = []
+        for item in data["audio"]:
+            item = item.replace("(", " ")
+            item = item.replace(")", " ")
+            item = item.split("/")
+            languages_parsed.append(item[0].strip())
+
+        return cls(
+            disc_label=data.get("disc_label"),
+            disc_size=data.get("disc_size"),
+            protection=data.get("protection"),
+            playlist=data.get("playlist"),
+            size=data.get("size"),
+            length=data.get("length"),
+            total_bitrate=data.get("total_bitrate"),
+            video=data.get("video"),
+            audio=data["audio"],
+            languages=languages_parsed,
+            subtitles=data["subtitles"],
+        )

ittup/common/bittorrent.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import dataclass
+from ittup.core.pvtTorrent import Mytorrent
+from ittup.core.media import Media
+
+
+@dataclass
+class BittorrentData:
+    tracker_response: str
+    torrent_response: Mytorrent | None
+    content: Media
+    tracker_message: dict
+    archive_path: str

ittup/common/command.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+import os
+import argparse
+
+from ittup.common.utility import System
+from ittup.common.about import APP_DESCRIPTION, APP_NAME
+
+
+class RemovedFlag(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser.error(f"'{option_string}' has been removed: {APP_NAME} uploads only to ItaTorrents")
+
+
+class CommandLine:
+    """
+    Handle command line arguments
+    """
+
+    def __init__(self):
+
+        # /////////////////////////
+        # Main parser
+        # /////////////////////////
+        parser = argparse.ArgumentParser(
+            prog=APP_NAME,
+            description=f"{APP_DESCRIPTION}: manage torrents, uploads, searches and config checks",
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter
+        )
+
+        # /////////////////////////
+        # Groups
+        # /////////////////////////
+        cfg_group = parser.add_argument_group("Config Commands")
+        upload_group = parser.add_argument_group("Upload Commands")
+        search_group = parser.add_argument_group("Search Commands")
+        filter_group = parser.add_argument_group("Filter Options")
+        special_group = parser.add_argument_group("Special Flags")
+
+        # /////////////////////////
+        # Config Commands
+        # /////////////////////////
+        cfg_group.add_argument(
+            "-check", "--check",
+            action="store_true",
+            help="Check config files"
+        )
+
+        # /////////////////////////
+        # Upload Commands
+        # /////////////////////////
+        upload_group.add_argument("-u", "--upload", type=str, help="Upload path")
+        upload_group.add_argument("-f", "--folder", type=str, help="Upload folder")
+        upload_group.add_argument("-scan", "--scan", type=str, help="Scan folder")
+        upload_group.add_argument("-reseed", "--reseed", action="store_true", help="Reseed folder")
+        upload_group.add_argument("-watcher", "--watcher", action="store_true", help="Start watcher")
+        upload_group.add_argument("-notitle", "--notitle", type=str, help="Manual title")
+
+        upload_group.add_argument(
+            "-force",
+            nargs='?',
+            const="movie",
+            type=str,
+            default=None,
+            help="Force category"
+        )
+
+        upload_group.add_argument("-noseed", "--noseed", action="store_true", help="Disable seeding")
+        upload_group.add_argument("-noup", "--noup", action="store_true", help="Torrent only")
+        upload_group.add_argument("-dup", "--duplicate", action="store_true", help="Check duplicates")
+        upload_group.add_argument("-personal", "--personal", action="store_true", help="Personal release")
+        upload_group.add_argument("-ftp", "--ftp", action="store_true", help="Connect FTP")
+
+        # Removed flags: ittup uploads only to ItaTorrents. Without this '-mt' would be parsed as '-m t'
+        upload_group.add_argument("-mt", "--mt", "-tracker", "--tracker", nargs='?', action=RemovedFlag,
+                                  help=argparse.SUPPRESS)
+
+        # /////////////////////////
+        # Search Commands
+        # /////////////////////////
+        search_group.add_argument("-dmp", "--dump", action="store_true", help="Dump titles")
+        search_group.add_argument("-sch", "--search", type=str, help="Search torrent")
+        search_group.add_argument("-db", "--dbsave", action="store_true", help="Save results")
+        search_group.add_argument("-i", "--info", type=str, help="Torrent info")
+        search_group.add_argument("-up", "--uploader", type=str, help="By uploader")
+        search_group.add_argument("-d", "--description", type=str, help="By description")
+        search_group.add_argument("-bd", "--bdinfo", type=str, help="Show BDInfo")
+        search_group.add_argument("-m", "--mediainfo", type=str, help="Show MediaInfo")
+        search_group.add_argument("-int", "--internal", action="store_true", help="Internal Release")
+        search_group.add_argument("-mod", "--moderation", action="store_true", help="In moderation")
+
+
+        # /////////////////////////
+        # Filter Options
+        # /////////////////////////
+        filter_group.add_argument("-st", "--startyear", type=str, help="Start year")
+        filter_group.add_argument("-en", "--endyear", type=str, help="End year")
+        filter_group.add_argument("-type", "--type", type=str, help="Type")
+        filter_group.add_argument("-res", "--resolution", type=str, help="Resolution")
+        filter_group.add_argument("-file", "--filename", type=str, help="Filename")
+        filter_group.add_argument("-se", "--season", type=str, help="Season")
+        filter_group.add_argument("-ep", "--episode", type=str, help="Episode")
+
+        # IDs
+        filter_group.add_argument("-tmdb", "--tmdb_id", type=str, help="TMDB ID")
+        filter_group.add_argument("-imdb", "--imdb_id", type=str, help="IMDB ID")
+        filter_group.add_argument("-tvdb", "--tvdb_id", type=int, help="TVDB ID")
+        filter_group.add_argument("-mal", "--mal_id", type=str, help="MAL ID")
+        filter_group.add_argument("-playid", "--playlist_id", type=str, help="Playlist ID")
+        filter_group.add_argument("-coll", "--collection_id", type=str, help="Collection ID")
+
+        # Status
+        filter_group.add_argument("-free", "--freelech", type=str, help="Freeleech")
+        filter_group.add_argument("-al", "--alive", action="store_true", help="Alive")
+        filter_group.add_argument("-dd", "--dead", action="store_true", help="Dead")
+        filter_group.add_argument("-dy", "--dying", action="store_true", help="Dying")
+
+        # /////////////////////////
+        # Special Flags
+        # /////////////////////////
+        special_group.add_argument("-du", "--doubleup", action="store_true", help="DoubleUp")
+        special_group.add_argument("-fe", "--featured", action="store_true", help="Featured")
+        special_group.add_argument("-re", "--refundable", action="store_true", help="Refundable")
+        special_group.add_argument("-str", "--stream", action="store_true", help="Stream")
+        special_group.add_argument("-sd", "--standard", action="store_true", help="SD")
+        special_group.add_argument("-hs", "--highspeed", action="store_true", help="Highspeed")
+        special_group.add_argument("-inter", "--intern_r", action="store_true", help="Internal Release")
+        special_group.add_argument("-pr", "--prelease", action="store_true", help="Personal")
+
+        # /////////////////////////
+        # Parse args
+        # /////////////////////////
+        self.args = parser.parse_args()
+
+        # /////////////////////////
+        # Check scan path
+        # /////////////////////////
+        self.is_dir = os.path.isdir(self.args.scan) if self.args.scan else None
+
+        # /////////////////////////
+        # Expand upload path
+        # /////////////////////////
+        if self.args.upload:
+            self.args.upload = os.path.expanduser(self.args.upload)
+
+        # /////////////////////////
+        # Validate force category
+        # /////////////////////////
+        if self.args.force:
+
+            self.args.force = self.args.force[:10]
+
+            valid_categories = [
+                System.category_list[System.MOVIE],
+                System.category_list[System.GAME],
+                System.category_list[System.TV_SHOW],
+                System.category_list[System.DOCUMENTARY]
+            ]
+
+            if self.args.force.lower() not in valid_categories:
+                self.args.force = None
+                print("Invalid -force category")
+                exit()

ittup/common/constants.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+language_dict = {
+    "IT": "Italian",
+    "ES": "Spanish",
+    "DE": "German",
+    "FR": "French",
+    "EN": "English",
+    "TR": "Turkish",
+    "PT": "Portuguese",
+    "JA": "Japanese",
+    "BG": "Bulgarian",
+    "PL": "Polish"
+}
+
+
+def my_language(iso639_1: str)-> str | None:
+    return language_dict.get(iso639_1.upper(), '')

ittup/common/database.py

@@ -0,0 +1,78 @@
+import json
+import os
+import sqlite3
+from ittup.core import config_settings
+
+# Torrent attributes
+create_table_sql = ('\n'
+                    'CREATE TABLE IF NOT EXISTS torrents (\n'
+                    '    id INTEGER PRIMARY KEY AUTOINCREMENT,\n'
+                    '    name TEXT,\n'
+                    '    category TEXT,\n'
+                    '    category_id INTEGER,\n'
+                    '    created_at TEXT,\n'
+                    '    description TEXT,\n'
+                    '    details_link TEXT,\n'
+                    '    download_link TEXT,\n'
+                    '    double_upload BOOLEAN,\n'
+                    '    featured BOOLEAN,\n'
+                    '    freeleech TEXT,\n'
+                    '    igdb_id INTEGER,\n'
+                    '    imdb_id TEXT,\n'
+                    '    info_hash TEXT,\n'
+                    '    internal BOOLEAN,\n'
+                    '    leechers INTEGER,\n'
+                    '    magnet_link TEXT,\n'
+                    '    mal_id INTEGER,\n'
+                    '    media_info TEXT,\n'
+                    '    release_year INTEGER,\n'
+                    '    resolution TEXT,\n'
+                    '    resolution_id INTEGER,\n'
+                    '    seeders INTEGER,\n'
+                    '    size INTEGER,\n'
+                    '    times_completed INTEGER,\n'
+                    '    tmdb_id INTEGER,\n'
+                    '    tvdb_id INTEGER,\n'
+                    '    type TEXT,\n'
+                    '    type_id INTEGER,\n'
+                    '    uploader TEXT,\n'
+                    '    personal_release BOOLEAN,\n'
+                    '    refundable BOOLEAN,\n'
+                    '    num_file INTEGER,\n'
+                    '    bd_info TEXT,\n'
+                    '    genres TEXT,\n'
+                    '    poster TEXT,\n'
+                    '    meta TEXT,\n'
+                    '    files TEXT\n'
+                    ')\n')
+
+
+class Database:
+    """
+    Create a new database and populate it with torrents attributes
+    Search torrents based on attributes
+    """
+
+    def __init__(self, db_file):
+        self.filename = db_file
+        self.CACHE_PATH = config_settings.user_preferences.CACHE_PATH
+        self.database = sqlite3.connect(os.path.join(self.CACHE_PATH, f"{db_file}.db"))
+        self.cursor = self.database.cursor()
+        self.build()
+
+    def build(self):
+        self.cursor.execute("DROP TABLE IF EXISTS torrents")
+        self.cursor.execute(create_table_sql)
+        self.database.commit()
+
+    def write(self, data: dict):
+        for key, value in data.items():
+            if isinstance(value, (dict, list)):
+                data[key] = json.dumps(value)
+
+        keys = ', '.join(data.keys())
+        placeholders = ', '.join(['?'] * len(data))
+        values = tuple(data.values())
+        sql = f'''INSERT INTO torrents ({keys}) VALUES ({placeholders})'''
+        self.cursor.execute(sql, values)
+        self.database.commit()

ittup/common/external_services/__init__.py

@@ -0,0 +1,9 @@
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+)
+
+logger = logging.getLogger(__name__)
+