torrt 1.2.0__tar.gz → 1.2.1__tar.gz

{torrt-1.2.0 → torrt-1.2.1}/.gitignore

@@ -11,3 +11,4 @@ docs/_build/
 docs/build/
 build/
 dist/
+*.lock

{torrt-1.2.0 → torrt-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: torrt
-Version: 1.2.0
+Version: 1.2.1
 Summary: Automates torrent updates for you.
 Project-URL: Homepage, https://github.com/idlesign/torrt
 Project-URL: Documentation, https://torrt.readthedocs.io/
@@ -13,7 +13,6 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{torrt-1.2.0 → torrt-1.2.1}/pyproject.toml

@@ -15,7 +15,6 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -75,6 +74,10 @@ packages = ["src/torrt"]
 packages = ["src/"]
 
 [tool.pytest.ini_options]
+addopts = "-m 'not live_trackers'"
+markers = [
+    "live_trackers: explicit checks against real torrent tracker websites",
+]
 testpaths = [
     "tests",
 ]

torrt-1.2.1/src/torrt/__init__.py

@@ -0,0 +1,3 @@
+
+VERSION = '1.2.1'
+"""Application version string."""

{torrt-1.2.0 → torrt-1.2.1}/src/torrt/base_rpc.py

@@ -1,8 +1,22 @@
-from typing import Any, ClassVar
+from typing import Any, ClassVar, NamedTuple
 
+from .exceptions import TorrtRPCException
 from .utils import HttpClient, RPCClassesRegistry, RPCObjectsRegistry, TorrentData, WithSettings
 
 
+class TorrentFile(NamedTuple):
+    """Identify a file in the client's current torrent metadata."""
+
+    index: int
+    name: str
+
+class TorrentStatus(NamedTuple):
+    """Describe a client's torrent without requiring a local torrent file."""
+
+    hash: str
+    metadata_ready: bool
+    files: tuple[TorrentFile, ...] = ()
+
 class BaseRPC(WithSettings):
     """Base RPC class. All RPC classes should inherit from this."""
 
@@ -65,6 +79,19 @@ class BaseRPC(WithSettings):
         """
         raise NotImplementedError
 
+    def method_get_torrent_status(self, hash_str: str) -> TorrentStatus | None:
+        """Return metadata status, or None only when absence is confirmed.
+
+        Failed status queries must raise TorrtRPCException rather than report absence.
+        """
+        raise TorrtRPCException("Magnet readiness checks are not supported by this RPC")
+
+    def method_apply_file_exclusions(self, status: TorrentStatus, excluded_names: list[str]) -> None:
+        """Apply saved file exclusions using the supplied torrent metadata."""
+
+        if excluded_names:
+            raise TorrtRPCException("File exclusions are not supported by this RPC")
+
     def method_remove_torrent(self, hash_str: str, *, with_data: bool = False) -> Any:  # pragma: nocover
         """Removes torrent from torrent client using RPC.
 

{torrt-1.2.0 → torrt-1.2.1}/src/torrt/base_tracker.py

@@ -7,6 +7,7 @@ from typing import ClassVar
 from urllib.parse import parse_qs, urljoin, urlparse
 
 from .exceptions import TorrtTrackerException
+from .magnet import parse_magnet
 from .utils import (
     BeautifulSoup,
     HttpClient,
@@ -110,7 +111,7 @@ class BaseTracker(WithSettings):
                     silence_exceptions=True,
                 )
 
-                if response and response.url.startswith(mirror_url):
+                if response and response.ok and response.url.startswith(mirror_url):
                     mirror_picked = mirror_domain
                     break
 
@@ -141,9 +142,31 @@ class BaseTracker(WithSettings):
         :param string: String, describing torrent. E.g. URL from torrent comment.
 
         """
+
+        if not isinstance(string, str) or not string:
+            return False
+
+        try:
+            parsed_url = urlparse(string)
+            hostname = parsed_url.hostname
+
+            if (
+                parsed_url.scheme not in ("http", "https")
+                or not hostname
+                or parsed_url.username is not None
+                or parsed_url.port == 0
+            ):
+                # maybe forgery
+                return False
+
+        except ValueError:
+            return False
+
         for domain in chain([cls.alias], cls.mirrors):
-            if domain in string:
+
+            if domain and hostname in (domain.lower(), f"www.{domain.lower()}"):
                 return True
+
         return False
 
     @classmethod
@@ -280,16 +303,31 @@ class BaseTracker(WithSettings):
         """This should implement a configuration test, e.g. make test login and report success."""
         return True
 
-    def get_torrent(self, url: str, *, last_updated: datetime | None = None) -> TorrentData | None:
-        """This method should be implemented in torrent tracker handler class
-        and must return .torrent file contents.
+    def get_torrent(
+            self, url: str, *, last_updated: datetime | None = None, prefer_magnet: bool = False,
+    ) -> TorrentData | None:
+        """Return torrent file contents or a preferred magnet extracted by this tracker.
 
         :param url: URL to download torrent file from
         :param last_updated: torrent last updated datetime
+        :param prefer_magnet: use a valid magnet instead of downloading a torrent file
 
         """
         raise NotImplementedError  # pragma: nocover
 
+    def get_magnet_link(self, url: str) -> str:
+        """Return a magnet only when the tracker explicitly implements extraction."""
+        return ""
+
+    def _find_magnet_link(self, url: str) -> str:
+        """Find a magnet href on a supported tracker page using the page cache."""
+
+        if not self.can_handle(url):
+            return ""
+
+        page = self.get_torrent_page(url)
+        return self.find_links(url, page, definite=r"(?i)^magnet:\?") or ""
+
     def extract_page_data(self) -> PageData:
         data = PageData(
             title=self.extract_page_title(),
@@ -364,14 +402,32 @@ class GenericTracker(BaseTracker):
         """
         return url.split('=')[1]
 
-    def get_torrent(self, url: str, *, last_updated: datetime | None = None) -> TorrentData | None:
-        """This is the main method which returns torrent file contents
-        of file located at URL.
+    def get_torrent(
+            self, url: str, *, last_updated: datetime | None = None, prefer_magnet: bool = False,
+    ) -> TorrentData | None:
+        """Get torrent data from a tracker page, preferring a magnet when requested.
 
         :param url: URL to find and get torrent from
         :param last_updated: torrent last updated datetime
+        :param prefer_magnet: use a valid magnet instead of downloading a torrent file
 
         """
+
+        if not self.can_handle(url):
+            self.log_warning("Unsupported tracker page URL")
+            return None
+
+        if prefer_magnet and (magnet := self.get_magnet_link(url)):
+
+            try:
+                parse_magnet(magnet)
+
+            except ValueError:
+                self.log_warning("Invalid magnet link on tracker page; using torrent file instead")
+
+            else:
+                return TorrentData(url=url, magnet=magnet, page=self.extract_page_data())
+
         download_link = self.get_download_link(url)
 
         if not download_link:
@@ -382,7 +438,9 @@ class GenericTracker(BaseTracker):
 
         self.log_debug(f'Torrent download link found: {download_link}')
 
-        if last_updated and last_updated >= page_data.date_updated:
+        date_updated = page_data.date_updated
+
+        if last_updated and date_updated and last_updated >= date_updated:
             self.log_debug('Skipped as up to date')
             return None
         else:
@@ -501,9 +559,24 @@ class GenericPrivateTracker(GenericPublicTracker):
     def test_configuration(self) -> bool:
         return self.login(self.alias)
 
+    def _find_magnet_link(self, url: str) -> str:
+        """Find a visible magnet, signing in once if the page requires a session."""
+        magnet = super()._find_magnet_link(url)
+
+        if not magnet and not self.logged_in and self.login(self.extract_domain(url)):
+            magnet = super()._find_magnet_link(url)
+
+        return magnet
+
     def login(self, domain: str) -> bool:
         """Implements tracker login procedure. Returns success bool."""
 
+        domain_url = f"https://{domain}/"
+
+        if not self.can_handle(domain_url) or urlparse(domain_url).netloc != domain:
+            self.log_warning("Unsupported tracker login domain")
+            return False
+
         login_url = self.login_url % {'domain': domain}
 
         self.log_debug(f'Trying to login at {login_url} ...')
@@ -549,6 +622,8 @@ class GenericPrivateTracker(GenericPublicTracker):
                 self.query_string = parsed_qs[self.auth_qs_param_name][0]
 
             self.cookies = response.cookies
+            self._torrent_page = None
+            self._torrent_page_url = ""
 
             # Save auth info to config.
             self.save_settings()

{torrt-1.2.0 → torrt-1.2.1}/src/torrt/bots/telegram_bot.py

@@ -27,14 +27,18 @@ class TelegramBot(BaseBot):
     alias: str = 'telegram'
     url: str = 'https://api.telegram.org/bot'
 
-    def __init__(self, token: str, *, allowed_users: str = ''):
+    def __init__(self, token: str, *, allowed_users: str = "") -> None:
         """
         :param token: str Telegram's bot token
-        :param allowed_users: comma-joined list of users allowed to add new torrents.
+        :param allowed_users: comma-joined list of users allowed to manage torrents.
 
         """
         self.token = token
         self.allowed_users = allowed_users or ''
+        self._allowed_usernames = frozenset(
+            name.strip().removeprefix("@").lower()
+            for name in self.allowed_users.split(",") if name.strip()
+        )
 
         if not telegram:
             raise BotRegistrationFailed('You have not installed python-telegram-bot library.')
@@ -44,10 +48,19 @@ class TelegramBot(BaseBot):
         self.dispatcher = self.updater.dispatcher
 
         if self.allowed_users:
-            self.handler_kwargs = {'filters': Filters.user(username=self.allowed_users.split(','))}
+            self.handler_kwargs = {"filters": Filters.user(username=list(self._allowed_usernames))}
 
         super().__init__()
 
+    def is_allowed_user(self, update: "Update") -> bool:
+        """Check the actual sender, including users clicking shared group buttons."""
+
+        if not self.allowed_users:
+            return True
+
+        user = update.effective_user
+        return bool(user and user.username and user.username.lower() in self._allowed_usernames)
+
     def test_configuration(self) -> bool:
         return telegram and bool(self.updater)
 
@@ -91,9 +104,21 @@ class TelegramBot(BaseBot):
         add_handler(CommandHandler('remove', self.command_remove_torrents, **kwargs))
         add_handler(CommandHandler('help', self.command_help, **kwargs))
 
-    def handle_callbacks(self, update: 'Update', context: 'CallbackContext'):
+    def handle_callbacks(self, update: "Update", context: "CallbackContext") -> None:
         """Handler to process all callbacks from buttons"""
 
+        query = update.callback_query
+
+        if not self.is_allowed_user(update):
+
+            if query:
+                query.answer("Access denied.", show_alert=True)
+
+            return
+
+        if not query or not isinstance(query.data, str):
+            return
+
         handlers = {
             'add_torrent': self.handle_ask_url,
             'list_torrents': self.command_list_torrents,
@@ -107,7 +132,10 @@ class TelegramBot(BaseBot):
         elif update.callback_query.data.startswith('hash:'):
             self.handle_remove_torrents(update, context)
 
-    def handle_ask_url(self, update: 'Update', context: 'CallbackContext'):
+    def handle_ask_url(self, update: "Update", context: "CallbackContext") -> int:
+
+        if not self.is_allowed_user(update):
+            return ConversationHandler.END
 
         message = update.callback_query.message
         message.reply_text(
@@ -116,7 +144,10 @@ class TelegramBot(BaseBot):
         )
         return self.URL
 
-    def handle_process_url(self, update: 'Update', context: 'CallbackContext'):
+    def handle_process_url(self, update: "Update", context: "CallbackContext") -> int:
+
+        if not self.is_allowed_user(update):
+            return ConversationHandler.END
 
         torrent_url = update.message.text
         torrent_data = get_torrent_from_url(torrent_url)
@@ -158,7 +189,10 @@ class TelegramBot(BaseBot):
 
         return self.PATH
 
-    def handle_ask_download_path(self, update: 'Update', context: 'CallbackContext'):
+    def handle_ask_download_path(self, update: "Update", context: "CallbackContext") -> int:
+
+        if not self.is_allowed_user(update):
+            return ConversationHandler.END
 
         torrent_url = context.user_data.get('url')
 
@@ -204,7 +238,7 @@ class TelegramBot(BaseBot):
 
         return ConversationHandler.END
 
-    def handle_remove_torrents(self, update: 'Update', context: 'CallbackContext'):
+    def handle_remove_torrents(self, update: "Update", context: "CallbackContext") -> None:
         """
         Handler for torrent remove action.
         data is colon-joined string which is contains:
@@ -213,6 +247,10 @@ class TelegramBot(BaseBot):
         3. 0|1 - optional attribute (with_data) responsible for data removal from RPC
         For example 'hash:1234567890' or 'hash:1234567890:0'
         """
+
+        if not self.is_allowed_user(update):
+            return
+
         message = update.callback_query.message
         data = update.callback_query.data
         split_data = data.split(':')[1:]
@@ -256,9 +294,12 @@ class TelegramBot(BaseBot):
 
         return self.URL
 
-    def command_add_torrent(self, update: 'Update', context: 'CallbackContext'):
+    def command_add_torrent(self, update: "Update", context: "CallbackContext") -> None:
         """Stand-alone handler to add torrent"""
 
+        if not self.is_allowed_user(update):
+            return
+
         torrent_url = update.message.text.removeprefix('/add ')
 
         if not torrent_url:
@@ -286,9 +327,17 @@ class TelegramBot(BaseBot):
         else:
             context.bot.send_message(chat_id, text='Unable to register the torrent.')
 
-    def command_list_torrents(self, update: 'Update', context: 'CallbackContext'):
+    def command_list_torrents(self, update: "Update", context: "CallbackContext") -> None:
         """Command to list all monitored torrents"""
 
+        if not self.is_allowed_user(update):
+            return
+
+        message = update.effective_message
+
+        if message is None:
+            return
+
         torrents = []
 
         for idx, torrent in enumerate(get_registered_torrents().values(), 1):
@@ -298,16 +347,23 @@ class TelegramBot(BaseBot):
             else:
                 torrents.append(f"{idx}. {torrent['name']}")
 
-        message = update.callback_query.message
         if torrents:
             message.reply_text('\n\n'.join(torrents))
 
         else:
             message.reply_text('No torrents yet.')
 
-    def command_remove_torrents(self, update: 'Update', context: 'CallbackContext'):
+    def command_remove_torrents(self, update: "Update", context: "CallbackContext") -> None:
         """Command to remove torrent"""
 
+        if not self.is_allowed_user(update):
+            return
+
+        message = update.effective_message
+
+        if message is None:
+            return
+
         buttons = [
             [
                 InlineKeyboardButton(
@@ -318,7 +374,6 @@ class TelegramBot(BaseBot):
             for torrent in get_registered_torrents().values()
         ]
 
-        message = update.callback_query.message
         if not buttons:
             message.reply_text('No torrents yet.')
             return