fix

.gitignore

@@ -3,4 +3,6 @@
 # cache
 tmp
 # pycache
-__pycache__
+__pycache__
+# stream-test.py
+stream-test.py

app.py

@@ -1,13 +1,15 @@
 from flask import Flask, jsonify, render_template, redirect, request, Response
 import os
 import json
+import re
 import requests
 import urllib.parse
 from datetime import datetime, timedelta
 from threading import Thread
-from hf_scrapper import get_system_proxies, stream_file
+from hf_scrapper import get_system_proxies, ffmpeg_stream
 from indexer import indexer
 from dotenv import load_dotenv
+import subprocess
 
 load_dotenv()
 INDEX_FILE = os.getenv("INDEX_FILE")
@@ -57,9 +59,9 @@ def get_thetvdb_token():
 
 def fetch_and_cache_json(original_title, title, media_type, year=None):
     if year:
-        search_url = f"{THETVDB_API_URL}/search?query={title}&type={media_type}&year={year}"
+        search_url = f"{THETVDB_API_URL}/search?query={urllib.parse.quote(title)}&type={media_type}&year={year}"
     else:
-        search_url = f"{THETVDB_API_URL}/search?query={title}&type={media_type}"
+        search_url = f"{THETVDB_API_URL}/search?query={urllib.parse.quote(title)}&type={media_type}"
     
     token = get_thetvdb_token()
     if not token:
@@ -93,19 +95,74 @@ def prefetch_metadata():
                 media_type = 'series' if item['path'].startswith('tv') else 'movie'
                 title = original_title
                 year = None
-                if any(char.isdigit() for char in original_title):
-                    # Strip year from title if present
-                    parts = original_title.rsplit(' ', 1)
-                    year_str = parts[-1]
+                
+                # Check if the title contains a year in parentheses
+                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 = parts[0]
+                        title = original_title[:match.start()].strip()
                         year = int(year_str)
+                else:
+                    # Check if the title contains a year at the end without parentheses
+                    parts = original_title.rsplit(' ', 1)
+                    if len(parts) > 1 and parts[-1].isdigit() and len(parts[-1]) == 4:
+                        title = parts[0].strip()
+                        year = int(parts[-1])
+                
                 fetch_and_cache_json(original_title, title, media_type, year)
 
+def get_film_file_path(title):
+    # URL-decode the title
+    decoded_title = urllib.parse.unquote(title)
+    # Normalize the title for comparison
+    normalized_title = decoded_title.split(' (')[0]
+    normalized_title = normalized_title.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]
+                # Normalize sub_item title
+                normalized_sub_item_title = sub_item_title.split(' (')[0]
+                normalized_sub_item_title = normalized_sub_item_title.strip()
+                
+                if normalized_title == normalized_sub_item_title:
+                    for file in sub_item['contents']:
+                        if file['type'] == 'file':
+                            return file['path']
+    return None
+
+def get_tv_show_seasons(title):
+    seasons = []
+    for item in file_structure:
+        if item['path'].startswith('tv'):
+            for sub_item in item['contents']:
+                if sub_item['type'] == 'directory' and title in sub_item['path']:
+                    for season in sub_item['contents']:
+                        if season['type'] == 'directory':
+                            episodes = []
+                            for episode in season['contents']:
+                                if episode['type'] == 'file':
+                                    episodes.append({
+                                        "title": episode['path'].split('/')[-1],
+                                        "path": episode['path']
+                                    })
+                            seasons.append({
+                                "season": season['path'].split('/')[-1],
+                                "episodes": episodes
+                            })
+                    return seasons
+    return []
+
 # Run prefetch_metadata in a background thread
 def start_prefetching():
     prefetch_metadata()
 
+def generate(file_url):
+    token = TOKEN = os.getenv("TOKEN")
+    output_stream = ffmpeg_stream(file_url, token)
+
 # Start prefetching before running the Flask app
 thread = Thread(target=start_prefetching)
 thread.daemon = True
@@ -131,10 +188,45 @@ def list_tv():
     tv_shows = [item for item in file_structure if item['path'].startswith('tv')]
     return jsonify([sub_item for show in tv_shows for sub_item in show['contents']])
 
-@app.route('/play/<path:file_path>')
-def play(file_path):
-    file_url = f"https://huggingface.co/{REPO}/resolve/main/{file_path}"
-    return redirect(file_url)
+@app.route('/film/<path:title>')
+def film_page(title):
+    title = urllib.parse.unquote(title)  # Decode the URL parameter
+    film_file_path = get_film_file_path(title)
+    if not film_file_path:
+        return jsonify({'error': 'Film not found'}), 404
+    
+    # Fetch cached metadata
+    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
+    if os.path.exists(json_cache_path):
+        with open(json_cache_path, 'r') as f:
+            metadata = json.load(f)
+    else:
+        return jsonify({'error': 'Metadata not found'}), 404
+    
+    return jsonify({
+        'metadata': metadata,
+        'file_path': film_file_path
+    })
+
+@app.route('/tv/<path:show_title>')
+def tv_page(show_title):
+    show_title = urllib.parse.unquote(show_title)  # Decode the URL parameter
+    seasons = get_tv_show_seasons(show_title)
+    if not seasons:
+        return jsonify({'error': 'TV show not found'}), 404
+    
+    # Fetch cached metadata
+    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(show_title)}.json")
+    if os.path.exists(json_cache_path):
+        with open(json_cache_path, 'r') as f:
+            metadata = json.load(f)
+    else:
+        return jsonify({'error': 'Metadata not found'}), 404
+    
+    return jsonify({
+        'metadata': metadata,
+        'seasons': seasons
+    })
 
 @app.route('/get_metadata')
 def get_metadata():
@@ -154,18 +246,14 @@ def get_metadata():
 
 @app.route('/stream')
 def stream_video():
+    # this route currently only stream the file from huggingface using ffmpy. can't play them in the web yet. need to implement later.
     file_path = request.args.get('path')
     if not file_path:
         return "File path not provided", 400
 
-    proxies = get_system_proxies()
     file_url = f"https://huggingface.co/{REPO}/resolve/main/{file_path}"
 
-    def generate():
-        for chunk in stream_file(file_url, TOKEN, proxies):
-            yield chunk
-
-    return Response(generate(), content_type='video/mp4')
+    return Response(generate(file_url), content_type='video/mp4')
 
 if __name__ == '__main__':
     app.run(debug=True, host="0.0.0.0", port=7860)

hf_scrapper.py

@@ -1,8 +1,10 @@
 import os
+import subprocess
 import requests
 import json
 import urllib.request
 from requests.exceptions import RequestException
+from ffmpy import FFmpeg
 
 def get_system_proxies():
     try:
@@ -10,38 +12,46 @@ def get_system_proxies():
         print("System proxies:", proxies)
         return {
             "http": proxies.get("http"),
-            "https": proxies.get("http")
+            "https": proxies.get("https")
         }
     except Exception as e:
         print(f"Error getting system proxies: {e}")
         return {}
 
-def stream_file(file_url, token, proxies):
-    print(f"Streaming file from URL: {file_url} with proxies: {proxies}")
+def ffmpeg_stream(file_url,token, output="tmp/cache/output.mp4"):
     try:
-        response = requests.get(file_url, headers={'Authorization': f'Bearer {token}'}, proxies=proxies, stream=True)
-        response.raise_for_status()
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                yield chunk
-    except RequestException as e:
-        print(f"Error streaming file: {e}")
-        yield b''  # Return empty bytes to indicate an error
+        # Set up the FFmpeg command with quality options
+        ff = FFmpeg(
+            inputs={
+                file_url: None
+            },
+            outputs={
+                f'{output}': '-c:v libx264 -crf 23 -preset medium -c:a aac -b:a 192k'
+            },
+            global_options= f'-headers "Authorization: Bearer {token}"'
+        )
+        
+        # Run the command
+        ff.run()
 
-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}")
+    except Exception as e:
+        print(f"Error using FFmpeg to stream file: {e}")
+        return None
+
+# 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 get_file_structure(repo, token, path="", proxies=None):
     api_url = f"https://huggingface.co/api/models/{repo}/tree/main/{path}"
@@ -62,3 +72,12 @@ 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}")
+
+# Example usage
+if __name__ == "__main__":
+    proxies = get_system_proxies()
+    token = 'hf token'
+    file_url = 'file url'
+    
+    # Stream the video
+    output_stream = ffmpeg_stream(file_url, token, output="tmp/cache/video.mp4")

requirements.txt

@@ -1,4 +1,5 @@
 flask
 Flask-Cors
 requests
-python-dotenv
+python-dotenv
+ffmpy

templates/index.html

@@ -39,6 +39,7 @@
             overflow: hidden;
             text-align: center;
             transition: transform 0.2s;
+            cursor: pointer;
         }
         .card:hover {
             transform: scale(1.05);
@@ -57,17 +58,6 @@
             margin: 0;
             padding: 10px;
         }
-        .card a {
-            display: block;
-            padding: 10px;
-            color: #fff;
-            background-color: #e50914;
-            text-decoration: none;
-            border-radius: 0 0 10px 10px;
-        }
-        .card a:hover {
-            background-color: #f40612;
-        }
     </style>
 </head>
 <body>
@@ -119,8 +109,15 @@
             card.innerHTML = `
                 <img src="https://via.placeholder.com/340x500.png" alt="${title}">
                 <h3>${title}</h3>
-                <a href="/player?path=${encodeURIComponent(item.path)}&type=${mediaType}">Play</a>
             `;
+            // Redirect to the appropriate page on card click
+            card.onclick = () => {
+                if (mediaType === 'movie') {
+                    window.location.href = `/film/${encodeURIComponent(title)}`;
+                } else if (mediaType === 'series') {
+                    window.location.href = `/tv/${encodeURIComponent(title)}`;
+                }
+            };
             fetchMetadata(title).then(thumbnailUrl => {
                 if (thumbnailUrl !== null) {
                     card.querySelector('img').src = thumbnailUrl;

templates/player.html

@@ -9,69 +9,42 @@
             color: #fff;
             margin: 0;
             padding: 0;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            height: 100vh;
+        }
+        .header {
+            background-color: #000;
+            padding: 20px;
+            text-align: center;
+        }
+        .header h1 {
+            margin: 0;
+            font-size: 24px;
+        }
+        .content {
+            padding: 20px;
         }
         .player-container {
+            max-width: 100%;
+            margin: auto;
             text-align: center;
         }
         video {
-            width: 80%;
+            width: 100%;
             height: auto;
-            margin-top: 20px;
+            background-color: #333;
         }
     </style>
 </head>
 <body>
-    <div class="player-container">
-        <h1 id="title"></h1>
-        <video id="videoPlayer" controls></video>
+    <div class="header">
+        <h1>Media Player</h1>
+    </div>
+    <div class="content">
+        <div class="player-container">
+            <video id="videoPlayer" controls>
+                <source id="videoSource" type="video/mp4">
+                Your browser does not support the video tag.
+            </video>
+        </div>
     </div>
-    <script>
-        function getQueryParams() {
-            const params = {};
-            window.location.search.substring(1).split("&").forEach(pair => {
-                const [key, value] = pair.split("=");
-                params[decodeURIComponent(key)] = decodeURIComponent(value);
-            });
-            return params;
-        }
-
-        async function fetchMetadata(title) {
-            try {
-                const response = await fetch(`/get_metadata?title=${encodeURIComponent(title)}`);
-                if (response.ok) {
-                    return await response.json();
-                }
-            } catch (error) {
-                console.error('Metadata fetch error:', error);
-            }
-            return null;
-        }
-
-        async function initializePlayer() {
-            const params = getQueryParams();
-            const { path, type } = params;
-            const title = path.split('/').pop();
-
-            document.getElementById('title').textContent = title;
-
-            const metadata = await fetchMetadata(title);
-            if (metadata && metadata.data && metadata.data.length > 0) {
-                console.log(`Loaded metadata for ${title}:`, metadata);
-            } else {
-                console.log(`No metadata found for ${title}`);
-            }
-
-            const videoPlayer = document.getElementById('videoPlayer');
-            const videoUrl = `https://huggingface.co/${REPO}/resolve/main/${path}`;
-            videoPlayer.src = videoUrl;
-            console.log(`Playing video from URL: ${videoUrl}`);
-        }
-
-        initializePlayer();
-    </script>
 </body>
 </html>