plexflow 0.0.64__py3-none-any.whl

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

@@ -0,0 +1,66 @@
+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 ExtraTorrentSearchResult(Torrent):
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._magnet = kwargs.get('magnet_link')
+        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._uploader = kwargs.get('uploader')
+        self.src = 'extratorrent'
+
+    @property
+    def source(self) -> str:
+        return self.src
+
+    @property
+    def magnet(self) -> str:
+        return self._magnet
+
+    @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 extract_torrent_hash(self._magnet)
+
+    @property
+    def uploader(self) -> str:
+        return self._uploader
+
+    @property
+    def url(self) -> str:
+        return self._link
+
+    @property
+    def category(self) -> str:
+        return self._type

plexflow/core/torrents/providers/eztv/eztv.py

@@ -0,0 +1,47 @@
+from plexflow.utils.api.rest.restful import Restful
+from plexflow.core.torrents.providers.eztv.utils import EZTVSearchResult
+
+class EZTV(Restful):
+    """EZTV class to interact with the EZTV API.
+
+    This class inherits from the Restful class and provides an interface to
+    interact with the EZTV API. It provides a method to search for torrents
+    using an IMDb ID.
+
+    Attributes:
+        http_conn_id (str): The connection ID for the HTTP connection.
+        config_folder (str): The folder where the configuration files are stored.
+    """
+
+    def __init__(self, base_url: str = 'https://eztv.re'):
+        """Initializes EZTV with the given HTTP connection ID and config folder."""
+        super().__init__(base_url=base_url)
+    
+    def search(self, imdb_id: str):
+        """Searches for torrents using an IMDb ID.
+
+        This method takes an IMDb ID as input, normalizes it by removing the
+        leading 'tt' and any leading zeros, and then makes a GET request to
+        the EZTV API to search for torrents. It raises an exception if the
+        response status is not OK, and returns a list of EZTVSearchResult
+        objects if the response is OK.
+
+        Args:
+            imdb_id (str): The IMDb ID to search for.
+
+        Returns:
+            list[EZTVSearchResult]: A list of EZTVSearchResult objects.
+        """
+        # Normalize the imdb_id by removing leading 'tt' and zeros
+        imdb_id = imdb_id.lstrip('tt')
+
+        response = self.get(url='/api/get-torrents', query_params={
+            'imdb_id': imdb_id,
+        })
+        
+        response.raise_for_status()
+        
+        # TODO pagination
+        data = response.json()
+        
+        return list(map(lambda x: EZTVSearchResult(**x), data.get("torrents", [])))

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

@@ -0,0 +1,83 @@
+from datetime import datetime
+from plexflow.core.torrents.results.torrent import Torrent
+from plexflow.utils.imdb.imdb_codes import IMDbCode
+
+class EZTVSearchResult(Torrent):
+    """EZTVSearchResult class to handle the data structure returned by the EZTV API.
+
+    This class inherits from the Torrent class and provides an interface to
+    interact with the EZTV API. It provides a method to search for torrents
+    using an IMDb ID.
+
+    Attributes:
+        id (str): The ID of the torrent.
+        hash (str): The hash of the torrent.
+        filename (str): The filename of the torrent.
+        torrent_url (str): The URL of the torrent.
+        magnet_url (str): The magnet URL of the torrent.
+        title (str): The title of the torrent.
+        imdb_id (str): The IMDb ID of the torrent.
+        season (str): The season of the torrent.
+        episode (str): The episode of the torrent.
+        small_screenshot (str): The small screenshot of the torrent.
+        large_screenshot (str): The large screenshot of the torrent.
+        seeds (int): The number of seeds of the torrent.
+        peers (int): The number of peers of the torrent.
+        date_released_unix (int): The release date of the torrent in Unix time.
+        size_bytes (int): The size of the torrent in bytes.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        self.id = kwargs.get("id")
+        self._hash = kwargs.get("hash")
+        self.filename = kwargs.get("filename")
+        self.torrent_url = kwargs.get("torrent_url")
+        self.magnet_url = kwargs.get("magnet_url")
+        self._title = kwargs.get("title")
+        self.imdb_id = kwargs.get("imdb_id")
+        self._season = kwargs.get("season")
+        self._episode = kwargs.get("episode")
+        self.small_screenshot = kwargs.get("small_screenshot")
+        self.large_screenshot = kwargs.get("large_screenshot")
+        self._seeds = kwargs.get("seeds")
+        self._peers = kwargs.get("peers")
+        self.date_released_unix = kwargs.get("date_released_unix")
+        self._size_bytes = kwargs.get("size_bytes")
+        self.src = "eztv"
+
+    @property
+    def magnet(self) -> str:
+        return self.magnet_url
+
+    @property
+    def hash(self) -> str:
+        return self._hash
+    
+    @property
+    def peers(self) -> str:
+        return self._peers
+    
+    @property
+    def seeds(self) -> str:
+        return self._seeds
+    
+    @property
+    def size_bytes(self) -> str:
+        return int(self._size_bytes)
+
+    @property
+    def date(self) -> datetime:
+        return datetime.fromtimestamp(self.date_released_unix)
+
+    @property
+    def imdb_code(self) -> IMDbCode:
+        return IMDbCode(self.imdb_id)
+
+    @property
+    def release_name(self) -> str:
+        return self._title
+
+    @property
+    def torrent_id(self) -> str:
+        return str(self.id)

plexflow/core/torrents/providers/rarbg2/rarbg2.py

@@ -0,0 +1,19 @@
+import requests
+from dataclasses import dataclass
+import json
+from plexflow.utils.api.rest.restful import Restful
+from plexflow.core.torrents.providers.rarbg2.utils import RARBG2SearchResult
+
+class RARBG2(Restful):
+    def __init__(self, http_conn_id: str = 'rarbg2_hook', config_folder: str = 'config'):
+        super().__init__(http_conn_id=http_conn_id, config_folder=config_folder)
+    
+    def search(self, query: str):
+        # query params does not work due to odd values in q parameter
+        response = self.get(f'/api.php?url=/q.php?q={query}')
+        
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        return list(map(lambda x: RARBG2SearchResult(**x), data))

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

@@ -0,0 +1,76 @@
+from datetime import datetime
+from plexflow.core.torrents.results.torrent import Torrent
+from plexflow.utils.imdb.imdb_codes import IMDbCode
+
+class RARBG2SearchResult(Torrent):
+    id: str
+    name: str
+    info_hash: str
+    leechers: str
+    seeders: str
+    num_files: str
+    size: str
+    username: str
+    added: str
+    status: str
+    category: str
+    imdb: str
+    
+    def __init__(self, **kwargs):
+        self.id = kwargs.get("id")
+        self.name = kwargs.get("name")
+        self.info_hash = kwargs.get("info_hash")
+        self.leechers = kwargs.get("leechers")
+        self.seeders = kwargs.get("seeders")
+        self.num_files = kwargs.get("num_files")
+        self.size = kwargs.get("size")
+        self.username = kwargs.get("username")
+        self.added = kwargs.get("added")
+        self.status = kwargs.get("status")
+        self.category = kwargs.get("category")
+        self.imdb = kwargs.get("imdb")
+        self.src = "rarbg2"
+
+    @property
+    def magnet(self) -> str:
+        return f'magnet:?xt=urn:btih:{self.info_hash}'
+
+    @property
+    def date(self) -> datetime:
+        return datetime.fromtimestamp(int(self.added))
+
+    @property
+    def seeds(self) -> int:
+        return int(self.seeders)
+
+    @property
+    def peers(self) -> int:
+        return int(self.leechers)
+
+    @property
+    def n_files(self) -> int:
+        return int(self.num_files)
+
+    @property
+    def size_bytes(self) -> int:
+        return int(self.size)
+
+    @property
+    def imdb_code(self) -> IMDbCode:
+        return IMDbCode(self.imdb)
+
+    @property
+    def hash(self) -> str:
+        return self.info_hash
+    
+    @property
+    def release_name(self) -> str:
+        return self.name
+
+    @property
+    def uploader(self) -> str:
+        return self.username
+
+    @property
+    def torrent_id(self) -> str:
+        return self.id

plexflow/core/torrents/providers/snowfl/snowfl.py

@@ -0,0 +1,36 @@
+from plexflow.utils.api.rest.restful import Restful
+from plexflow.core.torrents.providers.snowfl.utils import SnowflSearchResult
+import urllib.parse
+
+class Snowfl(Restful):
+    def __init__(self, base_url: str = 'https://snowfl.com'):
+        super().__init__(base_url=base_url)
+    
+    def search(self, query: str):
+        # lets use quote_plus to encode the query
+        encoded_query = urllib.parse.quote(query)
+        response = self.get(
+            url=f'/jZEQIcyiahCKmuKDzRzbwkSbyQHFzQnLTWnocRed/{encoded_query}/40d5GE72/1/SEED/NONE/1',
+            headers={
+            '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',
+            'x-requested-with': 'XMLHttpRequest'
+            }
+        )
+        
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        if isinstance(data, list):
+            return list(map(lambda t: SnowflSearchResult(**t), data))
+
+
+if __name__ == '__main__':
+    snowfl = Snowfl()
+    torrents = snowfl.search('Twisters 2024')
+    
+    print(len(torrents), "torrents found")
+    
+    for t in torrents:
+        print(t.release_name, t.url)
+

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

@@ -0,0 +1,59 @@
+from datetime import datetime
+from plexflow.core.torrents.results.torrent import Torrent
+from plexflow.utils.imdb.imdb_codes import IMDbCode
+import dateparser
+from plexflow.utils.strings.filesize import parse_size
+from plexflow.utils.torrent.hash import extract_torrent_hash
+
+class SnowflSearchResult(Torrent):
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._url = kwargs.get("url")
+        self._magnet = kwargs.get("magnet")
+        self._type = kwargs.get("type")
+        self._seeds = kwargs.get("seeder")
+        self._peers = kwargs.get("leecher")
+        self._size = kwargs.get("size")
+        self._size_bytes = next(iter(parse_size(self._size)), None)
+        self._age = kwargs.get("age")
+        self._date = dateparser.parse(f"{self._age} ago")
+        self._name = kwargs.get("name")
+        self.src = "snowfl"
+
+    @property
+    def magnet(self) -> str:
+        return self._magnet
+
+    @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_bytes
+
+    @property
+    def imdb_code(self) -> IMDbCode:
+        return None
+
+    @property
+    def release_name(self) -> str:
+        return self._name
+
+    @property
+    def hash(self) -> str:
+        return extract_torrent_hash(self._magnet)
+    
+    @property
+    def url(self) -> str:
+        return self._url
+
+

plexflow/core/torrents/providers/tgx/context.py

@@ -0,0 +1,50 @@
+from playwright.sync_api import sync_playwright
+import time
+from typing import List, Optional
+from pydantic import BaseModel
+
+class TorrentGalaxyContext(BaseModel):
+    cookies: Optional[List[dict]]
+    screenshot_bytes: Optional[bytes]
+    url: str
+    headless: bool = True
+    domain: str
+    torrent_id: str
+    wait_seconds: int
+    
+
+def get_request_context(headless: bool = True, 
+                        domain: str = "torrentgalaxy.to", 
+                        torrent_id: str = "16100045",
+                        wait_seconds: int = 10) -> TorrentGalaxyContext:
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=headless)
+        context = browser.new_context()
+        page = context.new_page()
+
+        # Navigate to the URL
+        url = f"https://{domain}/torrent/{torrent_id}"
+        page.goto(url)
+
+        # Wait for the page to load completely
+        time.sleep(wait_seconds)
+        
+        # Take a screenshot and get the image bytes
+        page.set_viewport_size({"width": 1920, "height": 1080})
+        screenshot_bytes = page.screenshot(full_page=True)
+
+        # Retrieve cookies
+        cookies = context.cookies()
+
+        # Close the browser
+        browser.close()
+    
+    return TorrentGalaxyContext(
+        cookies=cookies,
+        screenshot_bytes=screenshot_bytes,
+        url=url,
+        headless=headless,
+        domain=domain,
+        torrent_id=torrent_id,
+        wait_seconds=wait_seconds
+    )

plexflow/core/torrents/providers/tgx/dump.py

@@ -0,0 +1,40 @@
+import pandas as pd
+import re
+from typing import Optional
+from plexflow.utils.download.gz import download_and_extract_gz
+
+ID_PATTERN = re.compile(r'/torrent/(\d+)/', re.IGNORECASE)
+
+def extract_id(url: str) -> Optional[str]:
+    """
+    Extracts the ID from the given URL using a regular expression.
+
+    Args:
+        url (str): The URL from which to extract the ID.
+
+    Returns:
+        str: The extracted ID if found, otherwise None.
+    """
+    match = ID_PATTERN.search(url)
+    return match.group(1) if match else None
+
+def read_and_transform_dump(url: str, output_filename: str) -> pd.DataFrame:
+    """
+    Downloads, extracts, and transforms a gzipped dump file into a DataFrame.
+
+    This function downloads a gzipped dump file from the specified URL, extracts it, 
+    and reads the data into a DataFrame. It then renames the columns and adds a new 
+    column 'id' by extracting the ID from the 'url' column.
+
+    Args:
+        url (str): The URL of the gzipped dump file to download.
+        output_filename (str): The filename for the extracted file.
+
+    Returns:
+        pd.DataFrame: The transformed DataFrame.
+    """
+    download_and_extract_gz(url, output_filename)
+
+    df = pd.read_csv(output_filename, sep='|', header=None, names=["hash", "name", "category", "url", "torrent"])
+    df["id"] = df.url.apply(extract_id)
+    return df

plexflow/core/torrents/providers/tgx/tgx.py

@@ -0,0 +1,22 @@
+from plexflow.utils.api.rest.restful import Restful
+from plexflow.core.torrents.providers.tgx.utils import TGXSearchResult
+
+class TGX(Restful):
+    def __init__(self, postgres_conn_id: str = 'postgresql_hook', config_folder: str = 'config'):
+        super().__init__(postgres_conn_id=postgres_conn_id, config_folder=config_folder)
+    
+    def search(self, imdb: str):
+        rows = self.get_all("""
+                        SELECT 
+                            * 
+                        FROM tgx.results 
+                        WHERE 
+                            imdb = %(imdb)s 
+                        AND
+                            category IN ('movies', 'tv')
+                        LIMIT 1000
+                     """, params={
+                         "imdb": imdb, 
+                     })
+                
+        return list(map(lambda x: TGXSearchResult(**x), rows))

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

@@ -0,0 +1,61 @@
+from datetime import datetime
+from plexflow.core.torrents.results.torrent import Torrent
+from plexflow.utils.imdb.imdb_codes import IMDbCode
+
+class TGXSearchResult(Torrent):
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._id = kwargs.get("id")
+        self._name = kwargs.get("name")
+        self._category = kwargs.get("category")
+        self._sub_category = kwargs.get("sub_category")
+        self._date_added = kwargs.get("date_added")
+        self._uploader = kwargs.get("uploader")
+        self._peers = kwargs.get("peers")
+        self._seeds = kwargs.get("seeds")
+        self._imdb = kwargs.get("imdb")
+        self._imdb_link = kwargs.get("imdb_link")
+        self._magnet = kwargs.get("magnet")
+        self._hash = kwargs.get("hash")
+        self._language = kwargs.get("language")
+        self._subtitles = kwargs.get("subtitles")
+        self._deleted = kwargs.get("deleted")
+        self._errored = kwargs.get("errored")
+        self._date_last_scrape = kwargs.get("date_last_scrape")
+        self._size_bytes = kwargs.get("size_bytes")
+        self.src = "tgx"
+
+    @property
+    def magnet(self) -> str:
+        return self._magnet
+
+    @property
+    def date(self) -> datetime:
+        parts = self._date_added.split(" ")
+        if len(parts) > 0:
+            return datetime.strptime(parts[0], "%d-%m-%Y")
+
+    @property
+    def seeds(self) -> int:
+        return self._seeds
+
+    @property
+    def peers(self) -> int:
+        return self._peers
+
+    @property
+    def size_bytes(self) -> int:
+        return round(self._size_bytes)
+
+    @property
+    def imdb_code(self) -> IMDbCode:
+        return IMDbCode(self._imdb)
+
+    @property
+    def release_name(self) -> str:
+        return self._name
+
+    @property
+    def hash(self) -> str:
+        return self._hash
+

plexflow/core/torrents/providers/therarbg/therarbg.py

@@ -0,0 +1,17 @@
+from plexflow.utils.api.rest.antibot_restful import AntibotRestful
+from plexflow.utils.api.rest.restful import Restful
+from plexflow.core.torrents.providers.therarbg.utils import TheRarbgSearchResult
+from plexflow.utils.torrent.extract.therarbg import extract_torrent_results
+from typing import List
+
+class TheRarbg(Restful):
+    def __init__(self, base_url: str = 'https://therarbg.com'):
+        super().__init__(base_url=base_url)
+    
+    def search(self, query: str) -> List[TheRarbgSearchResult]:
+        response = self.get(f'/get-posts/keywords:{query}/')
+        
+        response.raise_for_status
+        
+        data = extract_torrent_results(html=response.text)
+        return list(map(lambda t: TheRarbgSearchResult(**t), data))

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

@@ -0,0 +1,61 @@
+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 TheRarbgSearchResult(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._imdb = kwargs.get('imdb')
+        self.src = 'therarbg'
+
+    @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 self._imdb
+
+    @property
+    def release_name(self) -> str:
+        return self._name
+
+    @property
+    def hash(self) -> str:
+        return extract_torrent_hash(self._magnet)
+
+    @property
+    def url(self) -> str:
+        return self._link
+
+    @property
+    def category(self) -> str:
+        return self._type

plexflow/core/torrents/providers/torrentquest/torrentquest.py

@@ -0,0 +1,20 @@
+from plexflow.utils.api.rest.antibot_restful import AntibotRestful
+from plexflow.core.torrents.providers.torrentquest.utils import TorrentQuestSearchResult
+from plexflow.utils.torrent.extract.torrentquest import extract_torrent_results
+from typing import List
+import os
+
+class TorrentQuest(AntibotRestful):
+    def __init__(self, base_url: str = 'https://torrentquest.com', 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[TorrentQuestSearchResult]:
+        capture = self.get('/search', query_params={
+            'q': query,
+            'm': '1',
+            'x': '14',
+            'y': '17',
+        }, wait_condition='regex', wait_value='Download Name')
+        
+        data = extract_torrent_results(html=capture.html)
+        return list(map(lambda t: TorrentQuestSearchResult(**t), data))