rpirate 0.1.0__tar.gz

rpirate-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include src/pirate_three/templates *
+recursive-include src/pirate_three/static *
+include src/pirate_three/default_config.yaml

rpirate-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: rpirate
+Version: 0.1.0
+Summary: A full stack torrent streaming app to get you free movies.
+Author: Miles Hilliard
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: Flask
+Requires-Dist: python-vlc
+Requires-Dist: PyYAML
+Requires-Dist: requests
+Requires-Dist: tpblite
+
+# PiRate v3.0
+
+Stream your favorite movies and TV shows for free.
+
+PiRate is a modern, mobile-friendly web interface that wraps The Pirate Bay (TPB) and the qBittorrent API to provide a seamless, Netflix-like streaming experience from your couch. 
+
+> **Disclaimer:** This software is an interface for third-party APIs and torrent sites. The creator of this software is not responsible for any content downloaded, hosted, or distributed. Please use a VPN and use responsibly in accordance with your local laws.
+
+## Features
+
+- **Cinematic UI:** Beautiful, responsive dark-mode interface optimized for mobile and desktop.
+- **Dynamic Content:** Browse trending and genre-specific movies fetched directly via the YTS API.
+- **Virtual Remote:** Control playback directly from your smartphone with a sleek web remote.
+- **Live Downloads:** Monitor and manage your active torrents with real-time progress.
+
+## Quick Start
+
+### 1. Prerequisites
+Ensure you have the following installed:
+- [Python 3](https://www.python.org/downloads/)
+- [VLC Media Player](https://www.videolan.org/vlc/)
+- [qBittorrent](https://www.qbittorrent.org/)
+- A reliable VPN (e.g., [Proton VPN](https://protonvpn.com))
+
+### 2. Installation
+```sh
+git clone https://github.com/syntaxerror019/pirate-three.git
+cd pirate-three
+pip install -r requirements.txt
+```
+
+### 3. Usage
+Make sure qBittorrent is running in the background, then start the PiRate server:
+```sh
+python3 main.py
+```
+Open your browser and navigate to `http://localhost:3000`.
+
+## Contributing
+Issues and Pull Requests are always welcome!

rpirate-0.1.0/README.md

@@ -0,0 +1,40 @@
+# PiRate v3.0
+
+Stream your favorite movies and TV shows for free.
+
+PiRate is a modern, mobile-friendly web interface that wraps The Pirate Bay (TPB) and the qBittorrent API to provide a seamless, Netflix-like streaming experience from your couch. 
+
+> **Disclaimer:** This software is an interface for third-party APIs and torrent sites. The creator of this software is not responsible for any content downloaded, hosted, or distributed. Please use a VPN and use responsibly in accordance with your local laws.
+
+## Features
+
+- **Cinematic UI:** Beautiful, responsive dark-mode interface optimized for mobile and desktop.
+- **Dynamic Content:** Browse trending and genre-specific movies fetched directly via the YTS API.
+- **Virtual Remote:** Control playback directly from your smartphone with a sleek web remote.
+- **Live Downloads:** Monitor and manage your active torrents with real-time progress.
+
+## Quick Start
+
+### 1. Prerequisites
+Ensure you have the following installed:
+- [Python 3](https://www.python.org/downloads/)
+- [VLC Media Player](https://www.videolan.org/vlc/)
+- [qBittorrent](https://www.qbittorrent.org/)
+- A reliable VPN (e.g., [Proton VPN](https://protonvpn.com))
+
+### 2. Installation
+```sh
+git clone https://github.com/syntaxerror019/pirate-three.git
+cd pirate-three
+pip install -r requirements.txt
+```
+
+### 3. Usage
+Make sure qBittorrent is running in the background, then start the PiRate server:
+```sh
+python3 main.py
+```
+Open your browser and navigate to `http://localhost:3000`.
+
+## Contributing
+Issues and Pull Requests are always welcome!

rpirate-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rpirate"
+version = "0.1.0"
+authors = [
+  { name="Miles Hilliard" },
+]
+description = "A full stack torrent streaming app to get you free movies."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "Flask",
+    "python-vlc",
+    "PyYAML",
+    "requests",
+    "tpblite"
+]
+
+[project.scripts]
+pirate = "pirate_three:main"

rpirate-0.1.0/setup.cfg

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

rpirate-0.1.0/src/pirate_three/__init__.py

@@ -0,0 +1 @@
+from .main import main

rpirate-0.1.0/src/pirate_three/config.py

@@ -0,0 +1,33 @@
+import yaml
+import os
+import shutil
+
+class Config():
+    def __init__(self, config_file="config.yaml"):
+        self.config_file = config_file
+        self.ensure_config()
+        self.load_config()
+
+    def ensure_config(self):
+        """Ensure the config file exists in the current working directory, otherwise copy default."""
+        if not os.path.exists(self.config_file):
+            print(f"[{self.config_file}] not found in current directory. Creating default configuration.")
+            
+            # Find default_config.yaml in the package directory
+            pkg_dir = os.path.dirname(os.path.abspath(__file__))
+            default_config_path = os.path.join(pkg_dir, "default_config.yaml")
+            
+            if os.path.exists(default_config_path):
+                shutil.copy(default_config_path, self.config_file)
+            else:
+                print("Error: Package default_config.yaml is missing!")
+
+    def load_config(self):
+        if os.path.exists(self.config_file):
+            with open(self.config_file, 'r') as file:
+                self.config = yaml.safe_load(file) or {}
+        else:
+            self.config = {}
+
+    def get(self, key, default=None):
+        return self.config.get(key, default)

rpirate-0.1.0/src/pirate_three/default_config.yaml

@@ -0,0 +1,24 @@
+############### www.mileshilliard.com ###################
+#
+# User Configuration File.
+#
+# Adjust settings per your taste and preference!
+#
+# The default settings should work fine, 
+# so there is no immediate need to touch this.
+#
+#########################################################
+
+download_folder: /home/miles/Downloads/pirate-downloads
+create_folder: true
+
+# Network
+
+tbp_url: https://thepiratebay7.com/
+host: 0.0.0.0
+port: 3000
+
+# QBitTorrent
+
+qb_url: http://localhost:8080
+use_old_api: false # Leave off unless you have an old version of qBittorrent

rpirate-0.1.0/src/pirate_three/logger.py

@@ -0,0 +1,39 @@
+import logging
+import sys
+
+# ANSI escape codes
+LOG_COLORS = {
+    "DEBUG": "\033[36m",    # Cyan
+    "INFO": "\033[32m",     # Green
+    "WARNING": "\033[33m",  # Yellow
+    "ERROR": "\033[31m",    # Red
+    "CRITICAL": "\033[35m", # Magenta
+    "RESET": "\033[0m"      # Reset to default
+}
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        log_color = LOG_COLORS.get(record.levelname, LOG_COLORS["RESET"])
+        record.msg = f"{log_color}{record.msg}{LOG_COLORS['RESET']}"
+        return super().format(record)
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("app.log"),  # Log to a file (no colors)
+        logging.StreamHandler(sys.stdout)  # log to console
+    ]
+)
+
+# colored formatting to console logs only
+console_handler = logging.getLogger().handlers[1]  # Second handler (StreamHandler)
+console_handler.setFormatter(ColoredFormatter("%(asctime)s - %(levelname)s - %(message)s"))
+
+if __name__ == "__main__":
+    # Test the logger
+    logging.debug("This is a debug message")
+    logging.info("This is an info message")
+    logging.warning("This is a warning")
+    logging.error("This is an error")
+    logging.critical("This is a critical error")

rpirate-0.1.0/src/pirate_three/main.py

@@ -0,0 +1,216 @@
+from flask import Flask, request, jsonify, render_template
+from tpblite import TPB
+import subprocess
+import socket
+import urllib.request
+import json
+import os
+import sys
+
+from .player import Player
+from .torrent import tr
+from .config import Config
+
+# Init Flask with explicit template/static folder paths so it works when installed via pip
+pkg_dir = os.path.dirname(os.path.abspath(__file__))
+template_dir = os.path.join(pkg_dir, "templates")
+static_dir = os.path.join(pkg_dir, "static")
+
+app = Flask(__name__, template_folder=template_dir, static_folder=static_dir)
+
+cf = Config("config.yaml")
+
+# Init Pirate Bay
+tpb = TPB(base_url=cf.get("tbp_url"))
+
+player = Player()
+
+# Init qBittorrent wrapper (API v4 by default)
+qb = tr(url=cf.get("qb_url"))   # qBittorrent default WebUI port is 8080
+
+def get_local_ip():
+    try:
+        # Use hostname -I to get all IPs and prioritize the typical home Wi-Fi range
+        output = subprocess.check_output(['hostname', '-I'], text=True).strip()
+        ips = output.split()
+        
+        # 1. Highest priority: 192.168.x.x (standard home router)
+        for ip in ips:
+            if ip.startswith("192.168."):
+                return ip
+                
+        # 2. Secondary priority: other local subnets excluding common VPN/Docker defaults
+        for ip in ips:
+            if (ip.startswith("10.") and not ip.startswith("10.2.")) or \
+               (ip.startswith("172.") and not ip.startswith("172.17.")):
+                return ip
+                
+        # 3. Fallback to the first valid IPv4 that isn't localhost
+        for ip in ips:
+            if "." in ip and not ip.startswith("127."):
+                return ip
+    except Exception:
+        pass
+
+    try:
+        # Last resort fallback: dummy UDP socket
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.settimeout(0.5)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except:
+        return "127.0.0.1"
+
+@app.route("/")
+def index():    
+    return render_template("index.html")
+
+@app.route("/mydownloads")
+def downloads_page():
+    return render_template("downloads.html")
+
+@app.route("/controller")
+def remote():
+    return render_template("controller.html")
+
+@app.route("/api/movies")
+def api_movies():
+    qs = request.query_string.decode('utf-8')
+    url = f"https://yts.lt/api/v2/list_movies.json?{qs}"
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=10) as response:
+            data = json.loads(response.read().decode('utf-8'))
+            return jsonify(data)
+    except Exception as e:
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route("/search")
+def search():
+    query = request.args.get("q", "")
+    if not query:
+        return jsonify([])
+    torrents = tpb.search(query)
+    results = [{
+        "title": t.title,
+        "seeds": t.seeds,
+        "leeches": t.leeches,
+        "upload_date": t.upload_date,
+        "uploader": t.uploader,
+        "filesize": t.filesize,
+        "byte_size": t.byte_size,
+        "magnetlink": t.magnetlink,
+        "url": t.url,
+        "is_trusted": t.is_trusted,
+        "is_vip": t.is_vip,
+        "infohash": t.infohash,
+        "category": t.category
+    } for t in torrents]
+    return jsonify(results)
+
+@app.route("/download", methods=["POST"])
+def download():
+    data = request.get_json()
+    magnet = data.get("magnetlink")
+    if not magnet:
+        return jsonify({"error": "No magnetlink"}), 400
+    
+    success = qb.download_torrent(magnet)
+    if success:
+        return jsonify({"status": "added"})
+    return jsonify({"status": "failed"}), 500
+
+@app.route("/downloads")
+def downloads():
+    try:
+        tasks = qb.torrent_status()
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    
+    results = [{
+        "hash": d["hash"],
+        "name": d["name"],
+        "status": d["state"],
+        "progress": f"{d['progress']*100:.2f}%",
+        "speed": f"{d['dlspeed']/1024:.1f} KiB/s",
+        "eta": tr.format_eta(d["eta"])
+    } for d in tasks]
+    return jsonify(results)
+
+@app.route('/watch/<name>')
+def watch(name):
+    file = qb.get_file_path(name)
+    if not file:
+        return jsonify({"error": "File not found"}), 404
+    
+    player.set_media(file)
+    player.play()
+    
+    return jsonify({'error': None, 'file': file}), 200
+
+@app.route('/remove/<hash>', methods=['DELETE'])
+def remove(hash):
+    success = qb.delete(hash)
+    if success:
+        return jsonify({'error': None}), 200
+    return jsonify({'error': 'Failed to remove torrent'}), 500
+
+@app.route("/pause/<hash>", methods=["POST"])
+def pause(hash):
+    if not hash:
+        return jsonify({"error": "No hash"}), 400
+    qb.pause(hash)
+    return jsonify({"status": "paused"})
+
+@app.route("/resume/<hash>", methods=["POST"])
+def resume(hash):
+    if not hash:
+        return jsonify({"error": "No hash"}), 400
+    qb.resume(hash)
+    return jsonify({"status": "resumed"})
+
+@app.route('/command/<cmd>', methods=['POST'])
+def command(cmd):
+    if cmd == "plp":
+        player.pause()
+    if cmd == "stp":
+        print("STOPPING")
+        player.stop_and_close()
+    if cmd == "rrw":
+        player.rewind(60)
+    if cmd == "ffw":
+        player.fast_forward(60)
+    if cmd == "ccy":
+        player.enable_subtitles()
+    if cmd == "ccn":
+        player.disable_subtitles()
+        
+        
+    return jsonify({"status": "success"})
+
+def setup():
+    qb.set_torrent_download_location(cf.get("download_folder"), create=cf.get("create_folder", True))
+
+    if not qb.check_connection():
+        raise Exception("Failed to connect to QBittorrent. Please check your settings and ensure QBittorrent is running.")
+
+def main():
+    setup()
+    
+    port = cf.get("port")
+    if not port:
+        port = 3000
+        
+    app_url = f"http://{get_local_ip()}:{port}"
+    print(f"Starting overlay with URL: {app_url}")
+    
+    # Calculate the path to the overlay script dynamically so it works anywhere
+    overlay_path = os.path.join(pkg_dir, "overlay.py")
+    subprocess.Popen([sys.executable, overlay_path, app_url])
+    
+    app.run(debug=False, host=cf.get("host"), port=port)
+
+if __name__ == "__main__":
+    main()

rpirate-0.1.0/src/pirate_three/overlay.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+import tkinter as tk
+import sys
+import time
+import math
+import random
+from datetime import datetime
+
+def get_ip_from_args():
+    if len(sys.argv) > 1:
+        return sys.argv[1]
+    return "No IP Provided"
+
+class IPOverlay:
+    def __init__(self, root, ip_text):
+        self.root = root
+        self.ip_text = ip_text
+
+        # Configure window
+        root.title("PiRate Idle Screen")
+        root.geometry(f"{root.winfo_screenwidth()}x{root.winfo_screenheight()}+0+0")
+        root.overrideredirect(True)
+        root.attributes("-topmost", True)
+        root.configure(bg="#050505")
+        try:
+            root.attributes("-fullscreen", True)
+        except:
+            pass
+            
+        root.config(cursor="none") # Hide mouse cursor
+
+        self.w = root.winfo_screenwidth()
+        self.h = root.winfo_screenheight()
+
+        # Main canvas for drawing
+        self.canvas = tk.Canvas(root, bg="#050505", highlightthickness=0, width=self.w, height=self.h)
+        self.canvas.pack(fill="both", expand=True)
+
+        # Create glowing orbs (cinematic Apple TV style)
+        self.orbs = []
+        # Dark, subtle ambient colors
+        colors = ["#1a0f2e", "#0f172a", "#2e0f1a"]
+        for i, color in enumerate(colors):
+            size = self.h * 1.5
+            x = self.w / 2
+            y = self.h / 2
+            orb = self.canvas.create_oval(x-size/2, y-size/2, x+size/2, y+size/2, fill=color, outline="")
+            self.orbs.append({"id": orb, "cx": x, "cy": y, "r": size/2, "offset": i*2.5})
+
+        # Create particles (stars/dust)
+        self.particles = []
+        for _ in range(80):
+            x = random.randint(0, self.w)
+            y = random.randint(0, self.h)
+            r = random.uniform(0.5, 1.8)
+            dx = random.uniform(-0.3, 0.3)
+            dy = random.uniform(-0.3, 0.3)
+            opacity = random.uniform(0.1, 0.6)
+            shade = int(255 * opacity)
+            color = f"#{shade:02x}{shade:02x}{shade:02x}"
+            p_id = self.canvas.create_oval(x-r, y-r, x+r, y+r, fill=color, outline="")
+            self.particles.append({"id": p_id, "x": x, "y": y, "dx": dx, "dy": dy, "r": r})
+
+        # Text fonts
+        font_time = ("Helvetica", max(72, int(self.h / 8)), "normal")
+        font_date = ("Helvetica", max(24, int(self.h / 30)), "normal")
+        font_large = ("Helvetica", max(48, int(self.h / 15)), "bold")
+        font_small = ("Helvetica", max(20, int(self.h / 35)))
+
+        # Time/Date overlay (top/center)
+        self.time_text = self.canvas.create_text(self.w/2, self.h/4, text="", font=font_time, fill="#ffffff")
+        self.date_text = self.canvas.create_text(self.w/2, self.h/4 + max(60, int(self.h/15)), text="", font=font_date, fill="#a1a1aa")
+
+        # Center text
+        self.title_text = self.canvas.create_text(self.w/2, self.h*0.65, text="PiRate Remote", font=font_large, fill="#ffffff")
+        self.url_text = self.canvas.create_text(self.w/2, self.h*0.65 + max(40, int(self.h/20)), text=f"Connect to: {self.ip_text}", font=font_small, fill="#38bdf8")
+
+        # Bindings to close
+        root.bind("<Key>", lambda e: root.destroy())
+        root.bind("<Button-1>", lambda e: root.destroy())
+
+        self._running = True
+        self._animate()
+        self._update_time()
+
+    def _update_time(self):
+        if not self._running:
+            return
+        now = datetime.now()
+        time_str = now.strftime("%I:%M %p").lstrip('0')
+        date_str = now.strftime("%A, %B %d")
+        
+        self.canvas.itemconfig(self.time_text, text=time_str)
+        self.canvas.itemconfig(self.date_text, text=date_str)
+        
+        # Bring all text to front
+        self.canvas.tag_raise(self.time_text)
+        self.canvas.tag_raise(self.date_text)
+        self.canvas.tag_raise(self.title_text)
+        self.canvas.tag_raise(self.url_text)
+        
+        self.root.after(1000, self._update_time)
+
+    def _animate(self):
+        if not self._running:
+            return
+            
+        t = time.time() * 0.15
+        
+        # Slowly move the orbs around to create a breathing cinematic effect
+        for i, orb in enumerate(self.orbs):
+            dx = math.sin(t + orb["offset"]) * (self.w * 0.25)
+            dy = math.cos(t * 0.8 + orb["offset"]) * (self.h * 0.25)
+            
+            x1 = orb["cx"] + dx - orb["r"]
+            y1 = orb["cy"] + dy - orb["r"]
+            x2 = orb["cx"] + dx + orb["r"]
+            y2 = orb["cy"] + dy + orb["r"]
+            
+            self.canvas.coords(orb["id"], x1, y1, x2, y2)
+
+        # Move particles
+        for p in self.particles:
+            p["x"] += p["dx"]
+            p["y"] += p["dy"]
+            
+            # wrap around
+            if p["x"] < 0: p["x"] = self.w
+            elif p["x"] > self.w: p["x"] = 0
+            if p["y"] < 0: p["y"] = self.h
+            elif p["y"] > self.h: p["y"] = 0
+            
+            self.canvas.coords(p["id"], p["x"]-p["r"], p["y"]-p["r"], p["x"]+p["r"], p["y"]+p["r"])
+
+        self.root.after(40, self._animate)
+
+def main():
+    ip = get_ip_from_args()
+    root = tk.Tk()
+    app = IPOverlay(root, ip)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()

rpirate-0.1.0/src/pirate_three/player.py

@@ -0,0 +1,77 @@
+import vlc
+import time
+import os
+from .logger import logging
+
+class Player:
+    def __init__(self):
+        self.media_path = None
+        self.instance = vlc.Instance()
+        self.player = self.instance.media_player_new()
+
+    def set_media(self, media_path):
+        self.media_path = media_path
+        media = self.instance.media_new(media_path)
+        self.player.set_media(media)
+
+    def play(self):
+        if not self.media_path:
+            logging.error("No media file set!")
+            return
+        self.player.set_fullscreen(True)
+        self.player.play()
+        self.player.video_set_spu(-1)
+        return True
+
+    def pause(self):
+        if self.player.is_playing():
+            self.player.pause()
+        else:
+            self.player.play()
+
+    def fast_forward(self, seconds=10):
+        current_time = self.player.get_time()
+        self.player.set_time(current_time + (seconds * 1000))
+
+    def rewind(self, seconds=10):
+        current_time = self.player.get_time()
+        new_time = max(0, current_time - (seconds * 1000))
+        self.player.set_time(new_time)
+
+    def enable_subtitles(self):
+        spu_count = self.player.video_get_spu_count()  # Get number of available subtitle tracks
+        logging.debug(f"Available subtitle tracks: {spu_count}")
+        
+        if spu_count > 0:
+            spu_tracks = self.player.video_get_spu_description()
+            if len(spu_tracks) > 1:
+                second_track = spu_tracks[1][0]  # Extract the second subtitle track ID
+                logging.debug(f"Enabling subtitles: Track {second_track}")
+                self.player.video_set_spu(second_track)
+            else:
+                logging.debug("Second subtitle track not available.")
+        else:
+            logging.debug("No subtitles available.")
+
+
+    def disable_subtitles(self):
+        self.player.video_set_spu(-1)  # -1 disables subtitles
+
+    def stop_and_close(self):
+        self.player.stop()
+
+    def is_playing(self):
+        return self.player.is_playing()
+
+if __name__ == "__main__":
+    player = Player()
+    player.set_media("example.mp4")
+    player.play()
+    time.sleep(5)  # Let it play for 5 seconds
+    player.fast_forward(10)  # Fast forward 10 seconds
+    time.sleep(5)
+    player.pause()
+    time.sleep(2)
+    player.play()
+    time.sleep(5)
+    player.stop_and_close()