plexflow 0.0.118__tar.gz → 0.0.120__tar.gz

{plexflow-0.0.118 → plexflow-0.0.120}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: plexflow
-Version: 0.0.118
+Version: 0.0.120
 Summary: A short description of the package.
 License: MIT
 Keywords: keyword1,keyword2,keyword3
@@ -29,6 +29,7 @@ Requires-Dist: dataclasses-json (>=0.6.4,<0.7.0)
 Requires-Dist: dateparser (>=1.2.0,<2.0.0)
 Requires-Dist: fake-useragent (>=1.4.0,<2.0.0)
 Requires-Dist: google-cloud-pubsub (>=2.28.0,<3.0.0)
+Requires-Dist: google-genai (>=1.26.0,<2.0.0)
 Requires-Dist: groq (>=0.9.0,<0.10.0)
 Requires-Dist: html5lib (>=1.1,<2.0)
 Requires-Dist: humanfriendly (>=10.0,<11.0)

{plexflow-0.0.118 → plexflow-0.0.120}/plexflow/core/context/partials/__init__.py

@@ -13,3 +13,4 @@ from plexflow.core.context.partials.candidates import Candidates
 from plexflow.core.context.partials.completed_downloads import CompletedDownloads
 from plexflow.core.context.partials.movie_assets import MovieAssets
 from plexflow.core.context.partials.torrent_deadline import TorrentDeadline
+from plexflow.core.context.partials.torrent_blacklist import TorrentBlacklist

plexflow-0.0.120/plexflow/core/context/partials/torrent_blacklist.py

@@ -0,0 +1,18 @@
+from plexflow.core.context.partial_context import PartialContext
+from qbittorrentapi.torrents import TorrentDictionary
+
+class TorrentBlacklist(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    def ban(self, torrent: TorrentDictionary):
+        hash = torrent.hash
+        key = f"blacklist/torrents/{hash}"
+        self.set_global(key, torrent)
+    
+    def is_banned(self, hash: str) -> bool:
+        try:
+            torrent = self.get_global(f"blacklist/torrents/{hash}")
+            return isinstance(torrent, TorrentDictionary)
+        except:
+            return False

{plexflow-0.0.118 → plexflow-0.0.120}/plexflow/core/downloads/qbit/interface.py

@@ -61,9 +61,9 @@ def is_completed(torrent: TorrentDictionary) -> bool:
 def is_downloading(torrent: TorrentDictionary) -> bool:
     return torrent.state in [
         "downloading",
-        "stalled_downloading",
+        # "stalled_downloading",
         "checking",
-        "stalledDL",
+        # "stalledDL", 
         "forcedDL",
     ]
 

{plexflow-0.0.118 → plexflow-0.0.120}/plexflow/core/metadata/providers/plex/datatypes.py

@@ -245,25 +245,25 @@ class PlexMovieMetadata:
         Rating (Optional[List[PlexRating]]): The list of ratings of the movie.
         Studio (Optional[List[PlexStudio]]): The list of studios associated with the movie.
     """
-    title: Optional[str]
-    guid: Optional[str]
-    key: Optional[str]
-    primaryExtraKey: Optional[str]
-    rating: Optional[float]
-    ratingKey: Optional[str]
-    studio: Optional[str]
-    summary: Optional[str]
-    tagline: Optional[str]
-    type: Optional[str]
-    thumb: Optional[str]
-    addedAt: Optional[int]
-    duration: Optional[int]
-    publicPagesURL: Optional[str]
-    slug: Optional[str]
-    userState: Optional[bool]
-    contentRating: Optional[str]
-    originallyAvailableAt: Optional[str]
-    year: Optional[int]
+    title: Optional[str] = field(default=None)
+    guid: Optional[str] = field(default=None)
+    key: Optional[str] = field(default=None)
+    primaryExtraKey: Optional[str] = field(default=None)
+    rating: Optional[float] = field(default=None)
+    ratingKey: Optional[str] = field(default=None)
+    studio: Optional[str] = field(default=None)
+    summary: Optional[str] = field(default=None)
+    tagline: Optional[str] = field(default=None)
+    type: Optional[str] = field(default=None)
+    thumb: Optional[str] = field(default=None)
+    addedAt: Optional[int] = field(default=None)
+    duration: Optional[int] = field(default=None)
+    publicPagesURL: Optional[str] = field(default=None)
+    slug: Optional[str] = field(default=None)
+    userState: Optional[bool] = field(default=None)
+    contentRating: Optional[str] = field(default=None)
+    originallyAvailableAt: Optional[str] = field(default=None)
+    year: Optional[int] = field(default=None)
     audienceRating: Optional[float] = None
     audienceRatingImage: Optional[str] = None
     ratingImage: Optional[str] = None

plexflow-0.0.120/plexflow/core/torrents/providers/tgxi/tgxi.py

@@ -0,0 +1,16 @@
+from plexflow.utils.api.rest.plexful import Plexful
+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(Plexful):
+    def __init__(self, base_url: str = 'https://therarbg.com'):
+        super().__init__(base_url=base_url)
+    
+    def search(self, query: str, headless: bool = True, **kwargs) -> List[TheRarbgSearchResult]:
+        response = self.get(f'/get-posts/keywords:{query}/')
+        
+        response.raise_for_status()
+        
+        data = extract_torrent_results(html=response.text if not headless else response.html)
+        return list(map(lambda t: TheRarbgSearchResult(**t), data))

plexflow-0.0.120/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 None
+
+    @property
+    def url(self) -> str:
+        return self._link
+
+    @property
+    def category(self) -> str:
+        return self._type

plexflow-0.0.120/plexflow/utils/torrent/compare/with_subtitles.py

@@ -0,0 +1,89 @@
+import os
+from google import genai
+from google.genai import types
+
+
+def generate(torrent: str, subtitle: str):
+    client = genai.Client(
+        api_key=os.environ.get("GEMINI_API_KEY"),
+    )
+
+    model = "gemini-2.5-flash"
+    contents = [
+        types.Content(
+            role="user",
+            parts=[
+                types.Part.from_text(text=f"""torrent: {torrent}
+subtitle: {subtitle}"""),
+            ],
+        ),
+    ]
+    generate_content_config = types.GenerateContentConfig(
+        thinking_config = types.ThinkingConfig(
+            thinking_budget=-1,
+        ),
+        response_mime_type="application/json",
+        response_schema=genai.types.Schema(
+            type = genai.types.Type.OBJECT,
+            required = ["subtitle", "torrent", "is_match", "reason"],
+            properties = {
+                "subtitle": genai.types.Schema(
+                    type = genai.types.Type.STRING,
+                ),
+                "torrent": genai.types.Schema(
+                    type = genai.types.Type.STRING,
+                ),
+                "is_match": genai.types.Schema(
+                    type = genai.types.Type.BOOLEAN,
+                ),
+                "reason": genai.types.Schema(
+                    type = genai.types.Type.STRING,
+                ),
+            },
+        ),
+        system_instruction=[
+            types.Part.from_text(text="""You are an expert at matching subtitle names with torrent names. Resolution and codecs are not important. Consider the release group when matching, however it is not the most important thing. You always output a JSON in the following format:
+
+{
+  \"subtitle\": string,
+  \"torrent\": string,
+  \"is_match\": boolean,
+  \"reason\": string
+}"""),
+        ],
+    )
+
+    # Initialize an empty string to store the full response
+    full_response_text = ""
+
+    for chunk in client.models.generate_content_stream(
+        model=model,
+        contents=contents,
+        config=generate_content_config,
+    ):
+        # Append each chunk's text to the string
+        full_response_text += chunk.text
+        # Optional: Print chunks as they arrive if you still want to see the streaming
+        # print(chunk.text, end="")
+
+    # Now, full_response_text contains the complete JSON string
+    #print("\n--- Complete Generated Output ---")
+    #print(full_response_text)
+
+    # You can return this string if you want to use it outside the function
+    return full_response_text
+
+
+def compare(torrent: str, subtitle: str) -> dict:
+    generated_json_string = generate(
+        torrent=torrent,
+        subtitle=subtitle,
+    )
+
+    import json
+    try:
+        data = json.loads(generated_json_string)
+        return data
+    except json.JSONDecodeError as e:
+        print(f"\nError decoding JSON: {e}")
+        print(f"Raw string: {generated_json_string}")

plexflow-0.0.120/plexflow/utils/torrent/extract/tgxi.py

@@ -0,0 +1,64 @@
+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
+
+
+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('div', class_='tgxtablerow')
+
+    for row in rows:
+        torrent = {}
+
+        # Extract data from the cells
+        cells = row.find_all('div', class_='tgxtablecell')
+
+        # Title (get full title from link href)
+        title_cell = cells[3]
+        title_link = title_cell.find('a')
+        
+        if title_link:
+            # Get the part of the href after the last '/'
+            torrent['link'] = urljoin('https://torrentgalaxy.info', title_link['href'])
+        else:
+            torrent['link'] = ''
+        
+        torrent['name'] = title_cell.text.strip()
+        
+        # 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
+
+        # TODO
+
+        torrents.append(torrent)
+
+    return torrents

{plexflow-0.0.118 → plexflow-0.0.120}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "plexflow"
-version = "0.0.118"
+version = "0.0.120"
 description = "A short description of the package."
 authors = ["Your Name <you@example.com>"]
 license = "MIT"
@@ -78,6 +78,7 @@ google-cloud-pubsub = "^2.28.0"
 qbittorrent-api = "^2025.2.0"
 langdetect = "^1.0.9"
 stable-ts = "^2.19.0"
+google-genai = "^1.26.0"
 [tool.poetry.dev-dependencies]
 pytest = "^8.2.1"
 
@@ -117,4 +118,5 @@ groq_transcribe = 'scripts.transcribe.groq_transcribe:main'
 mistral = 'scripts.mistral.mistral:main'
 schedule = 'scripts.downloads.qbit.schedule:main'
 interface = 'scripts.downloads.qbit.interface:main'
-refresh = 'scripts.plex.library.refresh:main'
+refresh = 'scripts.plex.library.refresh:main'
+subtitle_compare = 'scripts.torrents.subtitle_comparison:main'