Spaces:

erfyhersr
/

nothing

Paused

App Files Files Community

erfyhersr commited on Feb 25, 2025

Commit

aafa08b

verified ·

1 Parent(s): e0e8ea0

Update app.py

Browse files

Files changed (1) hide show

app.py +115 -110

app.py CHANGED Viewed

@@ -1,112 +1,117 @@
-import os
-import uuid
-import threading
-from flask import Flask, send_from_directory, render_template_string
 import streamlit as st
-from pyngrok import ngrok
-# Hardcode your ngrok token here
-ngrok.set_auth_token("2t7Jj4yyE3WswdAoz23Rkki03l0_53iu3por9LUB5uFPWYRFy")
-# Directory to store videos
-VIDEO_DIR = "videos"
-if not os.path.exists(VIDEO_DIR):
-    os.makedirs(VIDEO_DIR)
-# Create a Flask app to serve videos and an embed page
-app = Flask(__name__)
-@app.route('/video/<video_id>')
-def serve_video(video_id):
-    """Serves the video file based on the unique video_id."""
-    for filename in os.listdir(VIDEO_DIR):
-        if filename.startswith(video_id):
-            return send_from_directory(VIDEO_DIR, filename)
-    return "Video not found", 404
-@app.route('/embed/<video_id>')
-def embed_video(video_id):
-    """Returns a custom HTML page with a video player streaming the video."""
-    video_file = None
-    for filename in os.listdir(VIDEO_DIR):
-        if filename.startswith(video_id):
-            video_file = filename
-            break
-    if not video_file:
-        return "Video not found", 404
-    # The video source URL points to the /video/<video_id> route.
-    video_url = f"/video/{video_id}"
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-      <title>Custom Video Player</title>
-      <style>
-        body {{
-          margin: 0;
-          background-color: #000;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          height: 100vh;
-        }}
-        video {{
-          width: 80%;
-          max-width: 800px;
-          height: auto;
-          outline: none;
-        }}
-      </style>
-    </head>
-    <body>
-      <video controls autoplay>
-        <source src="{video_url}" type="video/mp4">
-        Your browser does not support the video tag.
-      </video>
-    </body>
-    </html>
     """
-    return render_template_string(html)
-def run_flask():
-    # Bind to 0.0.0.0 to allow external connections and run on port 8000
-    app.run(host="0.0.0.0", port=8000)
-# Start the Flask server in a background thread (only once).
-if "FLASK_STARTED" not in st.session_state:
-    st.session_state.FLASK_STARTED = True
-    threading.Thread(target=run_flask, daemon=True).start()
-# Setup ngrok to expose port 8000 publicly (only once).
-if "NGROK_URL" not in st.session_state:
-    public_url = ngrok.connect(8000, bind_tls=True)
-    st.session_state.NGROK_URL = public_url.public_url
-st.title("Cloud Video Hosting and Streaming")
-uploaded_file = st.file_uploader("Upload a video", type=["mp4", "mov", "avi", "mkv"])
-if uploaded_file is not None:
-    # Save the uploaded video using a unique id
-    video_id = str(uuid.uuid4())
-    ext = uploaded_file.name.split('.')[-1]
-    filename = f"{video_id}.{ext}"
-    filepath = os.path.join(VIDEO_DIR, filename)
-    with open(filepath, "wb") as f:
-        f.write(uploaded_file.getbuffer())
-    st.success("Video uploaded successfully!")
-    # Generate a public embed link using the ngrok public URL
-    public_url = st.session_state.NGROK_URL
-    embed_link = f"{public_url}/embed/{video_id}"
-    st.write("Your embed link:")
-    st.code(embed_link)
-    st.markdown(f"[Open Video]({embed_link})")
-# Optional: List available videos with their public embed links
-st.subheader("Available Videos")
-for fname in os.listdir(VIDEO_DIR):
-    vid_id = fname.split('.')[0]
-    public_url = st.session_state.NGROK_URL
-    embed_link = f"{public_url}/embed/{vid_id}"
-    st.markdown(f"- [Video {vid_id}]({embed_link})")

 import streamlit as st
+import ftplib
+import libtorrent as lt
+import time
+import os
+def ftp_upload_file(ftp, local_path, remote_path):
+    """
+    Upload a file to the FTP server showing a progress bar.
+    """
+    file_size = os.path.getsize(local_path)
+    uploaded_bytes = 0
+    progress_bar = st.progress(0)
+    # Callback for storbinary that is called after each block is sent.
+    def handle_block(block):
+        nonlocal uploaded_bytes
+        uploaded_bytes += len(block)
+        progress = int((uploaded_bytes / file_size) * 100)
+        progress_bar.progress(progress)
+    with open(local_path, 'rb') as f:
+        ftp.storbinary(f"STOR {remote_path}", f, blocksize=1024, callback=handle_block)
+def download_torrent(magnet_link, download_folder):
     """
+    Download a torrent from a magnet link using libtorrent.
+    Shows a progress bar and status updates.
+    """
+    st.write("Starting torrent session...")
+    ses = lt.session()
+    ses.listen_on(6881, 6891)
+    params = {
+        'save_path': download_folder,
+        'storage_mode': lt.storage_mode_t(2),
+    }
+    # Add the magnet link
+    handle = lt.add_magnet_uri(ses, magnet_link, params)
+    st.write("Fetching metadata...")
+    # Wait until metadata is received.
+    while not handle.has_metadata():
+        st.write("Waiting for metadata...")
+        time.sleep(1)
+    st.write("Metadata received. Starting download...")
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    # Loop until the torrent is complete (i.e. seeding)
+    while True:
+        s = handle.status()
+        progress = s.progress * 100
+        progress_bar.progress(int(progress))
+        status_text.text(
+            f"State: {s.state}, Progress: {progress:.2f}% | "
+            f"Down: {s.download_rate/1000:.2f} kB/s | "
+            f"Up: {s.upload_rate/1000:.2f} kB/s | "
+            f"Peers: {s.num_peers}"
+        )
+        if s.is_seeding:
+            break
+        time.sleep(1)
+    st.success("Torrent download complete!")
+    return download_folder
+def main():
+    st.title("Magnet Link to FTP Downloader")
+    st.header("FTP Connection Details")
+    ftp_host = st.text_input("FTP Host", "ftp.example.com")
+    ftp_port = st.number_input("FTP Port", value=21, step=1)
+    ftp_username = st.text_input("FTP Username")
+    ftp_password = st.text_input("FTP Password", type="password")
+    st.header("Torrent Details")
+    magnet_link = st.text_area("Magnet Link", placeholder="magnet:?xt=urn:btih:...")
+    download_folder = st.text_input("Download Folder", "./downloads")
+    if st.button("Start Download & Upload"):
+        # --- Verify FTP connection ---
+        st.write("Verifying FTP connection...")
+        try:
+            ftp = ftplib.FTP()
+            ftp.connect(ftp_host, ftp_port, timeout=10)
+            ftp.login(ftp_username, ftp_password)
+            st.success("FTP connection successful!")
+        except Exception as e:
+            st.error(f"FTP connection failed: {e}")
+            return
+        # Create download folder if it doesn't exist.
+        if not os.path.exists(download_folder):
+            os.makedirs(download_folder)
+        # --- Start torrent download ---
+        downloaded_folder = download_torrent(magnet_link, download_folder)
+        # --- Upload downloaded files to FTP ---
+        st.write("Uploading downloaded files to FTP...")
+        for root, dirs, files in os.walk(downloaded_folder):
+            for file in files:
+                local_file = os.path.join(root, file)
+                remote_file = file  # You can adjust the remote path as needed
+                st.write(f"Uploading {file}...")
+                try:
+                    ftp_upload_file(ftp, local_file, remote_file)
+                    st.success(f"Uploaded {file} successfully!")
+                except Exception as e:
+                    st.error(f"Failed to upload {file}: {e}")
+        ftp.quit()
+        st.success("All files uploaded. FTP connection closed.")
+if __name__ == '__main__':
+    main()