init player

app.py

@@ -1,11 +1,11 @@
-from flask import Flask, jsonify, render_template, redirect, request, send_file
+from flask import Flask, jsonify, render_template, redirect, request, Response
 import os
 import json
 import requests
 import urllib.parse
 from datetime import datetime, timedelta
 from threading import Thread
-from hf_scraper import get_system_proxies
+from hf_scrapper import get_system_proxies, stream_file
 from indexer import indexer
 from dotenv import load_dotenv
 
@@ -55,7 +55,7 @@ def get_thetvdb_token():
         authenticate_thetvdb()
     return THETVDB_TOKEN
 
-def fetch_and_cache_image(title, media_type, year=None):
+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}"
     else:
@@ -77,38 +77,34 @@ def fetch_and_cache_image(title, media_type, year=None):
         data = response.json()
         
         if 'data' in data and data['data']:
-            img_url = data['data'][0].get('thumbnail')
-            if img_url:
-                img_content = requests.get(img_url, proxies=proxies).content
-                cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.jpg")
-                with open(cache_path, 'wb') as f:
-                    f.write(img_content)
-                # Save JSON response to cache
-                json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
-                with open(json_cache_path, 'w') as f:
-                    json.dump(data, f)
+            # Use original_title to save JSON response to cache
+            json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(original_title)}.json")
+            with open(json_cache_path, 'w') as f:
+                json.dump(data, f)
+                
     except requests.RequestException as e:
         print(f"Error fetching data: {e}")
 
-def prefetch_images():
+def prefetch_metadata():
     for item in file_structure:
         if 'contents' in item:
             for sub_item in item['contents']:
-                title = sub_item['path'].split('/')[-1]
+                original_title = sub_item['path'].split('/')[-1]
                 media_type = 'series' if item['path'].startswith('tv') else 'movie'
+                title = original_title
                 year = None
-                if any(char.isdigit() for char in title):
+                if any(char.isdigit() for char in original_title):
                     # Strip year from title if present
-                    parts = title.split()
+                    parts = original_title.rsplit(' ', 1)
                     year_str = parts[-1]
                     if year_str.isdigit() and len(year_str) == 4:
-                        title = ' '.join(parts[:-1])
+                        title = parts[0]
                         year = int(year_str)
-                fetch_and_cache_image(title, media_type, year)
+                fetch_and_cache_json(original_title, title, media_type, year)
 
-# Run prefetch_images in a background thread
+# Run prefetch_metadata in a background thread
 def start_prefetching():
-    prefetch_images()
+    prefetch_metadata()
 
 # Start prefetching before running the Flask app
 thread = Thread(target=start_prefetching)
@@ -121,6 +117,10 @@ app = Flask(__name__)
 def home():
     return render_template('index.html')
 
+@app.route('/player')
+def player():
+    return render_template('player.html')
+
 @app.route('/films')
 def list_films():
     films = [item for item in file_structure if item['path'].startswith('films')]
@@ -136,19 +136,36 @@ def play(file_path):
     file_url = f"https://huggingface.co/{REPO}/resolve/main/{file_path}"
     return redirect(file_url)
 
-@app.route('/get_image')
-def get_image():
+@app.route('/get_metadata')
+def get_metadata():
     title = request.args.get('title')
     if not title:
         return jsonify({'error': 'No title provided'}), 400
     
-    cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.jpg")
+    json_cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.json")
     
-    if os.path.exists(cache_path):
-        return send_file(cache_path, mimetype='image/jpeg')
+    if os.path.exists(json_cache_path):
+        with open(json_cache_path, 'r') as f:
+            data = json.load(f)
+        return jsonify(data)
     
-    # If image is not found in cache, return a placeholder
-    return send_file('path/to/placeholder.jpg', mimetype='image/jpeg')  # Ensure you have a placeholder image
+    # If metadata is not found in cache, return an error
+    return jsonify({'error': 'Metadata not found'}), 404
+
+@app.route('/stream')
+def stream_video():
+    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')
 
 if __name__ == '__main__':
     app.run(debug=True, host="0.0.0.0", port=7860)

hf_scraper.py → hf_scrapper.py

@@ -16,10 +16,22 @@ def get_system_proxies():
         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}")
+    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
+
 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, verify=False)
+        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):
@@ -36,7 +48,7 @@ def get_file_structure(repo, token, path="", proxies=None):
     headers = {'Authorization': f'Bearer {token}'}
     print(f"Fetching file structure from URL: {api_url} with proxies: {proxies}")
     try:
-        response = requests.get(api_url, headers=headers, proxies=proxies, verify=False)
+        response = requests.get(api_url, headers=headers, proxies=proxies)
         response.raise_for_status()
         return response.json()
     except RequestException as e:

indexer.py

@@ -1,5 +1,5 @@
 import json
-from hf_scraper import get_system_proxies, get_file_structure, write_file_structure_to_json
+from hf_scrapper import get_system_proxies, get_file_structure, write_file_structure_to_json
 from dotenv import load_dotenv
 import os
 

templates/index.html

@@ -1,8 +1,6 @@
 <!DOCTYPE html>
-<html lang="en">
+<html>
 <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Media Library</title>
     <style>
         body {
@@ -79,24 +77,18 @@
     <div class="content">
         <div class="section" id="films">
             <h2>Films</h2>
-            <div class="grid" id="films-grid">
-                <!-- Film cards will be inserted here -->
-            </div>
+            <div class="grid" id="films-grid"></div>
         </div>
         <div class="section" id="tv">
             <h2>TV Shows</h2>
-            <div class="grid" id="tv-grid">
-                <!-- TV show cards will be inserted here -->
-            </div>
+            <div class="grid" id="tv-grid"></div>
         </div>
     </div>
     <script>
         async function fetchData(endpoint) {
             try {
                 const response = await fetch(endpoint);
-                if (!response.ok) {
-                    throw new Error('Network response was not ok');
-                }
+                if (!response.ok) throw new Error('Network response was not ok');
                 return await response.json();
             } catch (error) {
                 console.error('Fetch error:', error);
@@ -104,64 +96,49 @@
             }
         }
 
-        async function fetchImage(title) {
+        async function fetchMetadata(title) {
             try {
-                const response = await fetch(`/get_image?title=${encodeURIComponent(title)}`);
+                const response = await fetch(`/get_metadata?title=${encodeURIComponent(title)}`);
                 if (response.ok) {
-                    return response.url;
-                } else {
-                    console.error('Image fetch error:', response.statusText);
-                    return `https://via.placeholder.com/200x300?text=${title}`;
+                    const data = await response.json();
+                    if (data.data && data.data.length > 0) {
+                        const thumbnailUrl = data.data[0].thumbnail;
+                        return thumbnailUrl;
+                    }
                 }
             } catch (error) {
-                console.error('Image fetch error:', error);
-                return `https://via.placeholder.com/200x300?text=${title}`;
+                console.error('Metadata fetch error:', error);
             }
+            return null;
         }
 
-        async function createCard(item) {
+        function createCard(item, mediaType) {
             const card = document.createElement('div');
             card.className = 'card';
-
             const title = item.path.split('/').pop();
-            const imgSrc = await fetchImage(title);
-
-            const img = document.createElement('img');
-            img.src = imgSrc;
-            img.alt = title;
-            card.appendChild(img);
-
-            const titleElement = document.createElement('h3');
-            titleElement.textContent = title;
-            card.appendChild(titleElement);
-
-            if (item.contents) {
-                const p = document.createElement('p');
-                p.textContent = `Contains ${item.contents.length} items`;
-                card.appendChild(p);
-            } else {
-                const link = document.createElement('a');
-                link.href = `/play/${encodeURIComponent(item.path)}`;
-                link.textContent = 'Play';
-                card.appendChild(link);
-            }
-
+            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>
+            `;
+            fetchMetadata(title).then(thumbnailUrl => {
+                if (thumbnailUrl !== null) {
+                    card.querySelector('img').src = thumbnailUrl;
+                }
+            });
             return card;
         }
 
-        async function loadSection(endpoint, containerId) {
+        async function populateGrid(endpoint, gridId, mediaType) {
+            const grid = document.getElementById(gridId);
             const data = await fetchData(endpoint);
-            const container = document.getElementById(containerId);
-            container.innerHTML = '';  // Clear previous content
-            for (const item of data) {
-                container.appendChild(await createCard(item));
-            }
+            data.forEach(item => {
+                grid.appendChild(createCard(item, mediaType));
+            });
         }
 
-        document.addEventListener('DOMContentLoaded', () => {
-            loadSection('/films', 'films-grid');
-            loadSection('/tv', 'tv-grid');
-        });
+        populateGrid('/films', 'films-grid', 'movie');
+        populateGrid('/tv', 'tv-grid', 'series');
     </script>
 </body>
 </html>

templates/player.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Media Player</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #141414;
+            color: #fff;
+            margin: 0;
+            padding: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+        }
+        .player-container {
+            text-align: center;
+        }
+        video {
+            width: 80%;
+            height: auto;
+            margin-top: 20px;
+        }
+    </style>
+</head>
+<body>
+    <div class="player-container">
+        <h1 id="title"></h1>
+        <video id="videoPlayer" controls></video>
+    </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>