fix

app.py

@@ -1,14 +1,9 @@
-from flask import Flask, jsonify, render_template, request, Response
+from flask import Flask, jsonify, render_template, request, Response, abort
 import os
-import json
-import re
 import urllib.parse
-from threading import Thread
-import uuid
-from video import ffmpeg_stream
-from indexer import indexer
+from hf_scrapper import download_and_cache_file, get_system_proxies
 from dotenv import load_dotenv
-from tvdb import fetch_and_cache_json
+import json
 
 load_dotenv()
 INDEX_FILE = os.getenv("INDEX_FILE")
@@ -16,50 +11,28 @@ TOKEN = os.getenv("TOKEN")
 REPO = os.getenv("REPO")
 CACHE_DIR = os.getenv("CACHE_DIR")
 
+# Ensure CACHE_DIR exists
 if not os.path.exists(CACHE_DIR):
     os.makedirs(CACHE_DIR)
 
-indexer()
-
 if not os.path.exists(INDEX_FILE):
     raise FileNotFoundError(f"{INDEX_FILE} not found. Please make sure the file exists.")
 
 with open(INDEX_FILE, 'r') as f:
     file_structure = json.load(f)
 
-def prefetch_metadata():
-    for item in file_structure:
-        if 'contents' in item:
-            for sub_item in item['contents']:
-                original_title = sub_item['path'].split('/')[-1]
-                media_type = 'series' if item['path'].startswith('tv') else 'movie'
-                title, year = extract_title_and_year(original_title)
-                
-                fetch_and_cache_json(original_title, title, media_type, year)
-
-def extract_title_and_year(original_title):
-    match = re.search(r'\((\d{4})\)', original_title)
-    if match:
-        year_str = match.group(1)
-        if year_str.isdigit() and len(year_str) == 4:
-            title = original_title[:match.start()].strip()
-            return title, int(year_str)
-    else:
-        parts = original_title.rsplit(' ', 1)
-        if len(parts) > 1 and parts[-1].isdigit() and len(parts[-1]) == 4:
-            return parts[0].strip(), int(parts[-1])
-    return original_title, None
+app = Flask(__name__)
 
 def get_film_file_path(title):
     decoded_title = urllib.parse.unquote(title)
     normalized_title = decoded_title.split(' (')[0].strip()
-    
+
     for item in file_structure:
         if item['path'].startswith('films'):
             for sub_item in item['contents']:
                 sub_item_title = sub_item['path'].split('/')[-1]
                 normalized_sub_item_title = sub_item_title.split(' (')[0].strip()
-                
+
                 if normalized_title == normalized_sub_item_title:
                     for file in sub_item['contents']:
                         if file['type'] == 'file':
@@ -85,47 +58,19 @@ def get_tv_show_seasons(title):
                     return seasons
     return []
 
-def start_prefetching():
-    prefetch_metadata()
-
-def generate(file_url):
-    # Generate a unique stream ID
-    stream_id = str(uuid.uuid4())
-    output_dir = os.path.join(CACHE_DIR, "stream", stream_id)
-    
-    # Ensure output directory exists
-    if not os.path.exists(output_dir):
-        os.makedirs(output_dir)
-
-    # Set up HLS streaming
-    token = TOKEN
-    output_path = ffmpeg_stream(file_url, token, output_dir=output_dir, stream_id=stream_id)
-    
-    if output_path:
-        return stream_id
-    return None
-
-thread = Thread(target=start_prefetching)
-thread.daemon = True
-thread.start()
-
-app = Flask(__name__)
+def download_film_if_needed(file_path):
+    cached_file_path = os.path.join(CACHE_DIR, file_path)
+    if not os.path.exists(cached_file_path):
+        file_url = f"https://huggingface.co/{REPO}/resolve/main/{file_path}"
+        success = download_and_cache_file(file_url, TOKEN, cached_file_path, proxies=get_system_proxies())
+        if not success:
+            abort(404, description="File not found or failed to download.")
+    return cached_file_path
 
 @app.route('/')
 def home():
     return render_template('index.html')
 
-@app.route('/tvshow_player')
-def tvshow_player():
-    return render_template('player.html')
-
-@app.route('/film_player')
-def film_player():
-    title = request.args.get('title')
-    if not title:
-        return "No film title provided", 400
-    return render_template('film_player.html', title=urllib.parse.unquote(title))
-
 @app.route('/films')
 def films():
     return render_template('films.html')
@@ -201,31 +146,32 @@ def get_metadata():
 def film_details(title):
     return render_template('film_details_page.html', title=title)
 
-@app.route('/api/stream')
-def stream_video():
-    file_path = request.args.get('path')
-    if not file_path:
-        return "File path not provided", 400
+@app.route('/film/<path:title>/play')
+def film_player(title):
+    title = urllib.parse.unquote(title)
+    film_file_path = get_film_file_path(title)
+    if not film_file_path:
+        return jsonify({'error': 'Film not found'}), 404
 
-    file_url = f"https://huggingface.co/{REPO}/resolve/main/{file_path}"
-    stream_id = generate(file_url)
+    cached_file_path = download_film_if_needed(film_file_path)
     
-    if stream_id:
-        return jsonify({'stream_id': stream_id})
+    return render_template('film_player.html', title=title)
+
+@app.route('/stream/<path:title>')
+def stream_film(title):
+    title = urllib.parse.unquote(title)
+    film_file_path = get_film_file_path(title)
+    if not film_file_path:
+        return jsonify({'error': 'Film not found'}), 404
+
+    cached_file_path = download_film_if_needed(film_file_path)
     
-    return "Streaming error", 500
-
-@app.route('/stream/<stream_id>')
-def stream_file(stream_id):
-    stream_dir = os.path.join(CACHE_DIR, "stream", stream_id)
-    playlist_path = os.path.join(stream_dir, 'output.m3u8')
-
-    if os.path.exists(playlist_path):
-        return Response(
-            open(playlist_path, 'rb').read(),
-            mimetype='application/vnd.apple.mpegurl'
-        )
-    return "Stream not found", 404
+    def generate():
+        with open(cached_file_path, 'rb') as f:
+            while chunk := f.read(8192):
+                yield chunk
+
+    return Response(generate(), mimetype='video/mp4')
 
 if __name__ == '__main__':
     app.run(debug=True, host="0.0.0.0", port=7860)

hf_scrapper.py

@@ -19,20 +19,23 @@ def get_system_proxies():
         return {}
 
 
-# def download_file(file_url, token, output_path, proxies):
-#     print(f"Downloading file from URL: {file_url} with proxies: {proxies}")
-#     try:
-#         response = requests.get(file_url, headers={'Authorization': f'Bearer {token}'}, proxies=proxies, stream=True)
-#         response.raise_for_status()
-#         with open(output_path, 'wb') as f:
-#             for chunk in response.iter_content(chunk_size=8192):
-#                 if chunk:
-#                     f.write(chunk)
-#         print(f'File {output_path} downloaded successfully.')
-#     except RequestException as e:
-#         print(f"Error downloading file: {e}")
-#     except IOError as e:
-#         print(f"Error writing file {output_path}: {e}")
+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}")
+    try:
+        response = requests.get(file_url, headers={'Authorization': f'Bearer {token}'}, proxies=proxies, stream=True)
+        response.raise_for_status()
+        os.makedirs(os.path.dirname(cache_path), exist_ok=True)
+        with open(cache_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+        print(f'File cached to {cache_path} successfully.')
+        return True
+    except RequestException as e:
+        print(f"Error downloading file: {e}")
+    except IOError as e:
+        print(f"Error writing file {cache_path}: {e}")
+    return False
 
 def get_file_structure(repo, token, path="", proxies=None):
     api_url = f"https://huggingface.co/api/models/{repo}/tree/main/{path}"
@@ -53,3 +56,11 @@ def write_file_structure_to_json(file_structure, file_path):
         print(f'File structure written to {file_path}')
     except IOError as e:
         print(f"Error writing file structure to JSON: {e}")
+
+
+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"
+    proxy=get_system_proxies()
+    download_and_cache_file(file_url, token, cache_path, proxies=proxy)

templates/film_details_page.html

@@ -172,7 +172,7 @@
             metadataContainer.appendChild(createMetadataElement('Release Date', metadata.first_air_time));
 
             const playButton = document.getElementById('play-button');
-            playButton.href = `/film_player?title=${encodeURIComponent(title)}`;
+ 
         }
 
         const urlParams = new URLSearchParams(window.location.search);

templates/film_player.html

@@ -9,82 +9,33 @@
             font-family: Arial, sans-serif;
             margin: 0;
             padding: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
             background-color: #f0f0f0;
         }
-        .container {
-            max-width: 800px;
-            margin: auto;
-            padding: 20px;
-            background-color: #fff;
-            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+        .video-container {
+            position: relative;
+            width: 80%;
+            max-width: 1200px;
+            background: #000;
             border-radius: 8px;
+            overflow: hidden;
         }
         video {
             width: 100%;
             height: auto;
-            border-radius: 8px;
-        }
-        .title {
-            font-size: 24px;
-            font-weight: bold;
-            margin-bottom: 20px;
-        }
-        .error {
-            color: red;
-            font-size: 18px;
-            margin-top: 20px;
+            display: block;
         }
     </style>
 </head>
 <body>
-    <div class="container">
-        <div class="title" id="filmTitle">Film Title</div>
-        <video id="videoPlayer" controls>
-            <source id="videoSource" type="application/vnd.apple.mpegurl">
+    <div class="video-container">
+        <video controls>
+            <source src="{{ url_for('stream_film', title=title) }}" type="video/mp4">
             Your browser does not support the video tag.
         </video>
-        <div id="error" class="error"></div>
     </div>
-
-    <script>
-        document.addEventListener("DOMContentLoaded", function() {
-            const queryParams = new URLSearchParams(window.location.search);
-            const filmTitle = queryParams.get('title');
-
-            if (!filmTitle) {
-                document.getElementById('error').innerText = 'No film title provided.';
-                return;
-            }
-
-            // Display the film title
-            document.getElementById('filmTitle').innerText = decodeURIComponent(filmTitle);
-
-            // Fetch film metadata and stream URL
-            fetch(`/api/film/${encodeURIComponent(filmTitle)}`)
-                .then(response => response.json())
-                .then(data => {
-                    if (data.file_path) {
-                        return fetch(`/api/stream?path=${encodeURIComponent(data.file_path)}`);
-                    } else {
-                        throw new Error('File path not found.');
-                    }
-                })
-                .then(response => response.json())
-                .then(data => {
-                    if (data.stream_id) {
-                        // Update video source with the stream URL
-                        const videoSource = document.getElementById('videoSource');
-                        videoSource.src = `/stream/${data.stream_id}`;
-                        console.log("streamID : "+data.stream_id)
-                        document.getElementById('videoPlayer').load();
-                    } else {
-                        throw new Error('Stream ID not found.');
-                    }
-                })
-                .catch(error => {
-                    document.getElementById('error').innerText = `Error: ${error.message}`;
-                });
-        });
-    </script>
 </body>
 </html>

video.py

@@ -7,7 +7,7 @@ logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %
 
 def ffmpeg_stream(file_url, token, output_dir="tmp/cache/stream", stream_id=None):
     # Generate a unique directory for the stream
-    stream_dir = os.path.join(output_dir, stream_id) if stream_id else os.path.join(output_dir, str(uuid.uuid4()))
+    stream_dir = os.path.join(output_dir, stream_id)
     
     if not os.path.exists(stream_dir):
         os.makedirs(stream_dir)