Spaces:

Fred808
/

trrr14

Paused

App Files Files Community

Fred808 commited on Nov 14, 2025

Commit

2a09f27

verified ·

1 Parent(s): 2ec5a8a

Upload 5 files

Browse files

Files changed (5) hide show

Dockerfile (1) +66 -0
index (2).html +660 -0
main.py +173 -0
requirements (1).txt +3 -0
run.sh +7 -0

Dockerfile (1) ADDED Viewed

	@@ -0,0 +1,66 @@

+# Stage 1: Build Stage (for dependencies)
+FROM python:3.11-slim as builder
+# Install build dependencies for qBittorrent client library
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
+    libssl-dev \
+    libffi-dev \
+    python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+# Set up working directory
+WORKDIR /app
+# Copy only the requirements file to leverage Docker cache
+COPY requirements.txt .
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+# Stage 2: Final Image
+# Use a base image that includes a modern Linux distribution for qBittorrent
+FROM ubuntu:22.04
+# Set environment variables
+ENV DEBIAN_FRONTEND=noninteractive
+ENV QB_WEBUI_PORT=8080
+ENV APP_PORT=8000
+# Install qBittorrent-nox (daemon) and other necessary packages
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    qbittorrent-nox \
+    python3 \
+    python3-pip \
+    # Install tini for proper signal handling and process management
+    tini \
+    && rm -rf /var/lib/apt/lists/*
+# Create a non-root user for security
+RUN useradd -ms /bin/bash qbuser
+# Copy the installed Python packages from the builder stage
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3/dist-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
+# Set up the application directory and copy files
+WORKDIR /home/qbuser/app
+COPY app/ ./app/
+COPY run.sh .
+RUN chmod +x run.sh && \
+    chown -R qbuser:qbuser /home/qbuser/app
+# Set the non-root user
+USER qbuser
+# Expose the FastAPI port and the qBittorrent Web UI port
+EXPOSE 8000
+EXPOSE 8080
+# Use tini as the entrypoint to manage the main process
+ENTRYPOINT ["/usr/bin/tini", "--"]
+# Run the startup script
+CMD ["./run.sh"]

index (2).html ADDED Viewed

	@@ -0,0 +1,660 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>qBittorrent Magnet Link Manager</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        header {
+            text-align: center;
+            color: white;
+            margin-bottom: 30px;
+        }
+        header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+        }
+        header p {
+            font-size: 1.1em;
+            opacity: 0.9;
+        }
+        .status-bar {
+            background: white;
+            padding: 15px 20px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+        .status-bar .status {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+        .status-indicator {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background-color: #4caf50;
+            animation: pulse 2s infinite;
+        }
+        @keyframes pulse {
+            0%, 100% {
+                opacity: 1;
+            }
+            50% {
+                opacity: 0.5;
+            }
+        }
+        .input-section {
+            background: white;
+            padding: 30px;
+            border-radius: 8px;
+            margin-bottom: 30px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+        .input-section h2 {
+            margin-bottom: 20px;
+            color: #333;
+        }
+        .input-group {
+            display: flex;
+            gap: 10px;
+        }
+        input[type="text"] {
+            flex: 1;
+            padding: 12px 15px;
+            border: 2px solid #e0e0e0;
+            border-radius: 5px;
+            font-size: 1em;
+            transition: border-color 0.3s;
+        }
+        input[type="text"]:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+        button {
+            padding: 12px 30px;
+            background-color: #667eea;
+            color: white;
+            border: none;
+            border-radius: 5px;
+            font-size: 1em;
+            cursor: pointer;
+            transition: background-color 0.3s;
+        }
+        button:hover {
+            background-color: #5568d3;
+        }
+        button:active {
+            transform: scale(0.98);
+        }
+        .torrents-section {
+            background: white;
+            padding: 30px;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+        .torrents-section h2 {
+            margin-bottom: 20px;
+            color: #333;
+        }
+        .torrent-list {
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+        }
+        .torrent-item {
+            background: #f9f9f9;
+            padding: 20px;
+            border-radius: 8px;
+            border-left: 4px solid #667eea;
+            transition: transform 0.2s, box-shadow 0.2s;
+        }
+        .torrent-item:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        }
+        .torrent-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: start;
+            margin-bottom: 15px;
+        }
+        .torrent-name {
+            font-weight: 600;
+            color: #333;
+            word-break: break-word;
+            flex: 1;
+        }
+        .torrent-state {
+            padding: 5px 10px;
+            border-radius: 20px;
+            font-size: 0.85em;
+            font-weight: 500;
+            text-transform: uppercase;
+            margin-left: 10px;
+        }
+        .state-downloading {
+            background-color: #e3f2fd;
+            color: #1976d2;
+        }
+        .state-completed {
+            background-color: #e8f5e9;
+            color: #388e3c;
+        }
+        .state-paused {
+            background-color: #fff3e0;
+            color: #f57c00;
+        }
+        .state-error {
+            background-color: #ffebee;
+            color: #c62828;
+        }
+        .torrent-progress {
+            margin-bottom: 10px;
+        }
+        .progress-bar {
+            width: 100%;
+            height: 8px;
+            background-color: #e0e0e0;
+            border-radius: 4px;
+            overflow: hidden;
+            margin-bottom: 5px;
+        }
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #667eea, #764ba2);
+            transition: width 0.3s;
+        }
+        .progress-text {
+            font-size: 0.9em;
+            color: #666;
+            display: flex;
+            justify-content: space-between;
+        }
+        .torrent-stats {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 15px;
+            margin-bottom: 15px;
+            font-size: 0.9em;
+        }
+        .stat {
+            display: flex;
+            flex-direction: column;
+        }
+        .stat-label {
+            color: #999;
+            font-size: 0.85em;
+            text-transform: uppercase;
+            margin-bottom: 3px;
+        }
+        .stat-value {
+            color: #333;
+            font-weight: 600;
+        }
+        .torrent-actions {
+            display: flex;
+            gap: 10px;
+        }
+        .action-btn {
+            padding: 8px 15px;
+            font-size: 0.9em;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            transition: background-color 0.3s;
+        }
+        .pause-btn {
+            background-color: #ff9800;
+            color: white;
+        }
+        .pause-btn:hover {
+            background-color: #f57c00;
+        }
+        .resume-btn {
+            background-color: #4caf50;
+            color: white;
+        }
+        .resume-btn:hover {
+            background-color: #45a049;
+        }
+        .delete-btn {
+            background-color: #f44336;
+            color: white;
+        }
+        .delete-btn:hover {
+            background-color: #da190b;
+        }
+        .empty-state {
+            text-align: center;
+            padding: 40px 20px;
+            color: #999;
+        }
+        .empty-state-icon {
+            font-size: 3em;
+            margin-bottom: 10px;
+        }
+        .loading {
+            text-align: center;
+            padding: 20px;
+            color: #667eea;
+        }
+        .spinner {
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            width: 30px;
+            height: 30px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 10px;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        .alert {
+            padding: 15px 20px;
+            border-radius: 5px;
+            margin-bottom: 20px;
+            display: none;
+        }
+        .alert.show {
+            display: block;
+        }
+        .alert-success {
+            background-color: #e8f5e9;
+            color: #2e7d32;
+            border-left: 4px solid #4caf50;
+        }
+        .alert-error {
+            background-color: #ffebee;
+            color: #c62828;
+            border-left: 4px solid #f44336;
+        }
+        @media (max-width: 768px) {
+            header h1 {
+                font-size: 1.8em;
+            }
+            .input-group {
+                flex-direction: column;
+            }
+            .torrent-stats {
+                grid-template-columns: repeat(2, 1fr);
+            }
+            .torrent-actions {
+                flex-wrap: wrap;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>🚀 qBittorrent Magnet Link Manager</h1>
+            <p>Add magnet links and track your downloads in real-time</p>
+        </header>
+        <div class="status-bar">
+            <div class="status">
+                <div class="status-indicator"></div>
+                <span id="status-text">Connecting to qBittorrent...</span>
+            </div>
+            <div id="refresh-info" style="font-size: 0.9em; color: #666;"></div>
+        </div>
+        <div id="alert" class="alert"></div>
+        <div class="input-section">
+            <h2>Add Magnet Link</h2>
+            <div class="input-group">
+                <input
+                    type="text"
+                    id="magnet-input"
+                    placeholder="Paste your magnet link here (e.g., magnet:?xt=urn:btih:...)"
+                    autocomplete="off"
+                >
+                <button onclick="addTorrent()">Add Torrent</button>
+            </div>
+        </div>
+        <div class="torrents-section">
+            <h2>Active Downloads</h2>
+            <div id="torrents-container" class="loading">
+                <div class="spinner"></div>
+                <p>Loading torrents...</p>
+            </div>
+        </div>
+    </div>
+    <script>
+        const API_BASE = '';
+        const REFRESH_INTERVAL = 2000; // Refresh every 2 seconds
+        let refreshTimer = null;
+        // Format bytes to human-readable format
+        function formatBytes(bytes) {
+            if (bytes === 0) return '0 B';
+            const k = 1024;
+            const sizes = ['B', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+        }
+        // Format seconds to human-readable time
+        function formatTime(seconds) {
+            if (seconds < 0 || seconds === Infinity) return '∞';
+            const hours = Math.floor(seconds / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            const secs = Math.floor(seconds % 60);
+            if (hours > 0) return `${hours}h ${minutes}m`;
+            if (minutes > 0) return `${minutes}m ${secs}s`;
+            return `${secs}s`;
+        }
+        // Show alert message
+        function showAlert(message, type = 'success') {
+            const alertEl = document.getElementById('alert');
+            alertEl.textContent = message;
+            alertEl.className = `alert show alert-${type}`;
+            setTimeout(() => {
+                alertEl.classList.remove('show');
+            }, 5000);
+        }
+        // Check health and update status
+        async function checkHealth() {
+            try {
+                const response = await fetch(`${API_BASE}/health`);
+                if (response.ok) {
+                    document.getElementById('status-text').textContent = '✓ Connected to qBittorrent';
+                } else {
+                    document.getElementById('status-text').textContent = '✗ Connection error';
+                }
+            } catch (error) {
+                document.getElementById('status-text').textContent = '✗ Connection error';
+            }
+        }
+        // Fetch and display torrents
+        async function fetchTorrents() {
+            try {
+                const response = await fetch(`${API_BASE}/api/torrents`);
+                if (!response.ok) throw new Error('Failed to fetch torrents');
+                const data = await response.json();
+                displayTorrents(data.torrents);
+            } catch (error) {
+                console.error('Error fetching torrents:', error);
+                document.getElementById('torrents-container').innerHTML = `
+                    <div class="empty-state">
+                        <div class="empty-state-icon">⚠️</div>
+                        <p>Error loading torrents. Please check your connection.</p>
+                    </div>
+                `;
+            }
+        }
+        // Display torrents in the UI
+        function displayTorrents(torrents) {
+            const container = document.getElementById('torrents-container');
+            if (torrents.length === 0) {
+                container.innerHTML = `
+                    <div class="empty-state">
+                        <div class="empty-state-icon">📭</div>
+                        <p>No torrents yet. Add a magnet link to get started!</p>
+                    </div>
+                `;
+                return;
+            }
+            container.innerHTML = '<div class="torrent-list">' + torrents.map(torrent => {
+                const stateClass = `state-${torrent.state.toLowerCase()}`;
+                const isPaused = torrent.state.toLowerCase() === 'paused';
+                const isCompleted = torrent.state.toLowerCase() === 'uploading' || torrent.progress === 100;
+                return `
+                    <div class="torrent-item">
+                        <div class="torrent-header">
+                            <div class="torrent-name">${escapeHtml(torrent.name)}</div>
+                            <div class="torrent-state ${stateClass}">${torrent.state}</div>
+                        </div>
+                        <div class="torrent-progress">
+                            <div class="progress-bar">
+                                <div class="progress-fill" style="width: ${torrent.progress}%"></div>
+                            </div>
+                            <div class="progress-text">
+                                <span>${torrent.progress.toFixed(1)}%</span>
+                                <span>${formatBytes(torrent.downloaded)} / ${formatBytes(torrent.total_size)}</span>
+                            </div>
+                        </div>
+                        <div class="torrent-stats">
+                            <div class="stat">
+                                <div class="stat-label">Download Speed</div>
+                                <div class="stat-value">${formatBytes(torrent.download_speed)}/s</div>
+                            </div>
+                            <div class="stat">
+                                <div class="stat-label">Upload Speed</div>
+                                <div class="stat-value">${formatBytes(torrent.upload_speed)}/s</div>
+                            </div>
+                            <div class="stat">
+                                <div class="stat-label">ETA</div>
+                                <div class="stat-value">${formatTime(torrent.eta)}</div>
+                            </div>
+                            <div class="stat">
+                                <div class="stat-label">Seeds / Peers</div>
+                                <div class="stat-value">${torrent.num_seeds} / ${torrent.num_leechs}</div>
+                            </div>
+                        </div>
+                        <div class="torrent-actions">
+                            ${isPaused ?
+                                `<button class="action-btn resume-btn" onclick="resumeTorrent('${torrent.hash}')">Resume</button>` :
+                                `<button class="action-btn pause-btn" onclick="pauseTorrent('${torrent.hash}')">Pause</button>`
+                            }
+                            <button class="action-btn delete-btn" onclick="deleteTorrent('${torrent.hash}')">Delete</button>
+                        </div>
+                    </div>
+                `;
+            }).join('') + '</div>';
+        }
+        // Escape HTML to prevent XSS
+        function escapeHtml(text) {
+            const map = {
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&#039;'
+            };
+            return text.replace(/[&<>"']/g, m => map[m]);
+        }
+        // Add a new torrent
+        async function addTorrent() {
+            const input = document.getElementById('magnet-input');
+            const magnetLink = input.value.trim();
+            if (!magnetLink) {
+                showAlert('Please enter a magnet link', 'error');
+                return;
+            }
+            try {
+                const response = await fetch(`${API_BASE}/api/add_torrent`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ magnet_link: magnetLink })
+                });
+                if (!response.ok) {
+                    const error = await response.json();
+                    throw new Error(error.detail || 'Failed to add torrent');
+                }
+                showAlert('Torrent added successfully!', 'success');
+                input.value = '';
+                await fetchTorrents();
+            } catch (error) {
+                showAlert(`Error: ${error.message}`, 'error');
+            }
+        }
+        // Pause a torrent
+        async function pauseTorrent(hash) {
+            try {
+                const response = await fetch(`${API_BASE}/api/torrents/${hash}/pause`, {
+                    method: 'POST'
+                });
+                if (!response.ok) throw new Error('Failed to pause torrent');
+                showAlert('Torrent paused', 'success');
+                await fetchTorrents();
+            } catch (error) {
+                showAlert(`Error: ${error.message}`, 'error');
+            }
+        }
+        // Resume a torrent
+        async function resumeTorrent(hash) {
+            try {
+                const response = await fetch(`${API_BASE}/api/torrents/${hash}/resume`, {
+                    method: 'POST'
+                });
+                if (!response.ok) throw new Error('Failed to resume torrent');
+                showAlert('Torrent resumed', 'success');
+                await fetchTorrents();
+            } catch (error) {
+                showAlert(`Error: ${error.message}`, 'error');
+            }
+        }
+        // Delete a torrent
+        async function deleteTorrent(hash) {
+            if (!confirm('Are you sure you want to delete this torrent?')) return;
+            try {
+                const response = await fetch(`${API_BASE}/api/torrents/${hash}`, {
+                    method: 'DELETE'
+                });
+                if (!response.ok) throw new Error('Failed to delete torrent');
+                showAlert('Torrent deleted', 'success');
+                await fetchTorrents();
+            } catch (error) {
+                showAlert(`Error: ${error.message}`, 'error');
+            }
+        }
+        // Allow Enter key to add torrent
+        document.getElementById('magnet-input').addEventListener('keypress', function(event) {
+            if (event.key === 'Enter') {
+                addTorrent();
+            }
+        });
+        // Initialize
+        window.addEventListener('load', async () => {
+            await checkHealth();
+            await fetchTorrents();
+            // Set up auto-refresh
+            refreshTimer = setInterval(async () => {
+                await fetchTorrents();
+            }, REFRESH_INTERVAL);
+        });
+        // Clean up on page unload
+        window.addEventListener('beforeunload', () => {
+            if (refreshTimer) clearInterval(refreshTimer);
+        });
+    </script>
+</body>
+</html>

main.py ADDED Viewed

	@@ -0,0 +1,173 @@

+import os
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from qbittorrent import Client
+from typing import List, Optional
+# --- Configuration ---
+# The qBittorrent-nox daemon is started on port 8080 inside the container.
+# The default credentials for qbittorrent-nox are admin/adminadmin.
+# In a real-world scenario, these should be securely managed.
+QB_HOST = os.getenv("QB_HOST", "localhost")
+QB_PORT = os.getenv("QB_PORT", "8080")
+QB_USER = os.getenv("QB_USER", "admin")
+QB_PASS = os.getenv("QB_PASS", "adminadmin")
+# --- FastAPI App Initialization ---
+app = FastAPI(
+    title="qBittorrent Magnet Link API",
+    description="A simple FastAPI service to add magnet links to a running qBittorrent instance with download tracking.",
+    version="2.0.0"
+)
+# Mount static files (frontend)
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
+# --- Pydantic Models ---
+class MagnetLink(BaseModel):
+    magnet_link: str
+class StatusResponse(BaseModel):
+    status: str
+    message: str
+class TorrentInfo(BaseModel):
+    name: str
+    hash: str
+    state: str
+    progress: float
+    downloaded: int
+    total_size: int
+    upload_speed: int
+    download_speed: int
+    eta: int
+    num_seeds: int
+    num_leechs: int
+class TorrentListResponse(BaseModel):
+    torrents: List[TorrentInfo]
+    total_count: int
+# --- Utility Function for qBittorrent Client ---
+def get_qb_client():
+    """Initializes and logs into the qBittorrent client."""
+    try:
+        qb = Client(f'http://{QB_HOST}:{QB_PORT}')
+        qb.login(QB_USER, QB_PASS)
+        return qb
+    except Exception as e:
+        raise HTTPException(status_code=503, detail=f"Could not connect or log in to qBittorrent: {e}")
+# --- Endpoints ---
+@app.get("/", response_class=FileResponse)
+async def serve_frontend():
+    """Serves the main HTML frontend."""
+    return FileResponse("app/static/index.html")
+@app.get("/health", response_model=StatusResponse)
+async def health_check():
+    """Checks the health of the FastAPI service and qBittorrent connection."""
+    try:
+        qb = get_qb_client()
+        # A simple call to verify connection and authentication
+        version = qb.app.version
+        return StatusResponse(status="ok", message=f"FastAPI is running and connected to qBittorrent v{version}")
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal server error during health check: {e}")
+@app.post("/api/add_torrent", response_model=StatusResponse)
+async def add_torrent(link: MagnetLink):
+    """Adds a magnet link to the qBittorrent download queue."""
+    qb = get_qb_client()
+    try:
+        # The add_torrent method handles both magnet links and .torrent files
+        qb.torrents_add(urls=link.magnet_link)
+        return StatusResponse(
+            status="success",
+            message=f"Successfully added magnet link to qBittorrent"
+        )
+    except Exception as e:
+        # Log the error and return a user-friendly message
+        print(f"Error adding torrent: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to add torrent: {e}")
+@app.get("/api/torrents", response_model=TorrentListResponse)
+async def get_torrents():
+    """Fetches the list of all torrents with their current status."""
+    qb = get_qb_client()
+    try:
+        torrents = qb.torrents()
+        torrent_list = []
+        for torrent in torrents:
+            torrent_info = TorrentInfo(
+                name=torrent.get('name', 'Unknown'),
+                hash=torrent.get('hash', ''),
+                state=torrent.get('state', 'unknown'),
+                progress=torrent.get('progress', 0) * 100,  # Convert to percentage
+                downloaded=torrent.get('downloaded', 0),
+                total_size=torrent.get('total_size', 0),
+                upload_speed=torrent.get('upspeed', 0),
+                download_speed=torrent.get('dlspeed', 0),
+                eta=torrent.get('eta', 0),
+                num_seeds=torrent.get('num_seeds', 0),
+                num_leechs=torrent.get('num_leechs', 0),
+            )
+            torrent_list.append(torrent_info)
+        return TorrentListResponse(torrents=torrent_list, total_count=len(torrent_list))
+    except Exception as e:
+        print(f"Error fetching torrents: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to fetch torrents: {e}")
+@app.delete("/api/torrents/{torrent_hash}")
+async def delete_torrent(torrent_hash: str, delete_files: bool = False):
+    """Deletes a torrent from the qBittorrent instance."""
+    qb = get_qb_client()
+    try:
+        qb.torrents_delete(torrent_hashes=torrent_hash, delete_files=delete_files)
+        return StatusResponse(
+            status="success",
+            message=f"Successfully deleted torrent"
+        )
+    except Exception as e:
+        print(f"Error deleting torrent: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to delete torrent: {e}")
+@app.post("/api/torrents/{torrent_hash}/pause")
+async def pause_torrent(torrent_hash: str):
+    """Pauses a torrent."""
+    qb = get_qb_client()
+    try:
+        qb.torrents_pause(torrent_hashes=torrent_hash)
+        return StatusResponse(
+            status="success",
+            message=f"Successfully paused torrent"
+        )
+    except Exception as e:
+        print(f"Error pausing torrent: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to pause torrent: {e}")
+@app.post("/api/torrents/{torrent_hash}/resume")
+async def resume_torrent(torrent_hash: str):
+    """Resumes a torrent."""
+    qb = get_qb_client()
+    try:
+        qb.torrents_resume(torrent_hashes=torrent_hash)
+        return StatusResponse(
+            status="success",
+            message=f"Successfully resumed torrent"
+        )
+    except Exception as e:
+        print(f"Error resuming torrent: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to resume torrent: {e}")

requirements (1).txt ADDED Viewed

	@@ -0,0 +1,3 @@

+fastapi
+uvicorn[standard]
+python-qbittorrent

run.sh ADDED Viewed

	@@ -0,0 +1,7 @@

+#!/bin/bash
+# Start the qBittorrent daemon in the background
+qbittorrent-nox --webui-port=$QB_WEBUI_PORT &
+# Start the FastAPI application
+uvicorn app.main:app --host 0.0.0.0 --port $APP_PORT