init

.gitignore

@@ -0,0 +1,6 @@
+#.env
+.env
+# cache
+tmp
+# pycache
+__pycache__

app.py

@@ -0,0 +1,152 @@
+from flask import Flask, jsonify, render_template, redirect, request, send_file
+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 indexer import indexer
+from dotenv import load_dotenv
+
+load_dotenv()
+INDEX_FILE = os.getenv("INDEX_FILE")
+TOKEN = os.getenv("TOKEN")
+REPO = os.getenv("REPO")
+THETVDB_API_KEY = os.getenv("THETVDB_API_KEY")
+THETVDB_API_URL = os.getenv("THETVDB_API_URL")
+CACHE_DIR = os.getenv("CACHE_DIR")
+TOKEN_EXPIRY = None
+THETVDB_TOKEN = None
+proxies = get_system_proxies()
+
+if not os.path.exists(CACHE_DIR):
+    os.makedirs(CACHE_DIR)
+
+indexer()
+
+# Check if INDEX_FILE exists
+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 authenticate_thetvdb():
+    global THETVDB_TOKEN, TOKEN_EXPIRY
+    auth_url = f"{THETVDB_API_URL}/login"
+    auth_data = {
+        "apikey": THETVDB_API_KEY
+    }
+    try:
+        response = requests.post(auth_url, json=auth_data, proxies=proxies)
+        response.raise_for_status()
+        response_data = response.json()
+        print("Auth Response Data:", response_data)  # Debugging print statement
+        THETVDB_TOKEN = response_data['data']['token']
+        TOKEN_EXPIRY = datetime.now() + timedelta(days=30)  # token is valid for 1 month
+    except requests.RequestException as e:
+        print(f"Authentication failed: {e}")
+        THETVDB_TOKEN = None
+        TOKEN_EXPIRY = None
+
+def get_thetvdb_token():
+    global THETVDB_TOKEN, TOKEN_EXPIRY
+    if not THETVDB_TOKEN or datetime.now() >= TOKEN_EXPIRY:
+        authenticate_thetvdb()
+    return THETVDB_TOKEN
+
+def fetch_and_cache_image(title, media_type, year=None):
+    if year:
+        search_url = f"{THETVDB_API_URL}/search?query={title}&type={media_type}&year={year}"
+    else:
+        search_url = f"{THETVDB_API_URL}/search?query={title}&type={media_type}"
+    
+    token = get_thetvdb_token()
+    if not token:
+        print("Authentication failed")
+        return
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "accept": "application/json",
+    }
+    
+    try:
+        response = requests.get(search_url, headers=headers, proxies=proxies)
+        response.raise_for_status()
+        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)
+    except requests.RequestException as e:
+        print(f"Error fetching data: {e}")
+
+def prefetch_images():
+    for item in file_structure:
+        if 'contents' in item:
+            for sub_item in item['contents']:
+                title = sub_item['path'].split('/')[-1]
+                media_type = 'series' if item['path'].startswith('tv') else 'movie'
+                year = None
+                if any(char.isdigit() for char in title):
+                    # Strip year from title if present
+                    parts = title.split()
+                    year_str = parts[-1]
+                    if year_str.isdigit() and len(year_str) == 4:
+                        title = ' '.join(parts[:-1])
+                        year = int(year_str)
+                fetch_and_cache_image(title, media_type, year)
+
+# Run prefetch_images in a background thread
+def start_prefetching():
+    prefetch_images()
+
+# Start prefetching before running the Flask app
+thread = Thread(target=start_prefetching)
+thread.daemon = True
+thread.start()
+
+app = Flask(__name__)
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/films')
+def list_films():
+    films = [item for item in file_structure if item['path'].startswith('films')]
+    return jsonify([sub_item for film in films for sub_item in film['contents']])
+
+@app.route('/tv')
+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('/get_image')
+def get_image():
+    title = request.args.get('title')
+    cache_path = os.path.join(CACHE_DIR, f"{urllib.parse.quote(title)}.jpg")
+    
+    if os.path.exists(cache_path):
+        return send_file(cache_path, mimetype='image/jpeg')
+    
+    # If image is not found in cache, return a placeholder
+    return jsonify({'poster': 'placeholder'})
+
+if __name__ == '__main__':
+    app.run(debug=True, host="0.0.0.0", port=7860)

hf_scraper.py

@@ -0,0 +1,52 @@
+import os
+import requests
+import json
+import urllib.request
+from requests.exceptions import RequestException
+
+def get_system_proxies():
+    try:
+        proxies = urllib.request.getproxies()
+        print("System proxies:", proxies)
+        return {
+            "http": proxies.get("http"),
+            "https": proxies.get("http")
+        }
+    except Exception as e:
+        print(f"Error getting system proxies: {e}")
+        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, verify=False)
+        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}"
+    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.raise_for_status()
+        return response.json()
+    except RequestException as e:
+        print(f"Error fetching file structure: {e}")
+        return []
+
+def write_file_structure_to_json(file_structure, file_path):
+    try:
+        with open(file_path, 'w') as json_file:
+            json.dump(file_structure, json_file, indent=2)
+        print(f'File structure written to {file_path}')
+    except IOError as e:
+        print(f"Error writing file structure to JSON: {e}")

indexer.py

@@ -0,0 +1,32 @@
+import json
+from hf_scraper import get_system_proxies, get_file_structure, write_file_structure_to_json
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+def index_repository(token, repo, current_path="", proxies=None):
+    file_structure = get_file_structure(repo, token, current_path, proxies)
+    full_structure = []
+    for item in file_structure:
+        if item['type'] == 'directory':
+            sub_directory_structure = index_repository(token, repo, item['path'], proxies)
+            full_structure.append({
+                "type": "directory",
+                "path": item['path'],
+                "contents": sub_directory_structure
+            })
+        else:
+            full_structure.append(item)
+    return full_structure
+
+def indexer():
+    token = os.getenv("TOKEN")
+    repo = os.getenv("REPO")
+    output_path = os.getenv("INDEX_FILE")
+    
+    proxies = get_system_proxies()
+    full_structure = index_repository(token, repo, "", proxies)
+    write_file_structure_to_json(full_structure, output_path)
+    print(f"Full file structure for repository '{repo}' has been indexed and saved to {output_path}")
+    

requirements.txt

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

templates/index.html

@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Media Library</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #141414;
+            color: #fff;
+            margin: 0;
+            padding: 0;
+        }
+        .header {
+            background-color: #000;
+            padding: 20px;
+            text-align: center;
+        }
+        .header h1 {
+            margin: 0;
+            font-size: 24px;
+        }
+        .content {
+            padding: 20px;
+        }
+        .section {
+            margin-bottom: 40px;
+        }
+        .section h2 {
+            margin-bottom: 20px;
+        }
+        .grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+            gap: 20px;
+        }
+        .card {
+            background-color: #333;
+            border-radius: 10px;
+            overflow: hidden;
+            text-align: center;
+            transition: transform 0.2s;
+        }
+        .card:hover {
+            transform: scale(1.05);
+        }
+        .card img {
+            width: 100%;
+            height: 300px;
+            object-fit: cover;
+        }
+        .card h3 {
+            margin: 0;
+            padding: 10px;
+            font-size: 18px;
+        }
+        .card p {
+            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>
+    <div class="header">
+        <h1>Media Library</h1>
+    </div>
+    <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>
+        <div class="section" id="tv">
+            <h2>TV Shows</h2>
+            <div class="grid" id="tv-grid">
+                <!-- TV show cards will be inserted here -->
+            </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');
+                }
+                return await response.json();
+            } catch (error) {
+                console.error('Fetch error:', error);
+                return [];
+            }
+        }
+
+        async function fetchImage(title, mediaType) {
+            try {
+                const response = await fetch(`/get_image?title=${encodeURIComponent(title)}&type=${mediaType}`);
+                if (response.headers.get('content-type') === 'application/json') {
+                    const data = await response.json();
+                    return `https://via.placeholder.com/200x300?text=${title}`;
+                } else {
+                    return response.url;
+                }
+            } catch (error) {
+                console.error('Image fetch error:', error);
+                return `https://via.placeholder.com/200x300?text=${title}`;
+            }
+        }
+
+        async function createCard(item) {
+            const card = document.createElement('div');
+            card.className = 'card';
+
+            const title = item.path.split('/').pop();
+            const mediaType = item.path.includes('tv') ? 'series' : 'movie'; // Determine media type
+            const img = document.createElement('img');
+            img.src = await fetchImage(title, mediaType);
+            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);
+            }
+
+            return card;
+        }
+
+        async function loadSection(endpoint, containerId) {
+            const data = await fetchData(endpoint);
+            const container = document.getElementById(containerId);
+            for (const item of data) {
+                container.appendChild(await createCard(item));
+            }
+        }
+
+        document.addEventListener('DOMContentLoaded', () => {
+            loadSection('/films', 'films-grid');
+            loadSection('/tv', 'tv-grid');
+        });
+    </script>
+</body>
+</html>