scrapeer 1.0.0__tar.gz

scrapeer-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tboy1337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

scrapeer-1.0.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: scrapeer
+Version: 1.0.0
+Summary: Essential Python library that scrapes HTTP(S) and UDP trackers for torrent information.
+Home-page: https://github.com/tboy1337/scrapeer-py
+Download-URL: https://github.com/tboy1337/scrapeer-py/releases/latest
+Author: tboy1337
+Author-email: obywhuie@anonaddy.com
+License: MIT
+Keywords: torrent,torrents,scraper,scrapeer,torrent-scraper,torrent-scraping
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Scrapeer-py
+
+A tiny Python library that lets you scrape HTTP(S) and UDP trackers for torrent information.
+
+Scrapeer-py is a Python port of the original PHP [Scrapeer](https://github.com/torrentpier/scrapeer) library by [TorrentPier](https://github.com/torrentpier).
+
+## Overview
+
+Scrapeer-py allows you to retrieve peer information from BitTorrent trackers using both HTTP(S) and UDP protocols. It can fetch seeders, leechers, and completed download counts for multiple torrents from multiple trackers simultaneously.
+
+## Features
+
+- Support for both HTTP(S) and UDP tracker protocols
+- Batch scraping of multiple infohashes at once (up to 64)
+- Support for trackers with passkeys
+- Optional announce mode for trackers that don't support scrape
+- Configurable timeout settings
+- Detailed error reporting
+- Well-organized modular codebase
+
+## Installation
+
+```bash
+pip install scrapeer
+```
+
+## Usage
+
+```python
+from scrapeer import Scraper
+
+# Initialize the scraper
+scraper = Scraper()
+
+# Define your infohashes and trackers
+infohashes = [
+    "0123456789abcdef0123456789abcdef01234567",
+    "fedcba9876543210fedcba9876543210fedcba98"
+]
+
+trackers = [
+    "udp://tracker.example.com:80",
+    "http://tracker.example.org:6969/announce",
+    "https://private-tracker.example.net:443/YOUR_PASSKEY/announce"
+]
+
+# Get the results (timeout of 3 seconds per tracker)
+results = scraper.scrape(
+    hashes=infohashes,
+    trackers=trackers,
+    timeout=3
+)
+
+# Print the results
+for infohash, data in results.items():
+    print(f"Results for {infohash}:")
+    print(f"  Seeders: {data['seeders']}")
+    print(f"  Leechers: {data['leechers']}")
+    print(f"  Completed: {data['completed']}")
+
+# Check if there were any errors
+if scraper.has_errors():
+    print("\nErrors:")
+    for error in scraper.get_errors():
+        print(f"  {error}")
+```
+
+## Package Structure
+
+Scrapeer-py is organized into the following modules:
+
+- `scrapeer/` - Main package directory
+  - `__init__.py` - Package initialization that exports the Scraper class
+  - `scraper.py` - Main Scraper class implementation
+  - `http.py` - HTTP(S) protocol scraping functionality
+  - `udp.py` - UDP protocol scraping functionality
+  - `utils.py` - Utility functions used across the package
+
+## API Reference
+
+### `Scraper` class
+
+#### `scrape(hashes, trackers, max_trackers=None, timeout=2, announce=False)`
+
+Scrape trackers for torrent information.
+
+- **Parameters**:
+  - `hashes`: List (>1) or string of infohash(es)
+  - `trackers`: List (>1) or string of tracker(s)
+  - `max_trackers`: (Optional) Maximum number of trackers to be scraped, Default all
+  - `timeout`: (Optional) Maximum time for each tracker scrape in seconds, Default 2
+  - `announce`: (Optional) Use announce instead of scrape, Default False
+
+- **Returns**:
+  - Dictionary of results with infohashes as keys and stats as values
+
+#### `has_errors()`
+
+Checks if there are any errors.
+
+- **Returns**:
+  - `bool`: True if errors are present, False otherwise
+
+#### `get_errors()`
+
+Returns all the errors that were logged.
+
+- **Returns**:
+  - `list`: All the logged errors
+
+## Limitations
+
+- Maximum of 64 infohashes per request
+- Minimum of 1 infohash per request
+- Only supports BitTorrent trackers (HTTP(S) and UDP)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.

scrapeer-1.0.0/README.md

@@ -0,0 +1,119 @@
+# Scrapeer-py
+
+A tiny Python library that lets you scrape HTTP(S) and UDP trackers for torrent information.
+
+Scrapeer-py is a Python port of the original PHP [Scrapeer](https://github.com/torrentpier/scrapeer) library by [TorrentPier](https://github.com/torrentpier).
+
+## Overview
+
+Scrapeer-py allows you to retrieve peer information from BitTorrent trackers using both HTTP(S) and UDP protocols. It can fetch seeders, leechers, and completed download counts for multiple torrents from multiple trackers simultaneously.
+
+## Features
+
+- Support for both HTTP(S) and UDP tracker protocols
+- Batch scraping of multiple infohashes at once (up to 64)
+- Support for trackers with passkeys
+- Optional announce mode for trackers that don't support scrape
+- Configurable timeout settings
+- Detailed error reporting
+- Well-organized modular codebase
+
+## Installation
+
+```bash
+pip install scrapeer
+```
+
+## Usage
+
+```python
+from scrapeer import Scraper
+
+# Initialize the scraper
+scraper = Scraper()
+
+# Define your infohashes and trackers
+infohashes = [
+    "0123456789abcdef0123456789abcdef01234567",
+    "fedcba9876543210fedcba9876543210fedcba98"
+]
+
+trackers = [
+    "udp://tracker.example.com:80",
+    "http://tracker.example.org:6969/announce",
+    "https://private-tracker.example.net:443/YOUR_PASSKEY/announce"
+]
+
+# Get the results (timeout of 3 seconds per tracker)
+results = scraper.scrape(
+    hashes=infohashes,
+    trackers=trackers,
+    timeout=3
+)
+
+# Print the results
+for infohash, data in results.items():
+    print(f"Results for {infohash}:")
+    print(f"  Seeders: {data['seeders']}")
+    print(f"  Leechers: {data['leechers']}")
+    print(f"  Completed: {data['completed']}")
+
+# Check if there were any errors
+if scraper.has_errors():
+    print("\nErrors:")
+    for error in scraper.get_errors():
+        print(f"  {error}")
+```
+
+## Package Structure
+
+Scrapeer-py is organized into the following modules:
+
+- `scrapeer/` - Main package directory
+  - `__init__.py` - Package initialization that exports the Scraper class
+  - `scraper.py` - Main Scraper class implementation
+  - `http.py` - HTTP(S) protocol scraping functionality
+  - `udp.py` - UDP protocol scraping functionality
+  - `utils.py` - Utility functions used across the package
+
+## API Reference
+
+### `Scraper` class
+
+#### `scrape(hashes, trackers, max_trackers=None, timeout=2, announce=False)`
+
+Scrape trackers for torrent information.
+
+- **Parameters**:
+  - `hashes`: List (>1) or string of infohash(es)
+  - `trackers`: List (>1) or string of tracker(s)
+  - `max_trackers`: (Optional) Maximum number of trackers to be scraped, Default all
+  - `timeout`: (Optional) Maximum time for each tracker scrape in seconds, Default 2
+  - `announce`: (Optional) Use announce instead of scrape, Default False
+
+- **Returns**:
+  - Dictionary of results with infohashes as keys and stats as values
+
+#### `has_errors()`
+
+Checks if there are any errors.
+
+- **Returns**:
+  - `bool`: True if errors are present, False otherwise
+
+#### `get_errors()`
+
+Returns all the errors that were logged.
+
+- **Returns**:
+  - `list`: All the logged errors
+
+## Limitations
+
+- Maximum of 64 infohashes per request
+- Minimum of 1 infohash per request
+- Only supports BitTorrent trackers (HTTP(S) and UDP)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.

scrapeer-1.0.0/scrapeer/__init__.py

@@ -0,0 +1,11 @@
+"""
+Scrapeer-py, a tiny Python library that lets you scrape
+HTTP(S) and UDP trackers for torrent information.
+
+Port of the original PHP Scrapeer library by TorrentPier.
+"""
+
+from .scraper import Scraper
+
+__version__ = '1.0.0'
+__all__ = ['Scraper'] 

scrapeer-1.0.0/scrapeer/http.py

@@ -0,0 +1,227 @@
+"""
+HTTP scraping functionality for Scrapeer.
+"""
+
+import urllib.request
+import urllib.parse
+import re
+import socket
+
+
+def scrape_http(infohashes, protocol, host, port, passkey, announce, timeout):
+    """
+    Initiates the HTTP(S) scraping
+
+    Args:
+        infohashes: List (>1) or string of infohash(es).
+        protocol: Protocol to use for the scraping.
+        host: Domain or IP address of the tracker.
+        port: Optional. Port number of the tracker.
+        passkey: Optional. Passkey provided in the scrape request.
+        announce: Optional. Use announce instead of scrape.
+        timeout: Maximum time for each tracker scrape in seconds.
+
+    Returns:
+        dict: Dictionary of results.
+    """
+    if announce:
+        response = http_announce(infohashes, protocol, host, port, passkey, timeout)
+    else:
+        query = http_query(infohashes, protocol, host, port, passkey)
+        response = http_request(query, host, port, timeout)
+    
+    results = http_data(response, infohashes, host)
+    return results
+
+
+def http_query(infohashes, protocol, host, port, passkey):
+    """
+    Builds the HTTP(S) query
+
+    Args:
+        infohashes: List (>1) or string of infohash(es).
+        protocol: Protocol to use for the scraping.
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+        passkey: Optional. Passkey provided in the scrape request.
+
+    Returns:
+        str: Fully qualified URL.
+    """
+    info = urllib.parse.urlparse(f"{protocol}://{host}:{port}/scrape{passkey}")
+    query = f"{info.scheme}://{info.netloc}{info.path}"
+    
+    if len(infohashes) > 1:
+        query += '?'
+        
+        for index, infohash in enumerate(infohashes):
+            query += f"info_hash={urllib.parse.quote(bytes.fromhex(infohash))}"
+            
+            if index < len(infohashes) - 1:
+                query += '&'
+    elif len(infohashes) == 1:
+        query += f"?info_hash={urllib.parse.quote(bytes.fromhex(infohashes[0]))}"
+        
+    return query
+
+
+def http_request(query, host, port, timeout):
+    """
+    Sends HTTP(S) request to the tracker
+
+    Args:
+        query: URL to the tracker.
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+        timeout: Maximum time for each tracker scrape in seconds.
+
+    Returns:
+        str: Response from the tracker.
+    """
+    socket.setdefaulttimeout(timeout)
+    
+    try:
+        request = urllib.request.Request(
+            query,
+            headers={'User-Agent': 'Scrapeer-py/1.0.0'}
+        )
+        response = urllib.request.urlopen(request).read()
+        return response
+    except Exception as e:
+        raise Exception(f"Connection error: {host}:{port} - {str(e)}")
+
+
+def http_announce(infohashes, protocol, host, port, passkey, timeout):
+    """
+    Announces to the tracker instead of scraping
+
+    Args:
+        infohashes: List (>1) or string of infohash(es).
+        protocol: Protocol to use for the scraping.
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+        passkey: Optional. Passkey provided in the scrape request.
+        timeout: Maximum time for each tracker scrape in seconds.
+
+    Returns:
+        str: Response from the tracker.
+    """
+    info = urllib.parse.urlparse(f"{protocol}://{host}:{port}/announce{passkey}")
+    query = f"{info.scheme}://{info.netloc}{info.path}"
+    
+    if len(infohashes) > 1:
+        raise Exception(f"Too many hashes for HTTP announce ({len(infohashes)}).")
+
+    query += f"?info_hash={urllib.parse.quote(bytes.fromhex(infohashes[0]))}"
+    query += "&peer_id=test1234567891234567"
+    query += "&port=6889"
+    query += "&uploaded=0"
+    query += "&downloaded=0"
+    query += "&left=0"
+    query += "&compact=1"
+    
+    socket.setdefaulttimeout(timeout)
+    
+    try:
+        request = urllib.request.Request(
+            query,
+            headers={'User-Agent': 'Scrapeer-py/1.0.0'}
+        )
+        response = urllib.request.urlopen(request).read()
+        return response
+    except Exception as e:
+        raise Exception(f"Connection error: {host}:{port} - {str(e)}")
+
+
+def http_data(response, infohashes, host):
+    """
+    Gets the data from HTTP(S) response
+
+    Args:
+        response: Response from the tracker.
+        infohashes: List (>1) or string of infohash(es).
+        host: Domain or IP address of the tracker.
+
+    Returns:
+        dict: Dictionary of results.
+    """
+    data = str(response)
+    results = {}
+    pattern_all = r"d8:completei(\d+)e10:downloadedi(\d+)e10:incompletei(\d+)e"
+    pattern_single = r"d8:completei(\d+)e10:incompletei(\d+)e"
+    
+    for infohash in infohashes:
+        pattern = f"{infohash}:{pattern_all}"
+        matches = re.search(pattern, data, re.IGNORECASE)
+        
+        if matches:
+            results[infohash] = {
+                'seeders': int(matches.group(1)),
+                'completed': int(matches.group(2)),
+                'leechers': int(matches.group(3)),
+            }
+        else:
+            pattern = f"{infohash}:{pattern_single}"
+            matches = re.search(pattern, data, re.IGNORECASE)
+            
+            if matches:
+                results[infohash] = {
+                    'seeders': int(matches.group(1)),
+                    'completed': 0,
+                    'leechers': int(matches.group(2)),
+                }
+            else:
+                info = get_information(data, 'd5:filesd', 'ee')
+                
+                if info:
+                    pattern = f"20:{bytes.fromhex(infohash).decode('latin-1', errors='ignore')}d"
+                    start = info.find(pattern)
+                    
+                    if start != -1:
+                        info = info[start:]
+                        end = info.find('e')
+                        info = info[:end + 1]
+                        
+                        seeders = re.search(r"completei(\d+)e", info, re.IGNORECASE)
+                        leechers = re.search(r"incompletei(\d+)e", info, re.IGNORECASE)
+                        completed = re.search(r"downloadedi(\d+)e", info, re.IGNORECASE)
+                        
+                        seeders = int(seeders.group(1)) if seeders else 0
+                        leechers = int(leechers.group(1)) if leechers else 0
+                        completed = int(completed.group(1)) if completed else 0
+                        
+                        results[infohash] = {
+                            'seeders': seeders,
+                            'completed': completed,
+                            'leechers': leechers,
+                        }
+                    else:
+                        raise Exception(f"Failed to parse torrent data from '{host}'.")
+                else:
+                    raise Exception(f"Invalid scrape response from '{host}'.")
+    
+    return results
+
+
+def get_information(data, start, end):
+    """
+    Gets information from HTTP(S) response
+
+    Args:
+        data: Response from the tracker.
+        start: Starting string.
+        end: Ending string.
+
+    Returns:
+        str: Information or None.
+    """
+    start_pos = data.find(start)
+    
+    if start_pos != -1:
+        start_pos += len(start)
+        end_pos = data.find(end, start_pos)
+        
+        if end_pos != -1:
+            return data[start_pos:end_pos]
+    
+    return None 

scrapeer-1.0.0/scrapeer/scraper.py

@@ -0,0 +1,134 @@
+"""
+Main Scraper class for Scrapeer.
+"""
+
+import urllib.parse
+from .http import scrape_http
+from .udp import scrape_udp
+from .utils import normalize_infohashes, get_passkey
+
+
+class Scraper:
+    """
+    The one and only class you'll ever need.
+    """
+
+    VERSION = '1.0.0'  # Python port version
+
+    def __init__(self):
+        """
+        Initialize the scraper.
+        """
+        self.errors = []
+        self.infohashes = []
+        self.timeout = 2
+
+    def scrape(self, hashes, trackers, max_trackers=None, timeout=2, announce=False):
+        """
+        Initiates the scraper
+
+        Args:
+            hashes: List (>1) or string of infohash(es).
+            trackers: List (>1) or string of tracker(s).
+            max_trackers: Optional. Maximum number of trackers to be scraped, Default all.
+            timeout: Optional. Maximum time for each tracker scrape in seconds, Default 2.
+            announce: Optional. Use announce instead of scrape, Default false.
+
+        Returns:
+            dict: Dictionary of results.
+        """
+        final_result = {}
+
+        if not trackers:
+            self.errors.append('No tracker specified, aborting.')
+            return final_result
+        elif not isinstance(trackers, list):
+            trackers = [trackers]
+
+        if isinstance(timeout, int):
+            self.timeout = timeout
+        else:
+            self.timeout = 2
+            self.errors.append('Timeout must be an integer. Using default value.')
+
+        try:
+            self.infohashes = normalize_infohashes(hashes, self.errors)
+        except ValueError as e:
+            self.errors.append(str(e))
+            return final_result
+
+        max_iterations = max_trackers if isinstance(max_trackers, int) else len(trackers)
+        for index, tracker in enumerate(trackers):
+            if self.infohashes and index < max_iterations:
+                info = urllib.parse.urlparse(tracker)
+                protocol = info.scheme
+                host = info.netloc.split(':')[0] if ':' in info.netloc else info.netloc
+                
+                if not protocol or not host:
+                    self.errors.append(f'Skipping invalid tracker ({tracker}).')
+                    continue
+
+                port = info.port if info.port else None
+                path = info.path if info.path else None
+                passkey = get_passkey(path)
+                
+                result = self.try_scrape(protocol, host, port, passkey, announce)
+                final_result.update(result)
+                continue
+            break
+
+        return final_result
+
+    def try_scrape(self, protocol, host, port, passkey, announce):
+        """
+        Tries to scrape with a single tracker.
+
+        Args:
+            protocol: Protocol of the tracker.
+            host: Domain or address of the tracker.
+            port: Optional. Port number of the tracker.
+            passkey: Optional. Passkey provided in the scrape request.
+            announce: Optional. Use announce instead of scrape, Default false.
+
+        Returns:
+            dict: Dictionary of results.
+        """
+        infohashes = self.infohashes.copy()
+        self.infohashes = []
+        results = {}
+        
+        try:
+            if protocol == 'udp':
+                port = port if port else 80
+                results = scrape_udp(infohashes, host, port, announce, self.timeout)
+            elif protocol == 'http':
+                port = port if port else 80
+                results = scrape_http(infohashes, protocol, host, port, passkey, announce, self.timeout)
+            elif protocol == 'https':
+                port = port if port else 443
+                results = scrape_http(infohashes, protocol, host, port, passkey, announce, self.timeout)
+            else:
+                raise Exception(f'Unsupported protocol ({protocol}://{host}).')
+        except Exception as e:
+            self.infohashes = infohashes
+            self.errors.append(str(e))
+        
+        return results
+
+    def has_errors(self):
+        """
+        Checks if there are any errors.
+
+        Returns:
+            bool: True if errors are present, False otherwise.
+        """
+        return len(self.errors) > 0
+
+    def get_errors(self):
+        """
+        Returns all the errors that were logged.
+
+        Returns:
+            list: All the logged errors.
+        """
+        return self.errors 

scrapeer-1.0.0/scrapeer/udp.py

@@ -0,0 +1,327 @@
+"""
+UDP scraping functionality for Scrapeer.
+"""
+
+import socket
+import struct
+import random
+from .utils import random_peer_id, collect_info_hash
+
+
+def scrape_udp(infohashes, host, port, announce, timeout):
+    """
+    Initiates the UDP scraping
+
+    Args:
+        infohashes: List (>1) or string of infohash(es).
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+        announce: Optional. Use announce instead of scrape.
+        timeout: Maximum time for each tracker scrape in seconds.
+
+    Returns:
+        dict: Dictionary of results.
+    """
+    socket_obj, ip = prepare_udp(host, port)
+    socket_obj.settimeout(timeout)
+    
+    try:
+        transaction_id, connection_id = udp_connection_request(socket_obj)
+        connection_id = udp_connection_response(socket_obj, transaction_id, host, port)
+        
+        if announce:
+            return udp_announce(socket_obj, infohashes, connection_id)
+        else:
+            return udp_scrape(socket_obj, infohashes, connection_id, transaction_id, host, port)
+    finally:
+        socket_obj.close()
+
+
+def prepare_udp(host, port):
+    """
+    Prepares the UDP socket
+
+    Args:
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+
+    Returns:
+        tuple: Tuple containing socket object and IP address.
+    """
+    socket_obj = udp_create_connection(host, port)
+    
+    try:
+        ip = socket.gethostbyname(host)
+    except socket.gaierror:
+        raise Exception(f"Failed to resolve host '{host}'.")
+    
+    return socket_obj, ip
+
+
+def udp_create_connection(host, port):
+    """
+    Creates a UDP connection
+
+    Args:
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+
+    Returns:
+        socket: Socket object.
+    """
+    try:
+        socket_obj = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        socket_obj.connect((host, port))
+        return socket_obj
+    except socket.error as e:
+        raise Exception(f"Failed to create socket for '{host}:{port}' - {str(e)}.")
+
+
+def udp_connection_request(socket_obj):
+    """
+    Sends a connection request
+
+    Args:
+        socket_obj: Socket object.
+
+    Returns:
+        tuple: Tuple containing transaction_id and connection_id.
+    """
+    connection_id = 0x41727101980  # Default connection ID
+    action = 0  # Action (0 = connection, 1 = announce, 2 = scrape)
+    transaction_id = random.randint(0, 2147483647)  # Random transaction ID
+    
+    buffer = struct.pack(">QII", connection_id, action, transaction_id)
+    
+    try:
+        socket_obj.send(buffer)
+    except socket.error as e:
+        raise Exception(f"Failed to send connection request - {str(e)}.")
+    
+    return transaction_id, connection_id
+
+
+def udp_connection_response(socket_obj, transaction_id, host, port):
+    """
+    Receives a connection response
+
+    Args:
+        socket_obj: Socket object.
+        transaction_id: Transaction ID.
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+
+    Returns:
+        int: Connection ID.
+    """
+    try:
+        response = socket_obj.recv(16)
+    except socket.error as e:
+        raise Exception(f"Failed to receive connection response from '{host}:{port}' - {str(e)}.")
+    
+    if len(response) != 16:
+        raise Exception(f"Invalid response length from '{host}:{port}'.")
+    
+    return_action, return_transaction_id, connection_id = struct.unpack(">IIQ", response)
+
+    if return_transaction_id != transaction_id:
+        raise Exception(f"Invalid transaction ID from '{host}:{port}'.")
+
+    if return_action != 0:
+        raise Exception(f"Invalid action from '{host}:{port}'.")
+    
+    return connection_id
+
+
+def udp_scrape(socket_obj, hashes, connection_id, transaction_id, host, port):
+    """
+    Sends a scrape request
+
+    Args:
+        socket_obj: Socket object.
+        hashes: List (>1) or string of infohash(es).
+        connection_id: Connection ID.
+        transaction_id: Transaction ID.
+        host: Domain or IP address of the tracker.
+        port: Port number of the tracker.
+
+    Returns:
+        dict: Dictionary of results.
+    """
+    action = 2  # Action (2 = scrape)
+    
+    # Create scrape request
+    buffer = udp_scrape_request(socket_obj, hashes, connection_id, transaction_id)
+
+    try:
+        # Send scrape request
+        socket_obj.send(buffer)
+        
+        # Receive scrape response
+        response = socket_obj.recv(8 + (12 * len(hashes)))
+        
+        # Parse scrape response
+        if len(response) < 8:
+            raise Exception(f"Invalid scrape response from '{host}:{port}'.")
+        
+        return_action, return_transaction_id = struct.unpack(">II", response[:8])
+        
+        # Verify transaction ID
+        if transaction_id != return_transaction_id:
+            raise Exception(f"Invalid transaction ID from '{host}:{port}'.")
+        
+        # Verify action
+        if return_action != action:
+            err_msg = struct.unpack(">I", response[4:8])[0]
+            raise Exception(f"Tracker error, code: {err_msg} from '{host}:{port}'.")
+        
+        # Create keys array
+        keys = []
+        for infohash in hashes:
+            keys.append(infohash)
+        
+        # Parse results
+        return udp_scrape_data(response, hashes, host, keys, 8, len(response), 12)
+    except socket.error as e:
+        raise Exception(f"Socket error from '{host}:{port}' - {str(e)}.")
+
+
+def udp_scrape_request(socket_obj, hashes, connection_id, transaction_id):
+    """
+    Creates a scrape request
+
+    Args:
+        socket_obj: Socket object.
+        hashes: List (>1) or string of infohash(es).
+        connection_id: Connection ID.
+        transaction_id: Transaction ID.
+
+    Returns:
+        bytes: Scrape request.
+    """
+    action = 2  # Action (2 = scrape)
+    
+    buffer = struct.pack(">QII", connection_id, action, transaction_id)
+    
+    for infohash in hashes:
+        buffer += collect_info_hash(infohash)
+    
+    return buffer
+
+
+def udp_announce(socket_obj, hashes, connection_id):
+    """
+    Sends an announce request
+
+    Args:
+        socket_obj: Socket object.
+        hashes: List (>1) or string of infohash(es).
+        connection_id: Connection ID.
+
+    Returns:
+        dict: Dictionary of results.
+    """
+    if len(hashes) > 1:
+        raise Exception(f"Too many hashes for UDP announce ({len(hashes)}).")
+    
+    action = 1  # Action (1 = announce)
+    transaction_id = random.randint(0, 2147483647)  # Random transaction ID
+    
+    infohash = collect_info_hash(hashes[0])
+    peer_id = random_peer_id()
+    downloaded = 0
+    left = 0
+    uploaded = 0
+    event = 0
+    ip = 0
+    key = 0
+    num_want = -1
+    port = 6889
+    
+    buffer = struct.pack(">QII20s20sQQQIIIiH",
+                      connection_id, action, transaction_id, infohash, peer_id,
+                      downloaded, left, uploaded, event, ip, key, num_want, port)
+    
+    try:
+        socket_obj.send(buffer)
+        result = udp_verify_announce(socket_obj, transaction_id)
+        
+        return {
+            hashes[0]: {
+                'seeders': result[0],
+                'leechers': result[1],
+                'completed': result[2],
+            }
+        }
+    except socket.error as e:
+        raise Exception(f"Failed to send announce request - {str(e)}.")
+
+
+def udp_verify_announce(socket_obj, transaction_id):
+    """
+    Verifies an announce response
+
+    Args:
+        socket_obj: Socket object.
+        transaction_id: Transaction ID.
+
+    Returns:
+        tuple: Tuple containing seeders, leechers, and completed.
+    """
+    try:
+        response = socket_obj.recv(20)
+    except socket.error as e:
+        raise Exception(f"Failed to receive announce response - {str(e)}.")
+    
+    if len(response) < 20:
+        raise Exception(f"Invalid announce response length ({len(response)}).")
+    
+    return_action, return_transaction_id, interval, leechers, seeders = struct.unpack(">IIIII", response)
+    
+    if return_transaction_id != transaction_id:
+        raise Exception(f"Invalid transaction ID ({return_transaction_id} != {transaction_id}).")
+    
+    if return_action != 1:
+        raise Exception(f"Invalid action code ({return_action}).")
+    
+    return (seeders, leechers, 0)
+
+
+def udp_scrape_data(response, hashes, host, keys, start, end, offset):
+    """
+    Parses scrape response
+
+    Args:
+        response: Response from the tracker.
+        hashes: List (>1) or string of infohash(es).
+        host: Domain or IP address of the tracker.
+        keys: List of infohash keys.
+        start: Start position in the response.
+        end: End position in the response.
+        offset: Offset for each result.
+
+    Returns:
+        dict: Dictionary of results.
+    """
+    results = {}
+    
+    # Check if there is enough data for all hashes
+    if (end - start) < (len(hashes) * offset):
+        raise Exception(f"Invalid scrape response from '{host}'.")
+    
+    # Parse each hash
+    for i, infohash in enumerate(hashes):
+        pos = start + (i * offset)
+        
+        if pos + 12 <= end:
+            seeders, completed, leechers = struct.unpack(">III", response[pos:pos+12])
+            
+            results[keys[i]] = {
+                'seeders': seeders,
+                'completed': completed,
+                'leechers': leechers,
+            }
+        else:
+            raise Exception(f"Invalid scrape response from '{host}'.")
+    
+    return results 

scrapeer-1.0.0/scrapeer/utils.py

@@ -0,0 +1,76 @@
+"""
+Utility functions for Scrapeer.
+"""
+
+import re
+import random
+import binascii
+
+
+def normalize_infohashes(infohashes, errors):
+    """
+    Normalizes the given hashes
+
+    Args:
+        infohashes: List of infohash(es).
+        errors: List to append any errors to.
+
+    Returns:
+        list: Normalized infohash(es).
+    """
+    if not isinstance(infohashes, list):
+        infohashes = [infohashes]
+
+    normalized = []
+    for infohash in infohashes:
+        # Convert to lowercase for consistency
+        infohash = infohash.lower()
+        if not re.match(r'^[a-f0-9]{40}$', infohash):
+            errors.append(f'Invalid info hash skipped ({infohash}).')
+        else:
+            normalized.append(infohash)
+
+    total_infohashes = len(normalized)
+    if total_infohashes > 64 or total_infohashes < 1:
+        raise ValueError(f'Invalid amount of valid infohashes ({total_infohashes}).')
+
+    return normalized
+
+
+def get_passkey(path):
+    """
+    Returns the passkey found in the scrape request.
+
+    Args:
+        path: Path from the scrape request.
+
+    Returns:
+        str: Passkey or empty string.
+    """
+    if path and re.search(r'[a-z0-9]{32}', path, re.IGNORECASE):
+        matches = re.search(r'[a-z0-9]{32}', path, re.IGNORECASE)
+        return f'/{matches.group(0)}'
+    return ''
+
+
+def random_peer_id():
+    """
+    Generate a random peer_id.
+
+    Returns:
+        bytes: A random peer_id.
+    """
+    return '-PY0001-' + ''.join([str(random.randint(0, 9)) for _ in range(12)]).encode()
+
+
+def collect_info_hash(infohash):
+    """
+    Converts infohash to binary.
+
+    Args:
+        infohash: Infohash to convert.
+
+    Returns:
+        bytes: Binary representation of the infohash.
+    """
+    return binascii.unhexlify(infohash) 

scrapeer-1.0.0/scrapeer.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: scrapeer
+Version: 1.0.0
+Summary: Essential Python library that scrapes HTTP(S) and UDP trackers for torrent information.
+Home-page: https://github.com/tboy1337/scrapeer-py
+Download-URL: https://github.com/tboy1337/scrapeer-py/releases/latest
+Author: tboy1337
+Author-email: obywhuie@anonaddy.com
+License: MIT
+Keywords: torrent,torrents,scraper,scrapeer,torrent-scraper,torrent-scraping
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Scrapeer-py
+
+A tiny Python library that lets you scrape HTTP(S) and UDP trackers for torrent information.
+
+Scrapeer-py is a Python port of the original PHP [Scrapeer](https://github.com/torrentpier/scrapeer) library by [TorrentPier](https://github.com/torrentpier).
+
+## Overview
+
+Scrapeer-py allows you to retrieve peer information from BitTorrent trackers using both HTTP(S) and UDP protocols. It can fetch seeders, leechers, and completed download counts for multiple torrents from multiple trackers simultaneously.
+
+## Features
+
+- Support for both HTTP(S) and UDP tracker protocols
+- Batch scraping of multiple infohashes at once (up to 64)
+- Support for trackers with passkeys
+- Optional announce mode for trackers that don't support scrape
+- Configurable timeout settings
+- Detailed error reporting
+- Well-organized modular codebase
+
+## Installation
+
+```bash
+pip install scrapeer
+```
+
+## Usage
+
+```python
+from scrapeer import Scraper
+
+# Initialize the scraper
+scraper = Scraper()
+
+# Define your infohashes and trackers
+infohashes = [
+    "0123456789abcdef0123456789abcdef01234567",
+    "fedcba9876543210fedcba9876543210fedcba98"
+]
+
+trackers = [
+    "udp://tracker.example.com:80",
+    "http://tracker.example.org:6969/announce",
+    "https://private-tracker.example.net:443/YOUR_PASSKEY/announce"
+]
+
+# Get the results (timeout of 3 seconds per tracker)
+results = scraper.scrape(
+    hashes=infohashes,
+    trackers=trackers,
+    timeout=3
+)
+
+# Print the results
+for infohash, data in results.items():
+    print(f"Results for {infohash}:")
+    print(f"  Seeders: {data['seeders']}")
+    print(f"  Leechers: {data['leechers']}")
+    print(f"  Completed: {data['completed']}")
+
+# Check if there were any errors
+if scraper.has_errors():
+    print("\nErrors:")
+    for error in scraper.get_errors():
+        print(f"  {error}")
+```
+
+## Package Structure
+
+Scrapeer-py is organized into the following modules:
+
+- `scrapeer/` - Main package directory
+  - `__init__.py` - Package initialization that exports the Scraper class
+  - `scraper.py` - Main Scraper class implementation
+  - `http.py` - HTTP(S) protocol scraping functionality
+  - `udp.py` - UDP protocol scraping functionality
+  - `utils.py` - Utility functions used across the package
+
+## API Reference
+
+### `Scraper` class
+
+#### `scrape(hashes, trackers, max_trackers=None, timeout=2, announce=False)`
+
+Scrape trackers for torrent information.
+
+- **Parameters**:
+  - `hashes`: List (>1) or string of infohash(es)
+  - `trackers`: List (>1) or string of tracker(s)
+  - `max_trackers`: (Optional) Maximum number of trackers to be scraped, Default all
+  - `timeout`: (Optional) Maximum time for each tracker scrape in seconds, Default 2
+  - `announce`: (Optional) Use announce instead of scrape, Default False
+
+- **Returns**:
+  - Dictionary of results with infohashes as keys and stats as values
+
+#### `has_errors()`
+
+Checks if there are any errors.
+
+- **Returns**:
+  - `bool`: True if errors are present, False otherwise
+
+#### `get_errors()`
+
+Returns all the errors that were logged.
+
+- **Returns**:
+  - `list`: All the logged errors
+
+## Limitations
+
+- Maximum of 64 infohashes per request
+- Minimum of 1 infohash per request
+- Only supports BitTorrent trackers (HTTP(S) and UDP)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.

scrapeer-1.0.0/scrapeer.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE.txt
+README.md
+setup.py
+scrapeer/__init__.py
+scrapeer/http.py
+scrapeer/scraper.py
+scrapeer/udp.py
+scrapeer/utils.py
+scrapeer.egg-info/PKG-INFO
+scrapeer.egg-info/SOURCES.txt
+scrapeer.egg-info/dependency_links.txt
+scrapeer.egg-info/top_level.txt

scrapeer-1.0.0/scrapeer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scrapeer-1.0.0/scrapeer.egg-info/top_level.txt

@@ -0,0 +1 @@
+scrapeer

scrapeer-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scrapeer-1.0.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="scrapeer",
+    version="1.0.0",
+    description="Essential Python library that scrapes HTTP(S) and UDP trackers for torrent information.",
+    author="tboy1337",
+    author_email="obywhuie@anonaddy.com",
+    url="https://github.com/tboy1337/scrapeer-py",
+    download_url="https://github.com/tboy1337/scrapeer-py/releases/latest",
+    license="MIT",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    keywords=[
+        "torrent",
+        "torrents",
+        "scraper",
+        "scrapeer",
+        "torrent-scraper",
+        "torrent-scraping"
+    ],
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+)