update

app.py

@@ -1,4 +1,4 @@
-from flask import Flask, jsonify, render_template, request, Response, abort
+from flask import Flask, jsonify, render_template, request, Response, abort, send_from_directory
 import os
 import urllib.parse
 from hf_scrapper import download_and_cache_file, get_system_proxies
@@ -8,6 +8,7 @@ from dotenv import load_dotenv
 import json
 import re
 from threading import Thread
+from flask_socketio import SocketIO, emit
 
 load_dotenv()
 INDEX_FILE = os.getenv("INDEX_FILE")
@@ -58,6 +59,7 @@ thread.daemon = True
 thread.start()
 
 app = Flask(__name__)
+socketio = SocketIO(app)
 
 def get_film_file_path(title):
     decoded_title = urllib.parse.unquote(title)
@@ -219,41 +221,35 @@ def film_player(title):
 
 @app.route('/cached_films/<path:title>')
 def serve_cached_film(title):
-    # Decode the title and construct the path
-    folder_path = os.path.join(CACHE_DIR, urllib.parse.unquote(title))
-    
-    # Check if the folder exists
-    if not os.path.isdir(folder_path):
-        return jsonify({'error': 'Film folder not found'}), 404
-
-    # Get the list of files in the folder
-    files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
-
-    # If no files found, return error
-    if not files:
-        return jsonify({'error': 'No film files found in the folder'}), 404
+    title = urllib.parse.unquote(title)
+    cached_file_path = get_film_file_path(title)
+    if not cached_file_path:
+        return jsonify({'error': 'Film not found'}), 404
 
-    # Assuming there's only one file, get its path
-    file_path = os.path.join(folder_path, files[0])
-    print("fills :"+files)
-    print("file path : "+ file_path)
-    # Determine the MIME type based on the file extension
-    mime_type = 'video/mp4'
-    if file_path.lower().endswith('.mkv'):
-        mime_type = 'video/x-matroska'
-    elif file_path.lower().endswith('.avi'):
-        mime_type = 'video/x-msvideo'
-    elif file_path.lower().endswith('.webm'):
-        mime_type = 'video/webm'
-    elif file_path.lower().endswith('.ts'):
-        mime_type = 'video/mp2t'
+    return send_from_directory(os.path.dirname(cached_file_path), os.path.basename(cached_file_path))
 
-    def generate():
-        with open(file_path, 'rb') as f:
-            while chunk := f.read(8192):
-                yield chunk
+@socketio.on('download')
+def handle_download(data):
+    title = data.get('title')
+    film_file_path = get_film_file_path(title)
+    if not film_file_path:
+        emit('download_progress', {'error': 'Film not found'})
+        return
+    
+    cached_file_path = os.path.join(CACHE_DIR, film_file_path)
+    if os.path.exists(cached_file_path):
+        emit('download_progress', {'progress': 100, 'status': 'already cached'})
+        return
 
-    return Response(generate(), mimetype=mime_type)
+    file_url = f"https://huggingface.co/{REPO}/resolve/main/{film_file_path}"
+    def download_callback(progress):
+        socketio.emit('download_progress', {'progress': progress})
+    
+    success = download_and_cache_file(file_url, TOKEN, cached_file_path, proxies=get_system_proxies(), callback=download_callback)
+    if not success:
+        emit('download_progress', {'error': 'Failed to download film'})
+    else:
+        emit('download_progress', {'progress': 100, 'status': 'completed'})
 
 if __name__ == '__main__':
-    app.run(debug=True, host="0.0.0.0", port=7860)
+    socketio.run(app, host='0.0.0.0', port=5000)

hf_scrapper.py

@@ -4,6 +4,11 @@ import json
 import urllib.request
 from requests.exceptions import RequestException
 from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+CACHE_DIR = os.getenv("CACHE_DIR")
+CACHE_JSON_PATH = os.path.join(CACHE_DIR, "cached_films.json")
+MAX_WORKERS = 4  # Adjust the number of threads for concurrent downloads
 
 def get_system_proxies():
     try:
@@ -17,23 +22,35 @@ def get_system_proxies():
         print(f"Error getting system proxies: {e}")
         return {}
 
+def download_file_chunk(url, headers, proxies, start, end):
+    headers['Range'] = f"bytes={start}-{end}"
+    response = requests.get(url, headers=headers, proxies=proxies, stream=True)
+    response.raise_for_status()
+    return response.content
+
 def download_and_cache_file(file_url, token, cache_path, proxies=None):
     print(f"Downloading file from URL: {file_url} to {cache_path} with proxies: {proxies}")
+    headers = {'Authorization': f'Bearer {token}'}
     try:
-        response = requests.get(file_url, headers={'Authorization': f'Bearer {token}'}, proxies=proxies, stream=True)
+        response = requests.head(file_url, headers=headers, proxies=proxies)
         response.raise_for_status()
 
-        # Get the total file size from the headers
         total_size = int(response.headers.get('content-length', 0))
-        
         os.makedirs(os.path.dirname(cache_path), exist_ok=True)
-        with open(cache_path, 'wb') as f:
-            # Use tqdm to show download progress
-            for chunk in tqdm(response.iter_content(chunk_size=8192), total=total_size//8192, unit='KB', unit_scale=True, unit_divisor=1024):
-                if chunk:
+
+        chunk_size = total_size // MAX_WORKERS
+        ranges = [(i, min(i + chunk_size, total_size) - 1) for i in range(0, total_size, chunk_size)]
+
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+            futures = [executor.submit(download_file_chunk, file_url, headers, proxies, start, end) for start, end in ranges]
+            with open(cache_path, 'wb') as f, tqdm(total=total_size, unit='B', unit_scale=True, desc=cache_path) as pbar:
+                for future in as_completed(futures):
+                    chunk = future.result()
                     f.write(chunk)
+                    pbar.update(len(chunk))
 
         print(f'File cached to {cache_path} successfully.')
+        update_cache_json(file_url, cache_path)
         return True
     except RequestException as e:
         print(f"Error downloading file: {e}")
@@ -41,6 +58,20 @@ def download_and_cache_file(file_url, token, cache_path, proxies=None):
         print(f"Error writing file {cache_path}: {e}")
     return False
 
+def update_cache_json(file_url, cache_path):
+    cache_data = {}
+    if os.path.exists(CACHE_JSON_PATH):
+        with open(CACHE_JSON_PATH, 'r') as json_file:
+            cache_data = json.load(json_file)
+
+    film_title = os.path.basename(cache_path)
+    cache_data[film_title] = cache_path
+
+    with open(CACHE_JSON_PATH, 'w') as json_file:
+        json.dump(cache_data, json_file, indent=2)
+
+    print(f'Updated cache JSON: {CACHE_JSON_PATH} with {film_title}: {cache_path}')
+
 def get_file_structure(repo, token, path="", proxies=None):
     api_url = f"https://huggingface.co/api/models/{repo}/tree/main/{path}"
     headers = {'Authorization': f'Bearer {token}'}
@@ -64,6 +95,6 @@ def write_file_structure_to_json(file_structure, file_path):
 if __name__ == "__main__":
     file_url = "https://huggingface.co/Unicone-Studio/jellyfin_media/resolve/main/films/Funky%20Monkey%202004/Funky%20Monkey%20(2004)%20Web-dl%201080p.mp4"
     token = os.getenv("TOKEN")
-    cache_path = "tmp/cache/films/Funky%20Monkey%202004/Funky%20Monkey%20(2004)%20Web-dl%201080p.mp4"
+    cache_path = os.path.join(CACHE_DIR, "films/Funky Monkey 2004/Funky Monkey (2004) Web-dl 1080p.mp4")
     proxy = get_system_proxies()
     download_and_cache_file(file_url, token, cache_path, proxies=proxy)

requirements.txt

@@ -4,4 +4,5 @@ requests
 python-dotenv
 ffmpy
 ffmpeg-python
-tqdm
+tqdm
+Flask-SocketIO

templates/film_details_page.html

@@ -4,6 +4,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Film Details</title>
+    <script src="https://cdn.jsdelivr.net/npm/socket.io@4.0.0/dist/socket.io.min.js"></script>
     <style>
         body {
             font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
@@ -123,6 +124,7 @@
             <div class="genres" id="film-genres"></div>
             <div class="metadata-container" id="film-metadata"></div>
             <a href="#" class="play-button" id="play-button" onclick="playFilm()">Play</a>
+            <p id="progress" style="margin-top: 20px; text-align: center;"></p>
         </div>
     </div>
     <script>
@@ -170,24 +172,27 @@
             metadataContainer.appendChild(createMetadataElement('Director', metadata.director));
             metadataContainer.appendChild(createMetadataElement('Country', metadata.country));
             metadataContainer.appendChild(createMetadataElement('Release Date', metadata.first_air_time));
-
-            const playButton = document.getElementById('play-button');
-            playButton.href = `#`; // Will be handled by JavaScript
         }
 
-        async function playFilm() {
+        function playFilm() {
             const title = "{{ title }}";
-            try {
-                const response = await fetch(`/api/cache_film/${encodeURIComponent(title)}`);
-                const data = await response.json();
-                if (data.success) {
-                    window.location.href = `/film_player/${encodeURIComponent(title)}`;
+            const socket = io();
+            const progressElement = document.getElementById('progress');
+            
+            socket.emit('download', { title: title });
+
+            socket.on('download_progress', function(data) {
+                if (data.error) {
+                    progressElement.textContent = 'Error: ' + data.error;
+                } else if (data.status) {
+                    progressElement.textContent = 'Status: ' + data.status;
                 } else {
-                    alert('Error caching film: ' + data.error);
+                    progressElement.textContent = 'Progress: ' + data.progress + '%';
+                    if (data.progress === 100) {
+                        window.location.href = `/cached_films/${encodeURIComponent(title)}`;
+                    }
                 }
-            } catch (error) {
-                alert('Error: ' + error.message);
-            }
+            });
         }
 
         const urlParams = new URLSearchParams(window.location.search);