Upload 5 files

Dockerfile

@@ -0,0 +1,36 @@
+# Start with Python base image
+FROM python:3.9-slim
+
+# Install system dependencies as root
+USER root
+
+# Install required system packages
+RUN apt-get update && apt-get install -y \
+    libtorrent-rasterbar-dev \
+    build-essential \
+    libssl-dev \
+    libboost-system-dev \
+    libmagic1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /app
+
+# Install Python dependencies
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --user --upgrade -r requirements.txt
+
+# Copy application files
+COPY --chown=user . .
+
+# Add this after COPY . .
+RUN mkdir -p /app/static && chown user:user /app/static
+
+# Expose Hugging Face default port
+EXPOSE 7860
+
+# Start the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,10 @@
 ---
-title: Stream Yy
-emoji: 🦀
-colorFrom: yellow
-colorTo: indigo
+title: transfer-test
+emoji: ⚡
+colorFrom: purple
+colorTo: gray
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,165 @@
+
+import os
+import time
+import uuid
+import asyncio
+import libtorrent as lt
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+import magic
+from fastapi import Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from bs4 import BeautifulSoup
+import requests
+
+
+app = FastAPI()
+
+# Add to top of app.py
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory=".")
+
+active_sessions = {}
+
+# Add search endpoint
+@app.get("/search")
+async def search_torrents(q: str):
+    try:
+        url = f"https://torrentgalaxy.to/torrents.php?search={q}"
+        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
+        
+        response = requests.get(url, headers=headers)
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        torrents = []
+        for row in soup.select('div.tgxtablerow'):
+            try:
+                title = row.select_one('div:nth-child(4)').get_text(strip=True)
+                magnet = row.select_one('div:nth-child(5) a[href^="magnet:"]')['href']
+                size = row.select_one('div:nth-child(8)').get_text(strip=True)
+                seeds = row.select_one('div:nth-child(11) font').get_text(strip=True)
+                
+                torrents.append({
+                    'title': title,
+                    'magnet': magnet,
+                    'size': size,
+                    'seeds': seeds
+                })
+            except:
+                continue
+
+        return torrents[:10]  # Return top 10 results
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Add mime type endpoint
+@app.get("/stream/{torrent_id}/mime")
+async def get_mime_type(torrent_id: str):
+    if torrent_id not in active_sessions:
+        raise HTTPException(status_code=404, detail="Torrent session not found")
+    
+    file_path = active_sessions[torrent_id]["file_path"]
+    mime = magic.Magic(mime=True)
+    return {"mime_type": mime.from_file(file_path)}
+
+
+
+
+
+
+
+def get_largest_file(torrent_info):
+    files = torrent_info.files()
+    file_sizes = [(i, files.file_size(i)) for i in range(files.num_files())]
+    if not file_sizes:
+        return None
+    return max(file_sizes, key=lambda x: x[1])
+
+async def add_torrent(magnet_link: str, save_path: str):
+    ses = lt.session()
+    params = {
+        'save_path': save_path,
+        'storage_mode': lt.storage_mode_t(2),
+    }
+
+    handle = lt.add_magnet_uri(ses, magnet_link, params)
+    
+    # Wait for metadata
+    while not handle.has_metadata():
+        await asyncio.sleep(1)
+    
+    torrent_info = handle.get_torrent_info()
+    file_info = get_largest_file(torrent_info)
+    if not file_info:
+        raise Exception("No files found in torrent")
+    
+    file_index, _ = file_info
+    file_path = os.path.join(save_path, torrent_info.files().file_path(file_index))
+    
+    # Prioritize largest file
+    for i in range(torrent_info.num_files()):
+        handle.file_priority(i, 7 if i == file_index else 0)
+    
+    handle.set_sequential_download(True)
+    ses.resume()
+    
+    return {
+        "session": ses,
+        "handle": handle,
+        "file_path": file_path,
+        "downloading": True
+    }
+
+@app.post("/start_stream")
+async def start_stream(magnet_link: str):
+    torrent_id = str(uuid.uuid4())
+    save_path = f"./downloads/{torrent_id}"
+    os.makedirs(save_path, exist_ok=True)
+    
+    try:
+        session_info = await add_torrent(magnet_link, save_path)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    active_sessions[torrent_id] = session_info
+    return {"stream_url": f"/stream/{torrent_id}"}
+
+@app.get("/stream/{torrent_id}")
+async def stream_torrent(torrent_id: str):
+    if torrent_id not in active_sessions:
+        raise HTTPException(status_code=404, detail="Torrent session not found")
+    
+    session_info = active_sessions[torrent_id]
+    file_path = session_info["file_path"]
+    
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    mime = magic.Magic(mime=True)
+    mime_type = mime.from_file(file_path)
+    
+    def file_generator():
+        last_position = 0
+        while True:
+            if not os.path.exists(file_path):
+                time.sleep(1)
+                continue
+            
+            with open(file_path, "rb") as f:
+                f.seek(last_position)
+                data = f.read(1024 * 1024)  # 1MB chunks
+                if not data:
+                    if session_info["handle"].is_seed():
+                        break
+                    time.sleep(1)
+                    continue
+                last_position = f.tell()
+                yield data
+    
+    return StreamingResponse(file_generator(), media_type=mime_type)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+pillow
+python-multipart
+python-magic
+libtorrent
+beautifulsoup4
+requests
+jinja2

static/index.html

@@ -0,0 +1,75 @@
+<!-- index.html -->
+<!DOCTYPE html>
+<html>
+<head>
+    <title>TorrentGalaxy Streamer</title>
+    <style>
+        body { font-family: Arial, sans-serif; max-width: 1200px; margin: 0 auto; padding: 20px; }
+        .search-section, .player-section { margin-bottom: 30px; }
+        #results { margin-top: 20px; }
+        .torrent-item { padding: 10px; border-bottom: 1px solid #ddd; cursor: pointer; }
+        .torrent-item:hover { background: #f5f5f5; }
+        #player { width: 100%; height: 500px; }
+    </style>
+</head>
+<body>
+    <div class="search-section">
+        <h1>TorrentGalaxy Streamer</h1>
+        <input type="text" id="searchInput" placeholder="Search TorrentGalaxy...">
+        <button onclick="searchTorrents()">Search</button>
+        <div id="results"></div>
+    </div>
+
+    <div class="player-section">
+        <video id="player" controls></video>
+    </div>
+
+    <script>
+        async function searchTorrents() {
+            const query = document.getElementById('searchInput').value;
+            const results = document.getElementById('results');
+            results.innerHTML = 'Loading...';
+
+            try {
+                const response = await fetch(`/search?q=${encodeURIComponent(query)}`);
+                const torrents = await response.json();
+                
+                results.innerHTML = torrents.map(t => `
+                    <div class="torrent-item" onclick="startStream('${t.magnet}')">
+                        <strong>${t.title}</strong><br>
+                        <small>Size: ${t.size} | Seeds: ${t.seeds}</small>
+                    </div>
+                `).join('');
+            } catch (error) {
+                results.innerHTML = 'Error loading results';
+            }
+        }
+
+        async function startStream(magnet) {
+            try {
+                // Start the stream
+                const startResp = await fetch('/start_stream', {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify({ magnet_link: magnet })
+                });
+                
+                const { stream_url } = await startResp.json();
+                
+                // Get MIME type and set up player
+                const mimeResp = await fetch(`${stream_url}/mime`);
+                const { mime_type } = await mimeResp.json();
+                
+                // Set up video player
+                const player = document.getElementById('player');
+                player.src = stream_url;
+                player.type = mime_type;
+                player.load();
+                player.play();
+            } catch (error) {
+                alert('Error starting stream: ' + error.message);
+            }
+        }
+    </script>
+</body>
+</html>