plexflow 0.0.64__py3-none-any.whl

plexflow/utils/torrent/extract/tgx.py

@@ -0,0 +1,96 @@
+import re
+from bs4 import BeautifulSoup
+from plexflow.utils.subtitle.search import SubtitleSearcher
+from plexflow.utils.imdb.imdb_codes import extract_imdb_code
+
+def extract_torrent_info(html_content):
+    """Extracts torrent information from the provided HTML content,
+    searching for IMDb ID pattern in links and plain text.
+
+    Args:
+        html_content (str): The HTML content of the webpage.
+
+    Returns:
+        dict: A dictionary containing the extracted information with
+              lowercase keys, or None if the information is not found.
+    """
+
+    soup = BeautifulSoup(html_content, 'html.parser')
+    text = soup.get_text(separator='\n')
+
+    info = {}
+
+    # release_name
+    match = re.search(r"Torrent details for \"(.*?)\"", text)
+    info["release_name"] = match.group(1).lower() if match else None
+
+    # category and subcategory
+    match = re.search(
+        r"Category:\s*(.*?)\s*>\s*(.*?)$", text, re.MULTILINE
+    )
+    info["category"] = match.group(1).strip().lower() if match else None
+    info["subcategory"] = match.group(2).strip().lower() if match else None
+
+    # language
+    match = re.search(r"Language:\s*(.*?)$", text, re.MULTILINE)
+    info["language"] = match.group(1).strip().lower() if match else None
+
+    # total_size (Handling different units)
+    match = re.search(r"Total Size:\s*([\d.]+)\s*(GB|MB|KB)", text, re.IGNORECASE)
+    if match:
+        size_value = float(match.group(1))
+        size_unit = match.group(2).upper()
+        if size_unit == "GB":
+            info["total_size"] = size_value * 1024 * 1024 * 1024
+        elif size_unit == "MB":
+            info["total_size"] = size_value * 1024 * 1024
+        elif size_unit == "KB":
+            info["total_size"] = size_value * 1024
+    else:
+        info["total_size"] = None
+
+    # hash
+    match = re.search(r"Info Hash:\s*(.*?)$", text, re.MULTILINE)
+    info["hash"] = match.group(1).strip().lower() if match else None
+
+    # uploader
+    match = re.search(r"Added By:\s*(.*?)\s*Added", text, re.MULTILINE)
+    info["uploader"] = match.group(1).strip().lower() if match else None
+
+    # date
+    match = re.search(r"Added:\s*(.*?)$", text, re.MULTILINE)
+    info["date"] = match.group(1).strip().lower() if match else None
+
+    # seeds
+    match = re.search(r"Seeds:?\s*(\d+)", text)
+    info["seeds"] = int(match.group(1)) if match else None
+
+    # peers
+    match = re.search(r"Leechers:?\s*(\d+)", text)
+    info["peers"] = int(match.group(1)) if match else None
+
+    # imdb_id
+    imdb_id = next(extract_imdb_code(html_content), None)
+    info["imdb_id"] = imdb_id
+
+    # description (Extract up to the comments section)
+    match = re.search(
+        r"Description(.*?)User comments", text, re.IGNORECASE | re.DOTALL
+    )
+    info["description"] = match.group(1).strip().lower() if match else None
+
+    # magnet_url
+    match = re.search(r"magnet:\?xt=urn:btih:[a-z0-9]+[^'\"]+", html_content, re.IGNORECASE)
+    info["magnet_url"] = match.group(0) if match else None 
+    
+    searcher = SubtitleSearcher(hint_words={
+        "english",
+        "eng",
+        "dutch",
+        "dut"
+    })
+    
+    subtitles = searcher.search_subtitles(text)
+    info["subtitles"] = subtitles
+    
+    return info

plexflow/utils/torrent/extract/therarbg.py

@@ -0,0 +1,170 @@
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+import dateparser
+from plexflow.utils.strings.filesize import parse_size
+from plexflow.utils.imdb.imdb_codes import extract_imdb_code
+import re
+from plexflow.utils.torrent.files import TorrentFile
+from plexflow.utils.torrent.extract.common import torrent_detail_extract
+
+@torrent_detail_extract
+def extract_torrent_details(html_content, **torrent_details):
+    """Extracts specific torrent details from the given HTML content,
+       with increased robustness against HTML structure changes and case sensitivity.
+
+    Args:
+        html_content: The HTML content of the torrent page.
+
+    Returns:
+        A dictionary containing the extracted torrent details.
+    """
+
+    soup = BeautifulSoup(html_content, 'html.parser')
+
+    # Extract all text from the HTML
+    all_text = soup.get_text()
+
+    # Torrent name
+    torrent_details['release_name'] = re.search(r':\s*([^:]+)\s*:\s*Search', all_text, re.IGNORECASE).group(1).strip()
+
+    # Torrent size (capture only the number)
+    size_text = re.search(r'Size:\s*(\d+\.?\d*\s*\w+)', all_text, re.IGNORECASE)
+    if size_text:
+        torrent_details['torrent_size'] = size_text.group(1).strip()
+        torrent_details["size_bytes"] = next(iter(parse_size(torrent_details['torrent_size'])), None)
+
+    # Peers (Leechers)
+    peers_text = re.search(r'Leechers:\s*(\d+)', all_text, re.IGNORECASE)
+    if peers_text:
+        torrent_details['peers'] = int(peers_text.group(1))
+
+    # Seeds
+    seeds_text = re.search(r'Seeders:\s*(\d+)', all_text, re.IGNORECASE)
+    if seeds_text:
+        torrent_details['seeds'] = int(seeds_text.group(1))
+
+    # Total files
+    files_text = re.search(r'Files:\s*(\d+)', all_text, re.IGNORECASE)
+    if files_text:
+        torrent_details['total_files'] = int(files_text.group(1))
+
+    # Date of upload
+    upload_text = re.search(r'Added:\s*([^,]+)', all_text, re.IGNORECASE)
+    if upload_text:
+        torrent_details['date'] = dateparser.parse(upload_text.group(1).strip()).isoformat()
+
+    # Uploader
+    uploader_text = re.search(r'Uploader:\s*([^<]+)', all_text, re.IGNORECASE)
+    if uploader_text:
+        torrent_details['uploader'] = uploader_text.group(1).strip()
+
+    # Info hash
+    info_hash_text = re.search(r'Info Hash:\s*([\dA-F]+)', all_text, re.IGNORECASE)
+    if info_hash_text:
+        torrent_details['hash'] = info_hash_text.group(1).strip()
+
+    # File list (extract from text using surrounding context)
+    torrent_details['file_list'] = []
+    file_list_start = re.search(r'Files:\s*\d+', all_text, re.IGNORECASE)
+    if file_list_start:
+        file_list_start_index = file_list_start.end()
+        file_list_end = re.search(r'Multiple Quality Available', all_text, re.IGNORECASE)
+        if file_list_end:
+            file_list_end_index = file_list_end.start()
+            file_list_text = all_text[file_list_start_index:file_list_end_index]
+            
+            file_entries = file_list_text.strip().splitlines()
+            
+            for entry in file_entries:
+                # Extract file name and size
+                name_match = re.search(r'(.+)\s*(\d+\.?\d*\s*(GB|MB|KB|B))', entry, re.IGNORECASE)
+                name = name_match.group(1).strip() if name_match else None
+                size = name_match.group(2).strip() if name_match else None
+                                
+                torrent_details['file_list'].append(TorrentFile(
+                    name=name,
+                    size=size,
+                ))
+
+    # Category
+    category_text = re.search(r'Category:\s*([^<]+)', all_text, re.IGNORECASE)
+    if category_text:
+        torrent_details['category'] = category_text.group(1).strip()
+
+    return torrent_details
+
+
+def extract_torrent_results(html):
+    """Extracts torrent information from HTML, resilient to HTML structure changes.
+
+    Args:
+        html: The HTML content of the page.
+
+    Returns:
+        A list of dictionaries, each containing torrent information:
+            - 'title': The title of the torrent.
+            - 'link': The link to the torrent detail page.
+            - 'category': The category of the torrent.
+            - 'added': The date the torrent was added.
+            - 'size': The size of the torrent.
+            - 'seeders': The number of seeders.
+            - 'leechers': The number of leechers.
+            - 'thumbnail': The URL of the torrent thumbnail (if available).
+    """
+
+    torrents = []
+    soup = BeautifulSoup(html, 'html.parser')
+
+    # Find all table rows that likely contain torrent information
+    rows = soup.find_all('tr', class_='list-entry')
+
+    for row in rows:
+        torrent = {}
+
+        # Extract data from the cells
+        cells = row.find_all('td')
+
+        # Title (get full title from link href)
+        title_cell = cells[1]
+        title_link = title_cell.find('div', class_='wrapper').find('a', recursive=False)
+        if title_link:
+            # Get the part of the href after the last '/'
+            torrent['link'] = urljoin('https://therarbg.com/', title_link['href'])
+            torrent['name'] = torrent['link'].rstrip('/').split('/')[-1]  # Use rsplit for last occurrence
+        else:
+            # If no link is found, get the text of the title cell
+            torrent['name'] = title_cell.text.strip()
+            torrent['link'] = ''
+
+        # lets search in all links of the cell
+        # for an imdb id
+        for link in title_cell.find_all('a'):
+          href = link.get('href')
+          if isinstance(href, str):
+            imdb_code = next(extract_imdb_code(href), None)
+            if isinstance(imdb_code, str):
+              torrent['imdb'] = imdb_code
+              break
+            
+        # Category
+        torrent['type'] = cells[2].find('a').text.strip() if cells[2].find('a') else ''
+
+        # Added
+        added_cell = cells[3]
+        torrent['added'] = added_cell.text.strip() if added_cell else ''
+        torrent['date'] = dateparser.parse(torrent['added'])
+        
+        # Size
+        size_cell = cells[5]
+        torrent['size'] = size_cell.text.strip() if size_cell else ''
+        torrent['size_bytes'] = next(iter(parse_size(torrent['size'])), None)
+        
+        # Seeders and Leechers
+        seeders_cell = cells[6]
+        torrent['seeds'] = int(seeders_cell.text.strip()) if seeders_cell else 0
+        leechers_cell = cells[7]
+        torrent['peers'] = int(leechers_cell.text.strip()) if leechers_cell else 0
+
+        torrents.append(torrent)
+
+    return torrents

plexflow/utils/torrent/extract/torrentquest.py

@@ -0,0 +1,171 @@
+from bs4 import BeautifulSoup
+import dateparser
+from plexflow.utils.strings.filesize import parse_size
+import re
+from plexflow.utils.strings.filesize import parse_size
+from plexflow.utils.torrent.files import TorrentFile
+from plexflow.utils.torrent.extract.common import torrent_detail_extract
+
+@torrent_detail_extract
+def extract_torrent_details(html_content, **torrent_details):
+    """Extracts specific torrent details from the given HTML content,
+       with increased robustness against HTML structure changes and case sensitivity.
+
+    Args:
+        html_content: The HTML content of the torrent page.
+
+    Returns:
+        A dictionary containing the extracted torrent details.
+    """
+
+    soup = BeautifulSoup(html_content, 'html.parser')
+
+    # Torrent name
+    # Extract the text from the 'header-content' class
+    torrent_details['release_name'] = soup.find('div', class_='header-content').get_text().strip()
+
+    # Extract all text from the HTML
+    all_text = soup.get_text()
+
+    # Torrent size (capture only the number)
+    size_text = re.search(r'Total Size:\s*(\d+\.?\d*\s*\w+)', all_text, re.IGNORECASE)
+    if size_text:
+        torrent_details['torrent_size'] = size_text.group(1).strip()
+        torrent_details["size_bytes"] = next(iter(parse_size(torrent_details['torrent_size'])), None)
+
+    # Peers (Leechers)
+    peers_text = re.search(r'Leechers:\s*\d+', all_text, re.IGNORECASE)
+    if peers_text:
+        torrent_details['peers'] = int(peers_text.group(0).split()[-1])
+
+    # Seeds
+    seeds_text = re.search(r'Seeders:\s*\d+', all_text, re.IGNORECASE)
+    if seeds_text:
+        torrent_details['seeds'] = int(seeds_text.group(0).split()[-1])
+
+    # Total files
+    files_text = re.search(r'Total Files:\s*\d+', all_text, re.IGNORECASE)
+    if files_text:
+        torrent_details['total_files'] = int(files_text.group(0).split()[-1])
+
+    # Date of upload
+    upload_text = re.search(r'Uploaded:\s*\d{1,2}-\w{3}-\d{4}', all_text, re.IGNORECASE)
+    if upload_text:
+        torrent_details['date'] = upload_text.group(0).split()[-1]
+
+    # Uploader
+    uploader_text = re.search(r'Uploader:\s*\w+', all_text, re.IGNORECASE)
+    if uploader_text:
+        torrent_details['uploader'] = uploader_text.group(0).split()[-1]
+
+    # Info hash
+    info_hash_text = re.search(r'Info Hash:\s*[\dA-F]+', all_text, re.IGNORECASE)
+    if info_hash_text:
+        torrent_details['hash'] = info_hash_text.group(0).split()[-1]
+
+    # File list (extract from text using surrounding context)
+    torrent_details['file_list'] = []
+    file_list_start = re.search(r'File List Information', all_text, re.IGNORECASE)
+    if file_list_start:
+        file_list_start_index = file_list_start.end()
+        file_list_end = re.search(r'Related Downloads|Help Downloading', all_text, re.IGNORECASE)
+        if file_list_end:
+            file_list_end_index = file_list_end.start()
+            file_list_text = all_text[file_list_start_index:file_list_end_index]
+            
+            file_entries = file_list_text.strip().splitlines()
+            
+            for entry in file_entries:
+                # Extract file name and size
+                name_match = re.search(r'(.+)\s*\(\d+\.?\d*\s*(GB|MB|KB|B)\)', entry, re.IGNORECASE)
+                # the size is always at the end, so lets search from the end
+                size_matches = re.findall(r'\(([^)]+)\)', entry, re.IGNORECASE)
+                print(size_matches)
+                
+                name = name_match.group(1).strip() if name_match else None
+                if len(size_matches) > 0:
+                    size = size_matches[-1].strip()
+                else:
+                    size = None
+                                
+                torrent_details['file_list'].append(TorrentFile(
+                    name=name,
+                    size=size,
+                ))
+
+    # Category
+    category_text = re.search(r'Category:\s*\w+', all_text, re.IGNORECASE)
+    if category_text:
+        torrent_details['category'] = category_text.group(0).split()[-1]
+
+    return torrent_details
+
+
+def extract_torrent_results(html):
+    """
+    Extracts torrent results from HTML content, resilient to changes in HTML structure.
+
+    Args:
+        html: The HTML content as a string.
+
+    Returns:
+        A list of dictionaries, each representing a torrent result with keys:
+            - 'download_name': The name of the torrent.
+            - 'magnet_link': The magnet link for the torrent.
+            - 'age': The age of the torrent.
+            - 'torrent_type': The type of the torrent (e.g., Movie, Game, etc.).
+            - 'files': The number of files in the torrent.
+            - 'size': The size of the torrent.
+            - 'seeders': The number of seeders for the torrent.
+            - 'leechers': The number of leechers for the torrent.
+    """
+
+    soup = BeautifulSoup(html, 'html.parser')
+    torrent_results = []
+
+    # Find all 'a' tags with 'magnet' in the href attribute
+    magnet_links = soup.find_all('a', href=lambda href: 'magnet' in href)
+
+    # Iterate over each magnet link
+    for magnet_link in magnet_links:
+        torrent_result = {'magnet_link': magnet_link['href']}
+
+        # Find the parent 'tr' (table row) of the magnet link
+        parent_row = magnet_link.find_parent('tr')
+        if parent_row:
+            cols = parent_row.find_all('td')
+
+            # Extract data from columns based on their position 
+            # (assuming consistent layout within the table row)
+            if len(cols) >= 8:
+                torrent_result['name'] = cols[1].find('a').text.strip()
+                # get link of name
+                link = cols[1].find('a')['href']
+                # make it a full link
+                torrent_result['link'] = f"https://torrentquest.com{link}"
+                age = cols[2].text.strip()
+                torrent_result['age'] = age
+                if isinstance(age, str):
+                    age_str = f"{age} ago"
+                    date = dateparser.parse(age_str)
+                    torrent_result['date'] = date
+                else:
+                    torrent_result['date'] = None
+                torrent_result['type'] = cols[3].text.strip().lower()
+                torrent_result['files'] = cols[4].text.strip()
+                size_human = cols[5].text.strip()
+                torrent_result['size'] = size_human
+
+                if isinstance(size_human, str):
+                    sizes = parse_size(size_human)
+                    if sizes:
+                        torrent_result['size_bytes'] = sizes[0]
+                    else:
+                        torrent_result['size_bytes'] = None
+                
+                torrent_result['seeds'] = cols[6].text.strip()
+                torrent_result['peers'] = cols[7].text.strip()
+
+        torrent_results.append(torrent_result)
+
+    return torrent_results

plexflow/utils/torrent/files.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel
+from plexflow.utils.strings.filesize import parse_size
+from pathlib import Path
+from typing import Optional
+
+class TorrentFile(BaseModel):
+    name: Optional[str]
+    size: Optional[str]
+    
+    @property
+    def size_bytes(self):
+        return next(iter(parse_size(self.size)), None) if self.size else None
+
+    @property
+    def size_human(self):
+        return self.size
+    
+    @property
+    def extension(self):
+        return Path(self.name).suffix.lstrip('.') if self.name else None
+
+    def __str__(self) -> str:
+        return f"{self.name} [({self.size_human})][{self.extension}][{self.size_bytes} bytes]"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+class TorrentSubtitle(BaseModel):
+    language: Optional[str]
+    name: Optional[str]
+    
+    def __str__(self) -> str:
+        return f"{self.language} - {self.name}"
+    
+    def __repr__(self) -> str:
+        return self.__str__()

plexflow/utils/torrent/hash.py

@@ -0,0 +1,90 @@
+import re
+
+def extract_hash(s: str):
+    """
+    Extract all potential SHA-1 hashes from an arbitrary string.
+
+    This function uses a generator to lazily yield each potential hash as it is found,
+    which can be more memory-efficient than returning a list of all hashes, especially
+    for large input strings with many potential hashes.
+
+    Parameters:
+    s (str): The string from which to extract the potential hashes.
+
+    Yields:
+    str: Each extracted potential hash.
+
+    Examples:
+    >>> list(extract_hash('Here is a SHA-1 hash: 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'))
+    ['5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8']
+
+    >>> list(extract_hash('No hashes here!'))
+    []
+    """
+    # Regular expression pattern for a SHA-1 hash
+    pattern = r'\b[A-Fa-f0-9]{40}\b'
+
+    # Find all matches of the pattern in the input string
+    for match in re.finditer(pattern, s):
+        # Yield each match
+        yield match.group(0)
+
+
+def extract_torrent_hash(magnet: str):
+    """
+    Extract the torrent hash from a magnet link.
+
+    This function calls the `extract_hash` function to find potential SHA-1 hashes in the magnet link.
+    The torrent hash is typically found after 'xt=urn:btih:' in the magnet link.
+
+    Parameters:
+    magnet (str): The magnet link from which to extract the torrent hash.
+
+    Returns:
+    str: The extracted torrent hash, or None if no hash was found.
+
+    Examples:
+    >>> extract_torrent_hash('magnet:?xt=urn:btih:5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8')
+    '5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'
+
+    >>> extract_torrent_hash('No hashes here!')
+    None
+    """
+    # Find the start of the torrent hash in the magnet link
+    start = magnet.find('xt=urn:btih:') + len('xt=urn:btih:')
+
+    # Extract the potential hashes from the substring starting at the start index
+    hashes = extract_hash(magnet[start:])
+
+    # Return the first hash found, or None if no hash was found
+    return next(hashes, None)
+
+
+def extract_magnet(text: str):
+    """
+    Extract magnet links from an arbitrary string.
+
+    This function uses a generator to lazily yield each magnet link as it is found,
+    which can be more memory-efficient than returning a list of all links, especially
+    for large input strings with many potential links.
+
+    Parameters:
+    text (str): The string from which to extract the magnet links.
+
+    Yields:
+    str: Each extracted magnet link.
+
+    Examples:
+    >>> list(extract_magnet('Here is a magnet link: magnet:?xt=urn:btih:5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'))
+    ['magnet:?xt=urn:btih:5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8']
+
+    >>> list(extract_magnet('No magnet links here!'))
+    []
+    """
+    # Regular expression pattern for a magnet link
+    pattern = r'magnet:\?xt=urn:btih:[A-Fa-f0-9]+'
+
+    # Find all matches of the pattern in the input string
+    for match in re.finditer(pattern, text, re.IGNORECASE):
+        # Yield each match
+        yield match.group(0)

plexflow/utils/transcribe/speech2text.py

@@ -0,0 +1,40 @@
+import whisper
+
+def transcribe_audio(file_path, model: str = 'medium'):
+    """
+    Transcribes an audio file using the Whisper model.
+
+    Args:
+        file_path (str): The path to the audio file to transcribe.
+
+    Returns:
+        str: The transcription of the audio file.
+
+    Raises:
+        FileNotFoundError: If the audio file does not exist.
+        Exception: If there is an error loading the model or transcribing the audio.
+
+    Example:
+        >>> transcribe_audio('path/to/your/audio/file.mp3')
+        'This is the transcribed text from your audio file.'
+
+    Note:
+        This function assumes that you have the Whisper model available locally.
+    """
+    try:
+        # Check if the file exists
+        with open(file_path, 'rb') as f:
+            pass
+    except FileNotFoundError as e:
+        raise e
+
+    try:
+        # Load the Whisper model
+        model = whisper.load_model(model)
+
+        # Transcribe the audio
+        result = model.transcribe(file_path)
+
+        return result["text"]
+    except Exception as e:
+        raise e

plexflow/utils/video/subtitle.py

@@ -0,0 +1,73 @@
+import subprocess
+import json
+from pydantic import BaseModel
+from typing import List, Optional
+
+class SubtitleStream(BaseModel):
+    index: int
+    lang: Optional[str]
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "index": 0,
+                "lang": "en"
+            }
+        }
+
+def get_subtitles(video_path: str) -> List[SubtitleStream]:
+    """
+    Function to get subtitle streams from a video file.
+
+    Args:
+        video_path (str): The path to the video file.
+
+    Returns:
+        List[SubtitleStream]: A list of SubtitleStream objects, each representing a subtitle stream.
+
+    Raises:
+        FileNotFoundError: If the video file does not exist.
+        ValueError: If the output from the command could not be parsed.
+
+    Examples:
+        >>> video_path = "/path/to/your/video.mp4"
+        >>> try:
+        ...     subtitles = get_subtitles(video_path)
+        ...     for subtitle in subtitles:
+        ...         print(f"Subtitle stream index: {subtitle.index}, language: {subtitle.lang}")
+        ... except FileNotFoundError:
+        ...     print(f"The video file {video_path} does not exist.")
+        ... except ValueError:
+        ...     print("There was a problem parsing the command output.")
+        ...
+        Subtitle stream index: 0, language: en
+        Subtitle stream index: 1, language: es
+    """
+    if not os.path.isfile(video_path):
+        raise FileNotFoundError(f"No such file: '{video_path}'")
+
+    command = [
+        'ffprobe',
+        '-v', 'quiet',
+        '-print_format', 'json',
+        '-show_streams',
+        '-select_streams', 's',
+        video_path
+    ]
+
+    output = subprocess.run(command, capture_output=True, text=True)
+
+    try:
+        probe = json.loads(output.stdout)
+    except json.JSONDecodeError as e:
+        raise ValueError("Could not parse command output") from e
+
+    subtitle_streams = []
+    for stream in probe['streams']:
+        subtitle_info = SubtitleStream(
+            index=stream['index'],
+            lang=stream['tags']['language'] if 'tags' in stream and 'language' in stream['tags'] else None
+        )
+        subtitle_streams.append(subtitle_info)
+
+    return subtitle_streams