plexflow 0.0.64__py3-none-any.whl

plexflow/core/subtitles/results/subtitle.py

@@ -0,0 +1,170 @@
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import List, Union
+import PTN
+
+class Subtitle(ABC):
+    """
+    Abstract base class for subtitle objects.
+    """
+
+    @property
+    @abstractmethod
+    def release_name(self) -> str:
+        """
+        Gets the release name of the subtitle.
+
+        Returns:
+            str: The release name of the subtitle.
+        """
+        pass
+
+    @property
+    def uploader(self) -> str:
+        """
+        Gets the uploader of the subtitle.
+
+        Returns:
+            str: The uploader of the subtitle.
+        """
+        return self.source
+
+    @property
+    @abstractmethod
+    def date(self) -> datetime:
+        """
+        Gets the date of the subtitle.
+
+        Returns:
+            datetime: The date of the subtitle.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def imdb_code(self) -> str:
+        """
+        Gets the IMDb code of the subtitle.
+
+        Returns:
+            str: The IMDb code of the subtitle.
+        """
+        pass
+
+    @property
+    def source(self) -> str:
+        """
+        Gets the source of the subtitle.
+
+        Returns:
+            str: The source of the subtitle.
+        """
+        return self.src
+
+    @property
+    @abstractmethod
+    def language(self):
+        """
+        Gets the language of the subtitle.
+
+        Returns:
+            The language of the subtitle.
+        """
+        pass
+
+    @property
+    def subtitle_id(self) -> str:
+        """
+        Gets the subtitle ID.
+
+        Returns:
+            str: The subtitle ID.
+        """
+        return f"{self.source}_{self.hash}"
+
+    @property
+    def parsed_release_name(self) -> dict:
+        """
+        Parses the release name of the subtitle.
+
+        Returns:
+            dict: The parsed release name of the subtitle.
+        """
+        return PTN.parse(self.release_name)
+
+    @property
+    def encoder_name(self) -> str:
+        """
+        Gets the encoder name of the subtitle.
+
+        Returns:
+            str: The encoder name of the subtitle.
+        """
+        parts = self.parsed_release_name
+        return parts.get("encoder")
+
+    @property
+    def season(self) -> Union[int, List[int]]:
+        """
+        Gets the season number of the subtitle.
+
+        Returns:
+            Union[int, List[int]]: The season number of the subtitle.
+        """
+        parts = self.parsed_release_name
+        return parts.get("season")
+
+    @property
+    def episode(self) -> Union[int, List[int]]:
+        """
+        Gets the episode number of the subtitle.
+
+        Returns:
+            Union[int, List[int]]: The episode number of the subtitle.
+        """
+        parts = self.parsed_release_name
+        return parts.get("episode")
+
+    @property
+    def has_multiple_episodes(self):
+        """
+        Checks if the subtitle has multiple episodes.
+
+        Returns:
+            bool: True if the subtitle has multiple episodes, False otherwise.
+        """
+        tmp = self.episode
+        return isinstance(tmp, list) and len(tmp) > 1
+
+    @property
+    def has_multiple_seasons(self):
+        """
+        Checks if the subtitle has multiple seasons.
+
+        Returns:
+            bool: True if the subtitle has multiple seasons, False otherwise.
+        """
+        tmp = self.season
+        return isinstance(tmp, list) and len(tmp) > 1
+
+    @property
+    def title(self) -> str:
+        """
+        Gets the title of the subtitle.
+
+        Returns:
+            str: The title of the subtitle.
+        """
+        parts = self.parsed_release_name
+        return parts.get("title")
+
+    @property
+    def year(self) -> int:
+        """
+        Gets the year of the subtitle.
+
+        Returns:
+            int: The year of the subtitle.
+        """
+        parts = self.parsed_release_name
+        return parts.get("year")

plexflow/core/torrents/analyzers/analyzed_torrent.py

@@ -0,0 +1,143 @@
+from plexflow.core.torrents.results.torrent import Torrent
+from datetime import datetime
+from plexflow.utils.imdb.imdb_codes import IMDbCode
+from typing import List, Union
+from plexflow.utils.torrent.files import TorrentFile
+
+class AnalyzedTorrent:
+    def __init__(self, torrent: Torrent, **kwargs):
+        self._torrent = torrent
+        self._details = kwargs
+        self._ai_details = {}
+
+    def update_from_ai(self, **kwargs):
+        self._ai_details.update(kwargs)
+    
+    @property
+    def release_name(self):
+        return self._torrent.release_name or self._details.get('release_name') or self._ai_details.get('release_name')
+
+    @property
+    def seeds(self) -> int:
+        return self._torrent.seeds or self._details.get('seeds') or self._ai_details.get('seeds')
+    
+    @property
+    def peers(self) -> int:
+        return self._torrent.peers or self._details.get('peers') or self._ai_details.get('peers')
+        
+    @property
+    def size_bytes(self) -> int:
+        return self._torrent.size_bytes or self._details.get('size_bytes') or self._ai_details.get('size_bytes')
+    
+    @property
+    def magnet(self) -> str:
+        return self._torrent.magnet or self._details.get('magnet')
+    
+    @property
+    def hash(self) -> str:
+        return self._torrent.hash or self._details.get('hash')
+    
+    @property
+    def uploader(self) -> str:
+        return self._torrent.uploader or self._details.get('uploader') or self._ai_details.get('uploader')
+    
+    @property
+    def date(self) -> datetime:
+        return self._torrent.date or self._details.get('date') or self._ai_details.get('date')
+    
+    @property
+    def imdb_code(self) -> IMDbCode:
+        return self._torrent.imdb_code or IMDbCode(self._details.get('imdb_code')) if self._details.get('imdb_code') else None
+    
+    @property
+    def source(self) -> str:
+        return self._torrent.source
+    
+    @property
+    def torrent_id(self) -> str:
+        return self._torrent.torrent_id or self._details.get('torrent_id')
+
+    @property
+    def parsed_release_name(self) -> dict:
+        return self._torrent.parsed_release_name
+    
+    @property
+    def encoder_name(self) -> str:
+        return self._torrent.encoder_name
+
+    @property
+    def season(self) -> Union[int, List[int]]:
+        return self._torrent.season
+    
+    @property
+    def episode(self) -> Union[int, List[int]]:
+        return self._torrent.episode
+
+    @property
+    def has_multiple_episodes(self):
+        return self._torrent.has_multiple_episodes
+
+    @property
+    def has_multiple_seasons(self):
+        return self._torrent.has_multiple_seasons
+        
+    @property
+    def title(self) -> str:
+        return self._torrent.title
+        
+    @property
+    def year(self) -> int:
+        return self._torrent.year
+
+    @property
+    def quality(self) -> str:
+        return self._torrent.quality
+
+    @property
+    def is_bad_quality(self):
+        return self._torrent.is_bad_quality
+
+    @property
+    def url(self) -> str:
+        return self._torrent.url
+    
+    @property
+    def html_content(self) -> str:
+        return self._details.get('html_content')
+
+    @property
+    def resolved_urls(self) -> dict:
+        return self._details.get('resolved_urls')
+
+    @property
+    def files(self) -> List[TorrentFile]:
+        return self._details.get('file_list')
+    
+    @property
+    def has_native_subtitles(self):
+        subs = self._details.get('subtitles')
+        if subs and len(subs) > 0:
+            return True
+        return False
+    
+    @property
+    def has_native_dutch_subtitles(self):
+        subs = self._details.get('subtitles')
+        if subs and len(subs) > 0:
+            for sub in subs:
+                if 'dutch' in sub.lower():
+                    return True
+        return False
+    
+    @property
+    def has_native_english_subtitles(self):
+        subs = self._details.get('subtitles')
+        if subs and len(subs) > 0:
+            for sub in subs:
+                if 'english' in sub.lower():
+                    return True
+        return False
+    
+    @property
+    def native_subtitles(self):
+        return self._details.get('subtitles')

plexflow/core/torrents/analyzers/analyzer.py

@@ -0,0 +1,45 @@
+from plexflow.core.torrents.results.torrent import Torrent
+import requests
+from plexflow.core.torrents.analyzers.analyzed_torrent import AnalyzedTorrent
+from abc import ABC, abstractmethod
+
+class TorrentAnalyzer(ABC):
+    def __init__(self, torrent: Torrent):
+        self._torrent = torrent
+
+        self._resolved_urls = self.resolve_urls()
+        self._full_urls_content = '\n\n'.join(self._resolved_urls.values())        
+
+    def resolve_urls(self):
+        resolved_urls = {}
+        
+        if self._torrent.url:
+            print(f"Resolving URL: {self._torrent.url}")
+            r = requests.get(
+                url=self._torrent.url,
+                headers=self._headers,
+            )
+            
+            r.raise_for_status()
+            
+            html = r.text
+            
+            resolved_urls[self._torrent.url] = html
+        else:
+            print(f"Torrent {self._torrent} does not have a URL.")
+
+        return resolved_urls
+
+    @abstractmethod
+    def do_analysis(self):
+        pass
+    
+    def analyze(self):
+        details = self.do_analysis()
+        if isinstance(details, dict):
+            details = {
+                **details,
+                'resolved_urls': self._resolved_urls,
+                'html_content': self._full_urls_content,
+            }
+        return AnalyzedTorrent(self._torrent, **details)

plexflow/core/torrents/analyzers/torrentquest/analyzer.py

@@ -0,0 +1,47 @@
+from plexflow.core.torrents.results.torrent import Torrent
+from plexflow.utils.torrent.extract.torrentquest import extract_torrent_details
+import requests
+import re
+from plexflow.core.torrents.analyzers.analyzed_torrent import AnalyzedTorrent
+from plexflow.core.torrents.analyzers.analyzer import TorrentAnalyzer
+
+class TorrentQuestAnalyzer(TorrentAnalyzer):
+    def __init__(self, torrent: Torrent):
+        self._nfo_link_pattern = re.compile(r"information\('file_([^']+)'\)", re.IGNORECASE)
+
+        self._headers= {
+            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36'
+        }
+        
+        super().__init__(torrent)
+
+    def resolve_urls(self):
+        resolved_urls = super().resolve_urls()
+        
+        if len(resolved_urls) > 0:
+            html = next(iter(resolved_urls.values()))
+            nfo_match = next(re.finditer(self._nfo_link_pattern, html), None)
+            
+            if nfo_match:
+                nfo_id = nfo_match.group(1)
+                nfo_url = f"https://torrentquest.com/info/{nfo_id}"
+                
+                print(f"Resolving NFO URL: {nfo_url}")
+                r_nfo = requests.get(
+                    url=nfo_url,
+                    headers=self._headers,
+                )
+                
+                r_nfo.raise_for_status()
+                
+                nfo_html = r_nfo.text
+                
+                resolved_urls[nfo_url] = nfo_html
+        
+        return resolved_urls
+    
+    def do_analysis(self):
+        # resolve torrent URL and extract the torrent information from the page
+        details = extract_torrent_details(self._full_urls_content)
+        return details

plexflow/core/torrents/auto/auto_providers/auto/torrent.py

@@ -0,0 +1,64 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from plexflow.utils.torrent.hash import extract_torrent_hash
+import PTN
+
+class AutoTorrent(ABC):
+    def __init__(self, imdb_id: str, release_name: str, magnet_uri: str, source: str) -> None:
+        self._imdb_id = imdb_id
+        self._release_name = release_name
+        self._magnet_uri = magnet_uri
+        self._source = source
+
+    @property
+    @abstractmethod
+    def id(self) -> Any:
+        pass
+
+    @property
+    def hash(self) -> str:
+        return extract_torrent_hash(self.magnet_uri)
+
+    @property
+    def release_name(self) -> str:
+        return self._release_name
+
+    @property
+    def magnet_uri(self) -> str:
+        return self._magnet_uri
+
+    @property
+    def parsed_release_name(self) -> dict:
+        return PTN.parse(self.release_name)
+
+    @property
+    def title(self) -> str:
+        return self.parsed_release_name.get("title")
+
+    @property
+    def year(self) -> int:
+        return self.parsed_release_name.get("year")
+    
+    @property
+    def encoder(self) -> str:
+        return self.parsed_release_name.get("encoder")
+    
+    @property
+    def resolution(self) -> str:
+        return self.parsed_release_name.get("resolution")
+    
+    @property
+    def quality(self) -> str:
+        return self.parsed_release_name.get("quality")
+    
+    @property
+    def is_cam(self) -> bool:
+        return self.parsed_release_name.get("quality") == "CAM"
+
+    @property
+    def imdb_id(self) -> str:
+        return self._imdb_id
+
+    @property
+    def source(self) -> str:
+        return self._source

plexflow/core/torrents/auto/auto_providers/tpb/torrent.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from plexflow.utils.torrent.hash import extract_torrent_hash
+import PTN
+from plexflow.core.torrents.providers.tpb.utils import TPBSearchResult
+
+class AutoTPBTorrent(ABC):
+    def __init__(self, torrent: TPBSearchResult) -> None:
+        super().__init__(imdb_id=torrent.imdb_id, release_name=torrent.title, magnet_uri=torrent.magnet_uri, source="TPB")
+
+    @property
+    @abstractmethod
+    def id(self) -> Any:
+        pass
+
+    @property
+    def hash(self) -> str:
+        return extract_torrent_hash(self.magnet_uri)
+
+    @property
+    def release_name(self) -> str:
+        return self._release_name
+
+    @property
+    def magnet_uri(self) -> str:
+        return self._magnet_uri
+
+    @property
+    def parsed_release_name(self) -> dict:
+        return PTN.parse(self.release_name)
+
+    @property
+    def title(self) -> str:
+        return self.parsed_release_name.get("title")
+
+    @property
+    def year(self) -> int:
+        return self.parsed_release_name.get("year")
+    
+    @property
+    def encoder(self) -> str:
+        return self.parsed_release_name.get("encoder")
+    
+    @property
+    def resolution(self) -> str:
+        return self.parsed_release_name.get("resolution")
+    
+    @property
+    def quality(self) -> str:
+        return self.parsed_release_name.get("quality")
+    
+    @property
+    def is_cam(self) -> bool:
+        return self.parsed_release_name.get("quality") == "CAM"
+
+    @property
+    def imdb_id(self) -> str:
+        return self._imdb_id
+
+    @property
+    def source(self) -> str:
+        return self._source

plexflow/core/torrents/auto/auto_torrents.py

@@ -0,0 +1,29 @@
+from plexflow.core.torrents.providers.tpb.tpb import TPB
+from plexflow.core.torrents.providers.yts.yts import YTS
+from plexflow.core.torrents.providers.torrentquest.torrentquest import TorrentQuest
+from plexflow.core.torrents.providers.extratorrent.extratorrent import ExtraTorrent
+from plexflow.core.torrents.providers.ext.ext import Ext
+from plexflow.core.torrents.providers.snowfl.snowfl import Snowfl
+from plexflow.core.torrents.providers.therarbg.therarbg import TheRarbg
+from typing import List
+from plexflow.core.torrents.results.torrent import Torrent
+
+class AutoTorrents:
+    @staticmethod
+    def movie(imdb_id: str = None, query: str = None, source: str = 'yts', **kwargs) -> List[Torrent]:
+        if source == 'tpb':
+            return TPB(**kwargs).search(query=imdb_id)
+        elif source == 'yts':
+            return YTS(**kwargs).search(query=imdb_id)
+        elif source == 'torrentquest':
+            return TorrentQuest(**kwargs).search(query=query)
+        elif source == 'extratorrent':
+            return ExtraTorrent(**kwargs).search(query=query)
+        elif source == 'therarbg':
+            return TheRarbg(**kwargs).search(query=imdb_id)
+        elif source == 'ext':
+            return Ext(**kwargs).search(query=query)
+        elif source == 'snowfl':
+            return Snowfl(**kwargs).search(query=query)
+        else:
+            raise ValueError(f"Invalid source: {source}")

plexflow/core/torrents/providers/ext/ext.py

@@ -0,0 +1,18 @@
+from plexflow.utils.api.rest.antibot_restful import AntibotRestful
+from plexflow.core.torrents.providers.ext.utils import ExtSearchResult
+from plexflow.utils.torrent.extract.ext import extract_torrent_results
+from typing import List
+import os
+
+class Ext(AntibotRestful):
+    def __init__(self, base_url: str = 'https://ext.to', use_xvfb: bool = os.getenv('USE_XVFB', 'false').lower() == 'true'):
+        super().__init__(base_url=base_url, use_xvfb=use_xvfb)
+    
+    def search(self, query: str) -> List[ExtSearchResult]:
+        capture = self.get('/search', query_params={
+            'c': 'movies',
+            'q': query
+        })
+                        
+        data = extract_torrent_results(html=capture.html)
+        return list(map(lambda t: ExtSearchResult(**t), data))

plexflow/core/torrents/providers/ext/utils.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+from plexflow.core.torrents.results.torrent import Torrent
+from plexflow.utils.imdb.imdb_codes import IMDbCode
+from plexflow.utils.torrent.hash import extract_torrent_hash
+
+class ExtSearchResult(Torrent):
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._name = kwargs.get('name')
+        self._date = kwargs.get('date')
+        self._type = kwargs.get('type')
+        self._size = kwargs.get('size_bytes')
+        self._seeds = kwargs.get('seeds')
+        self._peers = kwargs.get('peers')
+        self._link = kwargs.get('link')
+        self.src = 'ext'
+
+    @property
+    def source(self) -> str:
+        return self.src
+
+    @property
+    def magnet(self) -> str:
+        return None
+
+    @property
+    def date(self) -> datetime:
+        return self._date
+
+    @property
+    def seeds(self) -> int:
+        return self._seeds
+
+    @property
+    def peers(self) -> int:
+        return self._peers
+
+    @property
+    def size_bytes(self) -> int:
+        return self._size
+
+    @property
+    def imdb_code(self) -> IMDbCode:
+        return None
+
+    @property
+    def release_name(self) -> str:
+        return self._name
+
+    @property
+    def hash(self) -> str:
+        return None
+
+    @property
+    def uploader(self) -> str:
+        return None
+
+    @property
+    def url(self) -> str:
+        return self._link
+
+    @property
+    def category(self) -> str:
+        return self._type

plexflow/core/torrents/providers/extratorrent/extratorrent.py

@@ -0,0 +1,21 @@
+from plexflow.utils.api.rest.antibot_restful import AntibotRestful
+from plexflow.core.torrents.providers.extratorrent.utils import ExtraTorrentSearchResult
+from plexflow.utils.torrent.extract.extratorrent import extract_torrent_results
+from typing import List
+import os
+
+class ExtraTorrent(AntibotRestful):
+    def __init__(self, base_url: str = 'https://extratorrent.st', use_xvfb: bool = os.getenv('USE_XVFB', 'false').lower() == 'true'):
+        super().__init__(base_url=base_url, use_xvfb=use_xvfb)
+    
+    def search(self, query: str) -> List[ExtraTorrentSearchResult]:
+        capture = self.get('/search', query_params={
+            'search': query,
+            'new': 1,
+            'x': 0,
+            'y': 0,
+            's_cat': 1,
+        })
+        
+        data = extract_torrent_results(html=capture.html)
+        return list(map(lambda t: ExtraTorrentSearchResult(**t), data))