Spaces:

EGAuto
/

Torrent2Space

Sleeping

App Files Files Community

alisaadhq commited on May 25

Commit

d286c92

verified ·

1 Parent(s): f09630e

Upload 19 files

Browse files

Files changed (19) hide show

Dockerfile +23 -0
README.md +36 -8
app.py +5 -0
requirements.txt +6 -0
static/index.html +379 -0
torrent2drive/__init__.py +1 -0
torrent2drive/app.py +52 -0
torrent2drive/config.py +34 -0
torrent2drive/constants.py +14 -0
torrent2drive/routes/__init__.py +15 -0
torrent2drive/routes/control.py +87 -0
torrent2drive/routes/files.py +99 -0
torrent2drive/routes/pages.py +17 -0
torrent2drive/routes/torrent.py +115 -0
torrent2drive/services/__init__.py +1 -0
torrent2drive/services/pipeline.py +83 -0
torrent2drive/session.py +128 -0
torrent2drive/torrent_engine.py +113 -0
torrent2drive/utils.py +47 -0

Dockerfile ADDED Viewed

	@@ -0,0 +1,23 @@

+FROM python:3.11-slim
+WORKDIR /app
+# System deps for libtorrent
+RUN apt-get update && apt-get install -y \
+    python3-libtorrent \
+    libboost-python-dev \
+    && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+# Create writable dirs
+RUN mkdir -p /app/_users /app/static
+EXPOSE 7860
+ENV PORT=7860
+CMD ["python", "-m", "uvicorn", "torrent2drive.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md CHANGED Viewed

@@ -1,13 +1,41 @@
 ---
 title: Torrent2Space
-emoji: 🚀
-colorFrom: gray
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
-app_file: app.py
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
 title: Torrent2Space
+emoji: 🌊
+colorFrom: purple
+colorTo: blue
+sdk: docker
 pinned: false
 ---
+# Torrent2Space 🌊
+A **Seedr-style** torrent client that runs entirely on HuggingFace Space disk — no Google Drive, no external storage.
+## How it works
+1. Paste a **magnet link** or upload a **.torrent file**
+2. Select which files you want
+3. Hit **Start Download** — the torrent downloads to the Space's local disk
+4. When done, **download** the files directly to your computer from "My Files"
+## API Endpoints
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `POST` | `/api/load_magnet` | Load a magnet link |
+| `POST` | `/api/load_torrent` | Load a .torrent file (base64) |
+| `POST` | `/api/start` | Start downloading selected files |
+| `POST` | `/api/pause` | Pause the torrent |
+| `POST` | `/api/resume` | Resume the torrent |
+| `POST` | `/api/stop` | Stop and clear |
+| `GET` | `/api/status` | Get download status & progress |
+| `GET` | `/api/files` | List all downloaded files |
+| `GET` | `/api/download/{path}` | Download a file |
+| `DELETE` | `/api/files/{path}` | Delete a specific file |
+| `DELETE` | `/api/files` | Delete all files |
+## Notes
+- Files are stored on the Space disk for the duration of your session
+- Sessions are cleaned up after 6 hours of inactivity
+- No Google account needed

app.py ADDED Viewed

	@@ -0,0 +1,5 @@

+"""Entry point."""
+from torrent2drive.app import app, main
+if __name__ == "__main__":
+    main()

requirements.txt ADDED Viewed

	@@ -0,0 +1,6 @@

+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+python-multipart>=0.0.9
+starlette>=0.37.0
+itsdangerous>=2.1.2
+libtorrent>=2.0.0

static/index.html ADDED Viewed

	@@ -0,0 +1,379 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+<title>Torrent2Space</title>
+<style>
+  *{box-sizing:border-box;margin:0;padding:0}
+  body{font-family:'Segoe UI',system-ui,sans-serif;background:#0f1117;color:#e2e8f0;min-height:100vh}
+  header{background:#1a1f2e;border-bottom:1px solid #2d3748;padding:16px 24px;display:flex;align-items:center;gap:12px}
+  header h1{font-size:1.3rem;font-weight:700;color:#7c3aed}
+  header span{font-size:.8rem;color:#64748b;background:#1e293b;padding:2px 8px;border-radius:999px}
+  .container{max-width:900px;margin:32px auto;padding:0 16px}
+  /* Add torrent card */
+  .card{background:#1a1f2e;border:1px solid #2d3748;border-radius:12px;padding:24px;margin-bottom:20px}
+  .card h2{font-size:.95rem;font-weight:600;color:#94a3b8;margin-bottom:16px;text-transform:uppercase;letter-spacing:.05em}
+  .input-row{display:flex;gap:8px}
+  .input-row input{flex:1;background:#0f1117;border:1px solid #374151;border-radius:8px;padding:10px 14px;color:#e2e8f0;font-size:.95rem;outline:none;transition:border .2s}
+  .input-row input:focus{border-color:#7c3aed}
+  .btn{padding:10px 20px;border:none;border-radius:8px;font-size:.9rem;font-weight:600;cursor:pointer;transition:all .2s}
+  .btn-primary{background:#7c3aed;color:#fff}
+  .btn-primary:hover{background:#6d28d9}
+  .btn-primary:disabled{background:#374151;color:#64748b;cursor:not-allowed}
+  .btn-danger{background:#dc2626;color:#fff}
+  .btn-danger:hover{background:#b91c1c}
+  .btn-sm{padding:6px 12px;font-size:.8rem}
+  .btn-ghost{background:transparent;border:1px solid #374151;color:#94a3b8}
+  .btn-ghost:hover{border-color:#7c3aed;color:#7c3aed}
+  .or-divider{text-align:center;color:#4b5563;font-size:.85rem;margin:12px 0;position:relative}
+  .or-divider::before,.or-divider::after{content:'';position:absolute;top:50%;width:45%;height:1px;background:#2d3748}
+  .or-divider::before{left:0}.or-divider::after{right:0}
+  .file-upload-area{border:2px dashed #374151;border-radius:8px;padding:20px;text-align:center;cursor:pointer;transition:all .2s;color:#64748b}
+  .file-upload-area:hover,.file-upload-area.drag{border-color:#7c3aed;color:#a78bfa}
+  .file-upload-area input{display:none}
+  /* File selector */
+  #file-list-section{display:none}
+  .torrent-info{display:flex;align-items:center;justify-content:space-between;margin-bottom:16px;flex-wrap:gap}
+  .torrent-name{font-weight:600;color:#e2e8f0;font-size:1rem}
+  .torrent-meta{font-size:.8rem;color:#64748b;margin-top:2px}
+  .file-table{width:100%;border-collapse:collapse}
+  .file-table th{text-align:left;font-size:.75rem;color:#64748b;font-weight:600;padding:8px 12px;text-transform:uppercase;letter-spacing:.05em;border-bottom:1px solid #2d3748}
+  .file-table td{padding:10px 12px;border-bottom:1px solid #1e293b;font-size:.875rem}
+  .file-table tr:last-child td{border-bottom:none}
+  .file-table tr:hover td{background:#1e293b}
+  .file-check{width:16px;height:16px;accent-color:#7c3aed;cursor:pointer}
+  .file-name{color:#cbd5e1}
+  .file-size{color:#64748b;text-align:right;white-space:nowrap}
+  .select-row{display:flex;gap:8px;margin-bottom:12px;align-items:center}
+  .select-row label{font-size:.8rem;color:#64748b}
+  /* Progress */
+  #progress-section{display:none}
+  .progress-wrap{background:#0f1117;border-radius:999px;height:8px;overflow:hidden;margin:12px 0}
+  .progress-bar{height:100%;background:linear-gradient(90deg,#7c3aed,#a855f7);border-radius:999px;transition:width .5s}
+  .progress-stats{display:flex;justify-content:space-between;font-size:.8rem;color:#64748b}
+  .status-badge{display:inline-flex;align-items:center;gap:6px;font-size:.8rem;font-weight:600;padding:4px 10px;border-radius:999px}
+  .badge-downloading{background:#1e3a5f;color:#60a5fa}
+  .badge-done{background:#14532d;color:#4ade80}
+  .badge-idle{background:#1e293b;color:#64748b}
+  .badge-processing{background:#3b1f5e;color:#c084fc}
+  .dot{width:6px;height:6px;border-radius:50%;background:currentColor;animation:pulse 1.2s infinite}
+  @keyframes pulse{0%,100%{opacity:1}50%{opacity:.3}}
+  .ctrl-row{display:flex;gap:8px;margin-top:12px}
+  /* My Files */
+  #my-files-section .empty-state{text-align:center;padding:40px;color:#4b5563}
+  .dl-table{width:100%;border-collapse:collapse}
+  .dl-table th{text-align:left;font-size:.75rem;color:#64748b;padding:8px 12px;text-transform:uppercase;letter-spacing:.05em;border-bottom:1px solid #2d3748}
+  .dl-table td{padding:10px 12px;border-bottom:1px solid #1e293b;font-size:.875rem;vertical-align:middle}
+  .dl-table tr:last-child td{border-bottom:none}
+  .dl-table tr:hover td{background:#1e293b}
+  .dl-filename{color:#cbd5e1;max-width:340px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+  .dl-size{color:#64748b;text-align:right}
+  .dl-actions{display:flex;gap:6px;justify-content:flex-end}
+  .refresh-btn{background:none;border:none;color:#64748b;cursor:pointer;font-size:1rem;padding:4px;transition:color .2s}
+  .refresh-btn:hover{color:#7c3aed}
+  .section-header{display:flex;align-items:center;justify-content:space-between;margin-bottom:16px}
+  .alert{padding:12px 16px;border-radius:8px;font-size:.875rem;margin-bottom:16px}
+  .alert-error{background:#450a0a;border:1px solid #dc2626;color:#fca5a5}
+  .alert-success{background:#052e16;border:1px solid #16a34a;color:#86efac}
+</style>
+</head>
+<body>
+<header>
+  <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="#7c3aed" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
+  <h1>Torrent2Space</h1>
+  <span>Seedr-style on HF Space</span>
+</header>
+<div class="container">
+  <!-- Add Torrent -->
+  <div class="card">
+    <h2>Add Torrent</h2>
+    <div id="alert-box"></div>
+    <div class="input-row">
+      <input id="magnet-input" type="text" placeholder="Paste magnet link (magnet:?xt=urn:btih:...)" />
+      <button class="btn btn-primary" onclick="loadMagnet()">Load</button>
+    </div>
+    <div class="or-divider">or</div>
+    <div class="file-upload-area" id="drop-zone" onclick="document.getElementById('torrent-file').click()"
+         ondragover="event.preventDefault();this.classList.add('drag')"
+         ondragleave="this.classList.remove('drag')"
+         ondrop="handleDrop(event)">
+      <input type="file" id="torrent-file" accept=".torrent" onchange="loadTorrentFile(this)"/>
+      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="margin-bottom:8px"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
+      <div>Drop .torrent file here or click to browse</div>
+    </div>
+  </div>
+  <!-- File selector -->
+  <div class="card" id="file-list-section">
+    <div class="torrent-info">
+      <div>
+        <div class="torrent-name" id="torrent-name"></div>
+        <div class="torrent-meta" id="torrent-meta"></div>
+      </div>
+    </div>
+    <div class="select-row">
+      <button class="btn btn-ghost btn-sm" onclick="selectAll(true)">Select All</button>
+      <button class="btn btn-ghost btn-sm" onclick="selectAll(false)">Deselect All</button>
+      <label id="selected-label"></label>
+    </div>
+    <table class="file-table">
+      <thead><tr><th style="width:30px"></th><th>Name</th><th style="text-align:right">Size</th></tr></thead>
+      <tbody id="file-tbody"></tbody>
+    </table>
+    <div style="margin-top:16px;display:flex;gap:8px">
+      <button class="btn btn-primary" id="start-btn" onclick="startDownload()">⬇ Start Download</button>
+      <button class="btn btn-ghost" onclick="resetUI()">Cancel</button>
+    </div>
+  </div>
+  <!-- Progress -->
+  <div class="card" id="progress-section">
+    <div class="section-header">
+      <h2>Download Progress</h2>
+      <span class="status-badge badge-idle" id="status-badge"><span class="dot"></span><span id="badge-text">Idle</span></span>
+    </div>
+    <div class="progress-wrap"><div class="progress-bar" id="progress-bar" style="width:0%"></div></div>
+    <div class="progress-stats">
+      <span id="stat-data">—</span>
+      <span id="stat-pct">0%</span>
+      <span id="stat-speed">—</span>
+      <span id="stat-eta">ETA: —</span>
+      <span id="stat-peers">—</span>
+    </div>
+    <div class="ctrl-row">
+      <button class="btn btn-ghost btn-sm" onclick="apiCall('/api/pause')">⏸ Pause</button>
+      <button class="btn btn-ghost btn-sm" onclick="apiCall('/api/resume')">▶ Resume</button>
+      <button class="btn btn-danger btn-sm" onclick="stopAndReset()">✕ Stop</button>
+    </div>
+  </div>
+  <!-- My Files -->
+  <div class="card" id="my-files-section">
+    <div class="section-header">
+      <h2>My Files</h2>
+      <button class="refresh-btn" onclick="loadFiles()" title="Refresh">↻</button>
+    </div>
+    <div id="files-container"><div class="empty-state">No files yet. Start a download above.</div></div>
+  </div>
+</div>
+<script>
+let pollTimer = null;
+let torrentFiles = [];
+// ─── Alert ──────────────────────────────────────────────────────────────────
+function showAlert(msg, type='error'){
+  const box = document.getElementById('alert-box');
+  box.innerHTML = `<div class="alert alert-${type}">${msg}</div>`;
+  setTimeout(()=>box.innerHTML='', 5000);
+}
+// ─── Load Magnet ─────────────────────────────────────────────────────────────
+async function loadMagnet(){
+  const magnet = document.getElementById('magnet-input').value.trim();
+  if(!magnet) return showAlert('Paste a magnet link first');
+  showAlert('Loading metadata… this may take a minute.','success');
+  const res = await fetch('/api/load_magnet',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({magnet})});
+  const data = await res.json();
+  if(data.error) return showAlert(data.error);
+  renderFileSelector(data);
+}
+// ─── Load .torrent ────────────────────────────────────────────────────────────
+async function loadTorrentFile(input){
+  const file = input.files[0];
+  if(!file) return;
+  const reader = new FileReader();
+  reader.onload = async e => {
+    const b64 = btoa(String.fromCharCode(...new Uint8Array(e.target.result)));
+    const res = await fetch('/api/load_torrent',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({data:b64})});
+    const data = await res.json();
+    if(data.error) return showAlert(data.error);
+    renderFileSelector(data);
+  };
+  reader.readAsArrayBuffer(file);
+}
+function handleDrop(e){
+  e.preventDefault();
+  document.getElementById('drop-zone').classList.remove('drag');
+  const file = e.dataTransfer.files[0];
+  if(file && file.name.endsWith('.torrent')){
+    const fakeInput = {files:[file]};
+    loadTorrentFile(fakeInput);
+  }
+}
+// ─── File Selector ────────────────────────────────────────────────────────────
+function renderFileSelector(data){
+  torrentFiles = data.files;
+  document.getElementById('torrent-name').textContent = data.name;
+  document.getElementById('torrent-meta').textContent = `${data.num_files} file(s) · ${data.total_size}`;
+  const tbody = document.getElementById('file-tbody');
+  tbody.innerHTML = '';
+  data.files.forEach(f=>{
+    const tr = document.createElement('tr');
+    tr.innerHTML = `
+      <td><input type="checkbox" class="file-check" checked data-idx="${f.index}" onchange="updateSelectedLabel()"/></td>
+      <td class="file-name">${f.name}</td>
+      <td class="file-size">${f.size}</td>
+    `;
+    tbody.appendChild(tr);
+  });
+  updateSelectedLabel();
+  document.getElementById('file-list-section').style.display='block';
+  document.getElementById('alert-box').innerHTML='';
+}
+function selectAll(v){
+  document.querySelectorAll('.file-check').forEach(c=>c.checked=v);
+  updateSelectedLabel();
+}
+function updateSelectedLabel(){
+  const checks = document.querySelectorAll('.file-check');
+  const sel = [...checks].filter(c=>c.checked).length;
+  document.getElementById('selected-label').textContent = `${sel} of ${checks.length} selected`;
+}
+// ─── Start Download ───────────────────────────────────────────────────────────
+async function startDownload(){
+  const selected = [...document.querySelectorAll('.file-check:checked')].map(c=>parseInt(c.dataset.idx));
+  if(!selected.length) return showAlert('Select at least one file');
+  const res = await fetch('/api/start',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({selected})});
+  const data = await res.json();
+  if(data.error) return showAlert(data.error);
+  document.getElementById('file-list-section').style.display='none';
+  document.getElementById('progress-section').style.display='block';
+  startPolling();
+}
+// ─── Status Polling ───────────────────────────────────────────────────────────
+function startPolling(){
+  if(pollTimer) clearInterval(pollTimer);
+  pollTimer = setInterval(pollStatus, 2000);
+  pollStatus();
+}
+async function pollStatus(){
+  try{
+    const res = await fetch('/api/status');
+    const d = await res.json();
+    updateProgress(d);
+    if(d.state==='done'){
+      clearInterval(pollTimer);
+      pollTimer=null;
+      loadFiles();
+    }
+  }catch(e){console.error(e)}
+}
+function updateProgress(d){
+  const pct = d.ovr_pct || d.cur_pct || 0;
+  document.getElementById('progress-bar').style.width = pct+'%';
+  document.getElementById('stat-pct').textContent = pct.toFixed(1)+'%';
+  document.getElementById('stat-data').textContent = d.data || '—';
+  document.getElementById('stat-speed').textContent = d.speed || '—';
+  document.getElementById('stat-eta').textContent = 'ETA: '+(d.eta||'—');
+  document.getElementById('stat-peers').textContent = d.peers || '—';
+  const badge = document.getElementById('status-badge');
+  const badgeText = document.getElementById('badge-text');
+  badge.className = 'status-badge ';
+  if(d.state==='downloading'){badge.className+='badge-downloading';badgeText.textContent=d.torrent_state||'Downloading';}
+  else if(d.state==='done'){badge.className+='badge-done';badgeText.textContent='Complete ✓';}
+  else if(d.state==='processing'){badge.className+='badge-processing';badgeText.textContent='Processing';}
+  else{badge.className+='badge-idle';badgeText.textContent='Idle';}
+  if(d.transfer_status) document.getElementById('stat-data').textContent = d.transfer_status;
+}
+// ─── My Files ─────────────────────────────────────────────────────────────────
+async function loadFiles(){
+  const res = await fetch('/api/files');
+  const data = await res.json();
+  const container = document.getElementById('files-container');
+  if(!data.files || data.files.length===0){
+    container.innerHTML='<div class="empty-state">No files yet. Start a download above.</div>';
+    return;
+  }
+  let html = `<div style="font-size:.8rem;color:#64748b;margin-bottom:12px">${data.count} file(s) · ${data.total_size}</div>`;
+  html += '<table class="dl-table"><thead><tr><th>Name</th><th style="text-align:right">Size</th><th></th></tr></thead><tbody>';
+  data.files.forEach(f=>{
+    const encoded = encodeURIComponent(f.path).replace(/%2F/g,'/');
+    html += `<tr>
+      <td><div class="dl-filename" title="${f.path}">${f.name}</div></td>
+      <td class="dl-size">${f.size}</td>
+      <td class="dl-actions">
+        <a href="/api/download/${encoded}" download="${f.name}" class="btn btn-primary btn-sm">⬇ Download</a>
+        <button class="btn btn-ghost btn-sm" onclick="deleteFile('${encoded}','${f.name}')">🗑</button>
+      </td>
+    </tr>`;
+  });
+  html += '</tbody></table>';
+  if(data.count>0){
+    html+=`<div style="margin-top:12px;text-align:right"><button class="btn btn-danger btn-sm" onclick="deleteAll()">Delete All Files</button></div>`;
+  }
+  container.innerHTML=html;
+}
+async function deleteFile(path, name){
+  if(!confirm(`Delete "${name}"?`)) return;
+  await fetch('/api/files/'+path,{method:'DELETE'});
+  loadFiles();
+}
+async function deleteAll(){
+  if(!confirm('Delete ALL downloaded files?')) return;
+  await fetch('/api/files',{method:'DELETE'});
+  loadFiles();
+}
+// ─── Control ──────────────────────────────────────────────────────────────────
+async function apiCall(endpoint){
+  await fetch(endpoint,{method:'POST',headers:{'Content-Type':'application/json'},body:'{}'});
+}
+async function stopAndReset(){
+  await apiCall('/api/stop');
+  clearInterval(pollTimer);
+  pollTimer=null;
+  resetUI();
+}
+function resetUI(){
+  document.getElementById('file-list-section').style.display='none';
+  document.getElementById('progress-section').style.display='none';
+  document.getElementById('magnet-input').value='';
+  document.getElementById('torrent-file').value='';
+}
+// ─── Init ─────────────────────────────────────────────────────────────────────
+loadFiles();
+// Resume polling if download was already running
+(async()=>{
+  const res = await fetch('/api/status');
+  const d = await res.json();
+  if(d.state==='downloading'){
+    document.getElementById('progress-section').style.display='block';
+    startPolling();
+  } else if(d.state==='done'){
+    loadFiles();
+  }
+})();
+</script>
+</body>
+</html>

torrent2drive/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ """Torrent2Space — Seedr-style torrent client on HF Space disk."""

torrent2drive/app.py ADDED Viewed

	@@ -0,0 +1,52 @@

+"""FastAPI application factory."""
+import os
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.sessions import SessionMiddleware
+from torrent2drive.config import STATIC_DIR
+from torrent2drive.routes import register_routes
+from torrent2drive.session import start_gc_loop
+def create_app() -> FastAPI:
+    application = FastAPI(title="Torrent2Space")
+    application.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    application.add_middleware(
+        SessionMiddleware,
+        secret_key=os.environ.get("SESSION_SECRET", "torrent2space-change-me"),
+        same_site="lax",
+    )
+    register_routes(application)
+    assets_dir = os.path.join(STATIC_DIR, "assets")
+    if os.path.isdir(assets_dir):
+        application.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+    if os.path.isdir(STATIC_DIR):
+        application.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+    return application
+app = create_app()
+start_gc_loop()
+def main():
+    uvicorn.run(
+        "torrent2drive.app:app",
+        host="0.0.0.0",
+        port=int(os.environ.get("PORT", "7860")),
+        reload=os.environ.get("T2D_RELOAD", "").lower() in ("1", "true", "yes"),
+    )
+if __name__ == "__main__":
+    main()

torrent2drive/config.py ADDED Viewed

	@@ -0,0 +1,34 @@

+"""Application paths."""
+import os
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+STATIC_DIR = os.path.join(BASE_DIR, "static")
+def _default_users_dir() -> str:
+    """Pick a writable session/temp root (HF Docker runs as non-root)."""
+    if os.environ.get("T2D_USERS_DIR"):
+        return os.path.abspath(os.environ["T2D_USERS_DIR"])
+    legacy = os.path.join(BASE_DIR, "_users")
+    try:
+        os.makedirs(legacy, exist_ok=True)
+        if os.access(legacy, os.W_OK):
+            return legacy
+    except OSError:
+        pass
+    home = os.environ.get("HOME") or os.path.expanduser("~")
+    if home:
+        path = os.path.join(home, ".torrent2drive", "users")
+        os.makedirs(path, exist_ok=True)
+        return path
+    os.makedirs(legacy, exist_ok=True)
+    return legacy
+BASE_TEMP = _default_users_dir()
+if not os.path.isdir(STATIC_DIR):
+    try:
+        os.makedirs(STATIC_DIR, exist_ok=True)
+    except OSError:
+        pass

torrent2drive/constants.py ADDED Viewed

	@@ -0,0 +1,14 @@

+"""Shared constants."""
+STATE_STR = [
+    "Queued (checking)",
+    "Checking Files",
+    "Downloading Metadata",
+    "Downloading",
+    "Finished",
+    "Seeding",
+    "Allocating",
+    "Checking Resume Data",
+]
+DEFAULT_ENC: dict = {}

torrent2drive/routes/__init__.py ADDED Viewed

	@@ -0,0 +1,15 @@

+"""Route registration."""
+from fastapi import FastAPI
+from torrent2drive.routes.torrent import router as torrent_router
+from torrent2drive.routes.control import router as control_router
+from torrent2drive.routes.files import router as files_router
+from torrent2drive.routes.pages import router as pages_router
+def register_routes(app: FastAPI):
+    app.include_router(torrent_router)
+    app.include_router(control_router)
+    app.include_router(files_router)
+    app.include_router(pages_router)

torrent2drive/routes/control.py ADDED Viewed

	@@ -0,0 +1,87 @@

+"""Status API."""
+import os
+from fastapi import APIRouter, Request
+from torrent2drive.constants import STATE_STR
+from torrent2drive.session import get_or_create_session
+from torrent2drive.utils import fmt_eta, fmt_size
+router = APIRouter(tags=["control"])
+@router.get("/api/status")
+async def api_status(request: Request):
+    us = get_or_create_session(request)
+    base = {
+        "state": "idle",
+        "phase": "idle",
+        "cur_pct": 0,
+        "ovr_pct": 0,
+        "data": "—",
+        "speed": "—",
+        "peers": "—",
+        "eta": "—",
+        "ff_running": us.ff_running,
+        "pipeline_cur": us.pipeline_current,
+        "pipeline_total": us.pipeline_total,
+        "transfer_status": us.transfer_status,
+        "pipeline_error": us.pipeline_error,
+        "is_completed": us.is_completed,
+        "files_ready": us.pipeline_done,
+    }
+    if us.is_completed:
+        base.update({
+            "state": "done",
+            "phase": "done",
+            "cur_pct": 100,
+            "ovr_pct": 100,
+        })
+        return base
+    if not us.handle or not us.handle.is_valid():
+        return base
+    try:
+        s = us.handle.status()
+        pct = s.progress * 100
+        dl = fmt_size(s.download_rate) + "/s"
+        dn = fmt_size(s.total_wanted_done)
+        tot = fmt_size(s.total_wanted)
+        eta = (
+            fmt_eta((s.total_wanted - s.total_wanted_done) / s.download_rate)
+            if s.download_rate > 0
+            else "—"
+        )
+        peers = f"{s.num_peers} ({s.num_seeds} seeds)"
+        if us.download_started and (s.is_finished or s.is_seeding) and not us.download_finished:
+            us.download_finished = True
+            # Trigger finalize in background
+            from torrent2drive.services.pipeline import finalize_in_background
+            finalize_in_background(us)
+        state_nm = (
+            STATE_STR[int(s.state)]
+            if int(s.state) < len(STATE_STR)
+            else "Downloading"
+        )
+        base.update({
+            "state": "downloading",
+            "phase": "torrent",
+            "cur_pct": pct,
+            "ovr_pct": pct,
+            "data": f"{dn} / {tot}",
+            "speed": dl,
+            "peers": peers,
+            "eta": eta,
+            "torrent_state": state_nm,
+        })
+        return base
+    except Exception as e:
+        print(f"[Status] {e}")
+        return base

torrent2drive/routes/files.py ADDED Viewed

	@@ -0,0 +1,99 @@

+"""File management API — list, download, and delete files on Space disk."""
+import os
+import mimetypes
+from fastapi import APIRouter, Request, HTTPException
+from fastapi.responses import FileResponse
+from torrent2drive.session import get_or_create_session
+from torrent2drive.utils import fmt_size
+router = APIRouter(tags=["files"])
+def _list_dir(path: str, base: str) -> list[dict]:
+    """Recursively list all files under path, relative to base."""
+    result = []
+    for root, dirs, files in os.walk(path):
+        dirs.sort()
+        for fname in sorted(files):
+            full = os.path.join(root, fname)
+            rel = os.path.relpath(full, base)
+            size = os.path.getsize(full)
+            result.append({
+                "name": fname,
+                "path": rel,
+                "size": fmt_size(size),
+                "size_bytes": size,
+            })
+    return result
+@router.get("/api/files")
+async def api_list_files(request: Request):
+    """List all downloaded files in the user's session directory."""
+    us = get_or_create_session(request)
+    files = _list_dir(us.dl_dir, us.dl_dir)
+    total_bytes = sum(f["size_bytes"] for f in files)
+    return {
+        "files": files,
+        "total_size": fmt_size(total_bytes),
+        "total_bytes": total_bytes,
+        "count": len(files),
+    }
+@router.get("/api/download/{file_path:path}")
+async def api_download_file(file_path: str, request: Request):
+    """Stream a file from the user's session directory."""
+    us = get_or_create_session(request)
+    # Security: resolve and ensure the path stays within dl_dir
+    target = os.path.realpath(os.path.join(us.dl_dir, file_path))
+    dl_dir_real = os.path.realpath(us.dl_dir)
+    if not target.startswith(dl_dir_real + os.sep) and target != dl_dir_real:
+        raise HTTPException(status_code=403, detail="Access denied")
+    if not os.path.isfile(target):
+        raise HTTPException(status_code=404, detail="File not found")
+    fname = os.path.basename(target)
+    mime, _ = mimetypes.guess_type(target)
+    mime = mime or "application/octet-stream"
+    return FileResponse(
+        path=target,
+        filename=fname,
+        media_type=mime,
+    )
+@router.delete("/api/files/{file_path:path}")
+async def api_delete_file(file_path: str, request: Request):
+    """Delete a specific downloaded file."""
+    us = get_or_create_session(request)
+    target = os.path.realpath(os.path.join(us.dl_dir, file_path))
+    dl_dir_real = os.path.realpath(us.dl_dir)
+    if not target.startswith(dl_dir_real + os.sep):
+        raise HTTPException(status_code=403, detail="Access denied")
+    if not os.path.isfile(target):
+        raise HTTPException(status_code=404, detail="File not found")
+    os.remove(target)
+    return {"ok": True, "deleted": file_path}
+@router.delete("/api/files")
+async def api_delete_all_files(request: Request):
+    """Delete all downloaded files for this session."""
+    import shutil
+    us = get_or_create_session(request)
+    shutil.rmtree(us.dl_dir, ignore_errors=True)
+    os.makedirs(us.dl_dir, exist_ok=True)
+    us.is_completed = False
+    us.transfer_status = ""
+    us.pipeline_done = []
+    return {"ok": True}

torrent2drive/routes/pages.py ADDED Viewed

	@@ -0,0 +1,17 @@

+"""HTML page routes."""
+import os
+from fastapi import APIRouter
+from fastapi.responses import FileResponse
+from torrent2drive.config import STATIC_DIR
+router = APIRouter(tags=["pages"])
+@router.get("/")
+async def index():
+    path = os.path.join(STATIC_DIR, "index.html")
+    if os.path.exists(path):
+        return FileResponse(path)
+    return FileResponse(os.path.join(STATIC_DIR, "index.html"))

torrent2drive/routes/torrent.py ADDED Viewed

	@@ -0,0 +1,115 @@

+"""Torrent load and control API."""
+import base64
+import threading
+from fastapi import APIRouter, Request
+from torrent2drive.session import get_or_create_session
+from torrent2drive.torrent_engine import load_torrent, remove_handle
+from torrent2drive.utils import fmt_size
+router = APIRouter(tags=["torrent"])
+@router.post("/api/load_magnet")
+async def api_load_magnet(body: dict, request: Request):
+    us = get_or_create_session(request)
+    files, err = load_torrent(us, magnet=body.get("magnet", ""))
+    if err:
+        return {"error": err}
+    return {
+        "name": us.ti.name(),
+        "total_size": fmt_size(us.ti.total_size()),
+        "num_files": us.ti.files().num_files(),
+        "files": files,
+    }
+@router.post("/api/load_torrent")
+async def api_load_torrent(body: dict, request: Request):
+    us = get_or_create_session(request)
+    try:
+        raw = base64.b64decode(body.get("data", ""))
+    except Exception:
+        return {"error": "Bad base64"}
+    files, err = load_torrent(us, torrent_bytes=raw)
+    if err:
+        return {"error": err}
+    return {
+        "name": us.ti.name(),
+        "total_size": fmt_size(us.ti.total_size()),
+        "num_files": us.ti.files().num_files(),
+        "files": files,
+    }
+@router.post("/api/start")
+async def api_start(body: dict, request: Request):
+    us = get_or_create_session(request)
+    if not us.ti:
+        return {"error": "No torrent loaded"}
+    if not us.handle or not us.handle.is_valid():
+        return {"error": "Invalid handle"}
+    selected = body.get("selected", [])
+    if not selected:
+        return {"error": "No files selected"}
+    us.stream_watch_only = False
+    us.stream_watch_active = False
+    us.stream_watch_index = -1
+    us.download_finished = False
+    us.selected_file_indices = [int(i) for i in selected]
+    pri = [0] * us.ti.files().num_files()
+    for idx in us.selected_file_indices:
+        pri[idx] = 4
+    us.handle.prioritize_files(pri)
+    us.handle.resume()
+    us.download_started = True
+    return {"ok": True, "count": len(us.selected_file_indices)}
+@router.post("/api/pause")
+async def api_pause(request: Request):
+    us = get_or_create_session(request)
+    try:
+        if us.handle and us.handle.is_valid():
+            us.handle.pause()
+    except Exception:
+        pass
+    return {"ok": True}
+@router.post("/api/resume")
+async def api_resume(request: Request):
+    us = get_or_create_session(request)
+    try:
+        if us.handle and us.handle.is_valid():
+            us.handle.resume()
+    except Exception:
+        pass
+    return {"ok": True}
+@router.post("/api/stop")
+async def api_stop(request: Request):
+    us = get_or_create_session(request)
+    us.download_started = False
+    us.download_finished = False
+    us.is_transferring = False
+    us.is_completed = False
+    us.ff_running = False
+    try:
+        remove_handle(us.handle)
+    except Exception:
+        pass
+    us.handle = None
+    us.ti = None
+    us.stream_watch_only = False
+    us.stream_watch_active = False
+    us.stream_watch_index = -1
+    return {"ok": True}

torrent2drive/services/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ # services package

torrent2drive/services/pipeline.py ADDED Viewed

	@@ -0,0 +1,83 @@

+"""Download pipeline: torrent → disk (Seedr-style, no cloud upload)."""
+import os
+import threading
+from torrent2drive.session import UserSession
+from torrent2drive.torrent_engine import remove_handle
+def reset_pipeline(us: UserSession):
+    us.pipeline_total = 0
+    us.pipeline_current = 0
+    us.pipeline_current_name = ""
+    us.pipeline_failed = []
+    us.pipeline_skipped = []
+    us.pipeline_done = []
+    us.pipeline_overall_pct = 0.0
+    us.pipeline_error = ""
+def finalize_download(us: UserSession):
+    """Called when torrent finishes downloading — mark complete, release handle."""
+    with us.lock:
+        if us.is_transferring:
+            return
+        us.is_transferring = True
+        us.is_completed = False
+        reset_pipeline(us)
+    try:
+        if not us.ti:
+            us.transfer_status = "No torrent info."
+            return
+        files = []
+        for idx in us.selected_file_indices:
+            p = os.path.join(us.dl_dir, us.ti.files().file_path(idx))
+            if os.path.exists(p):
+                files.append(p)
+        us.pipeline_total = len(files)
+        if us.pipeline_total == 0:
+            msg = "No files found on disk."
+            us.transfer_status = msg
+            us.pipeline_error = msg
+            return
+        # Release the torrent handle so libtorrent stops seeding
+        if us.handle:
+            try:
+                remove_handle(us.handle)
+            except Exception:
+                pass
+            us.handle = None
+        # Mark every file as done (they're already on disk)
+        for i, p in enumerate(files, 1):
+            us.pipeline_current = i
+            name = os.path.basename(p)
+            us.pipeline_current_name = name
+            us.pipeline_overall_pct = (i / us.pipeline_total) * 100
+            us.pipeline_done.append(name)
+            print(f"[Pipeline] ready on disk: {name}")
+        us.pipeline_overall_pct = 100.0
+        ok = len(us.pipeline_done)
+        us.transfer_status = f"Done — {ok} file(s) ready for download"
+        us.is_completed = True
+        print(f"[Pipeline] finished: {us.transfer_status}")
+    except Exception as e:
+        msg = f"Pipeline error: {e}"
+        us.transfer_status = msg
+        us.pipeline_error = msg
+        print(f"[Pipeline] {msg}")
+    finally:
+        us.ff_running = False
+        us.download_started = False
+        us.is_transferring = False
+def finalize_in_background(us: UserSession):
+    threading.Thread(target=finalize_download, args=(us,), daemon=True).start()

torrent2drive/session.py ADDED Viewed

	@@ -0,0 +1,128 @@

+"""Per-browser user sessions and idle cleanup."""
+import os
+import secrets
+import shutil
+import threading
+import time
+from fastapi import Request
+from torrent2drive.config import BASE_TEMP
+from torrent2drive.constants import DEFAULT_ENC
+class UserSession:
+    """Isolated state for a single browser session / user."""
+    def __init__(self, sid: str):
+        self.sid = sid
+        self.lock = threading.Lock()
+        self.last_seen = time.time()
+        self.dl_dir = os.path.join(BASE_TEMP, sid, "downloads")
+        os.makedirs(self.dl_dir, exist_ok=True)
+        self.handle = None
+        self.ti = None
+        self.selected_file_indices = []
+        self.download_started = False
+        self.download_finished = False
+        self.is_transferring = False
+        self.is_completed = False
+        self.transfer_status = ""
+        self.use_ffmpeg = False
+        self.ff_progress = 0.0
+        self.ff_eta = ""
+        self.ff_speed = ""
+        self.ff_size_done = ""
+        self.ff_file_label = ""
+        self.ff_running = False
+        self.ff_stage = ""
+        self.ff_duration_s = 0.0
+        self.ff_time_done_s = 0.0
+        self.pipeline_total = 0
+        self.pipeline_current = 0
+        self.pipeline_current_name = ""
+        self.pipeline_failed: list[str] = []
+        self.pipeline_skipped: list[str] = []
+        self.pipeline_done: list[str] = []
+        self.pipeline_overall_pct = 0.0
+        self.pipeline_error = ""
+        self.enc = dict(DEFAULT_ENC)
+        self.stream_watch_only = False
+        self.stream_watch_active = False
+        self.stream_watch_index = -1
+    def touch(self):
+        self.last_seen = time.time()
+_sessions: dict[str, UserSession] = {}
+_sessions_lock = threading.Lock()
+def get_or_create_session(request: Request) -> UserSession:
+    sid = request.session.get("sid")
+    if not sid:
+        sid = secrets.token_urlsafe(16)
+        request.session["sid"] = sid
+    with _sessions_lock:
+        us = _sessions.get(sid)
+        if us is None:
+            us = UserSession(sid)
+            _sessions[sid] = us
+    us.touch()
+    return us
+def get_session_by_sid(sid: str) -> UserSession | None:
+    with _sessions_lock:
+        return _sessions.get(sid)
+def _gc_sessions(idle_seconds=3600 * 6):
+    now = time.time()
+    drop = []
+    with _sessions_lock:
+        for sid, us in _sessions.items():
+            if (
+                us.is_transferring
+                or us.ff_running
+                or us.download_started
+                or us.stream_watch_active
+            ):
+                continue
+            if now - us.last_seen > idle_seconds:
+                drop.append(sid)
+    for sid in drop:
+        us = _sessions.pop(sid, None)
+        if not us:
+            continue
+        try:
+            from torrent2drive.torrent_engine import remove_handle
+            remove_handle(us.handle)
+        except Exception:
+            pass
+        try:
+            shutil.rmtree(os.path.join(BASE_TEMP, sid), ignore_errors=True)
+        except Exception:
+            pass
+def _gc_loop():
+    while True:
+        try:
+            _gc_sessions()
+        except Exception as e:
+            print(f"[GC] {e}")
+        time.sleep(900)
+def start_gc_loop():
+    threading.Thread(target=_gc_loop, daemon=True).start()

torrent2drive/torrent_engine.py ADDED Viewed

	@@ -0,0 +1,113 @@

+"""libtorrent wrapper — load magnets / .torrent files into a session."""
+import threading
+import time
+try:
+    import libtorrent as lt  # type: ignore
+    LT_AVAILABLE = True
+except ImportError:
+    lt = None
+    LT_AVAILABLE = False
+from torrent2drive.utils import fmt_size
+_lt_session = None
+_lt_lock = threading.Lock()
+def _get_lt_session():
+    global _lt_session
+    with _lt_lock:
+        if _lt_session is None:
+            if not LT_AVAILABLE:
+                raise RuntimeError("libtorrent is not installed")
+            settings = {
+                "enable_dht": True,
+                "enable_lsd": True,
+                "enable_upnp": True,
+                "enable_natpmp": True,
+            }
+            _lt_session = lt.session(settings)
+        return _lt_session
+def load_torrent(us, *, magnet: str = "", torrent_bytes: bytes = b""):
+    """Load a magnet link or .torrent bytes into the session.
+    Returns (files_list, error_string). On success error_string is "".
+    """
+    try:
+        sess = _get_lt_session()
+    except RuntimeError as e:
+        return [], str(e)
+    params = lt.add_torrent_params()
+    params.save_path = us.dl_dir
+    if magnet:
+        try:
+            params = lt.parse_magnet_uri(magnet)
+            params.save_path = us.dl_dir
+        except Exception as e:
+            return [], f"Bad magnet: {e}"
+    elif torrent_bytes:
+        try:
+            info = lt.torrent_info(lt.bdecode(torrent_bytes))
+            params.ti = info
+        except Exception as e:
+            return [], f"Bad torrent file: {e}"
+    else:
+        return [], "No magnet or torrent provided"
+    # Remove old handle if exists
+    if us.handle and us.handle.is_valid():
+        try:
+            sess.remove_torrent(us.handle)
+        except Exception:
+            pass
+    handle = sess.add_torrent(params)
+    # Wait for metadata (magnet links need DHT)
+    deadline = time.time() + 60
+    while not handle.has_metadata():
+        if time.time() > deadline:
+            sess.remove_torrent(handle)
+            return [], "Metadata timeout — check your magnet link or try again"
+        time.sleep(0.5)
+    ti = handle.get_torrent_info()
+    handle.pause()
+    # Disable all files by default
+    priorities = [0] * ti.files().num_files()
+    handle.prioritize_files(priorities)
+    us.handle = handle
+    us.ti = ti
+    us.download_started = False
+    us.download_finished = False
+    us.selected_file_indices = []
+    files = []
+    for i in range(ti.files().num_files()):
+        files.append({
+            "index": i,
+            "name": ti.files().file_path(i),
+            "size": fmt_size(ti.files().file_size(i)),
+            "size_bytes": ti.files().file_size(i),
+        })
+    return files, ""
+def remove_handle(handle):
+    if handle is None:
+        return
+    try:
+        sess = _get_lt_session()
+        if handle.is_valid():
+            sess.remove_torrent(handle)
+    except Exception:
+        pass

torrent2drive/utils.py ADDED Viewed

	@@ -0,0 +1,47 @@

+"""Shared utilities."""
+import os
+VIDEO_EXTENSIONS = {
+    ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm",
+    ".m4v", ".mpg", ".mpeg", ".ts", ".m2ts", ".3gp",
+}
+def fmt_size(n: int | float) -> str:
+    if n < 0:
+        return "—"
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"
+def fmt_eta(seconds: float) -> str:
+    if seconds <= 0 or seconds != seconds:
+        return "—"
+    seconds = int(seconds)
+    h, r = divmod(seconds, 3600)
+    m, s = divmod(r, 60)
+    if h:
+        return f"{h}h {m}m"
+    if m:
+        return f"{m}m {s}s"
+    return f"{s}s"
+def is_video(path: str) -> bool:
+    return os.path.splitext(path)[1].lower() in VIDEO_EXTENSIONS
+def find_first_video(directory: str) -> str:
+    for root, _, files in os.walk(directory):
+        for f in files:
+            if is_video(f):
+                return os.path.join(root, f)
+    return ""
+def ffmpeg_ok() -> bool:
+    import shutil
+    return shutil.which("ffmpeg") is not None