File size: 6,846 Bytes
2e81e75 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 |
from flask import Flask, jsonify, request, send_from_directory
from flask_cors import CORS
import os
import json
from threading import Thread
import urllib.parse
from Instance import Instance
from api import LoadBalancerAPI
app = Flask(__name__)
CORS(app)
# Constants and Configuration
CACHE_DIR = os.getenv("CACHE_DIR")
INDEX_FILE = os.getenv("INDEX_FILE")
TOKEN = os.getenv("TOKEN")
REPO = os.getenv("REPO")
ID = os.getenv("ID")
URL = os.getenv("URL")
LOAD_BALANCER_URL = os.getenv("LOAD_BALANCER_URL")
load_balancer_api = LoadBalancerAPI(base_url=LOAD_BALANCER_URL)
instance = Instance(id=ID, url=URL, cache_dir=CACHE_DIR, index_file=INDEX_FILE, token=TOKEN, repo=REPO, load_balancer_api=load_balancer_api)
# API Endpoints
@app.route('/api/film/<title>', methods=['GET'])
def get_movie_api(title):
"""Endpoint to get the movie by title."""
if not title:
return jsonify({"error": "Title parameter is required"}), 400
# Load the film store JSON
with open(instance.FILM_STORE_JSON_PATH, 'r') as json_file:
film_store_data = json.load(json_file)
# Check if the film is already cached
if title in film_store_data:
cache_path = film_store_data[title]
if os.path.exists(cache_path):
return send_from_directory(os.path.dirname(cache_path), os.path.basename(cache_path))
movie_path = instance.find_movie_path(title)
if not movie_path:
return jsonify({"error": "Movie not found"}), 404
cache_path = os.path.join(CACHE_DIR, movie_path)
file_url = f"https://huggingface.co/{REPO}/resolve/main/{movie_path}"
proxies = instance.get_system_proxies()
film_id = instance.get_film_id(title)
# Start the download in a separate thread if not already downloading
if film_id not in instance.download_threads or not instance.download_threads[film_id].is_alive():
thread = Thread(target=instance.download_film, args=(file_url, TOKEN, cache_path, proxies, film_id, title))
instance.download_threads[film_id] = thread
thread.start()
return jsonify({"status": "Download started", "film_id": film_id})
@app.route('/api/tv/<title>/<season>/<episode>', methods=['GET'])
def get_tv_show_api(title, season, episode):
"""Endpoint to get the TV show by title, season, and episode."""
if not title or not season or not episode:
return jsonify({"error": "Title, season, and episode parameters are required"}), 400
# Load the TV store JSON
with open(instance.TV_STORE_JSON_PATH, 'r') as json_file:
tv_store_data = json.load(json_file)
# Check if the episode is already cached
if title in tv_store_data and season in tv_store_data[title]:
for ep in tv_store_data[title][season]:
if episode in ep:
cache_path = tv_store_data[title][season][ep]
print(cache_path)
if os.path.exists(cache_path):
return send_from_directory(os.path.dirname(cache_path), os.path.basename(cache_path))
tv_path = instance.find_tv_path(title)
if not tv_path:
return jsonify({"error": "TV show not found"}), 404
episode_path = None
for directory in instance.file_structure:
if directory['type'] == 'directory' and directory['path'] == 'tv':
for sub_directory in directory['contents']:
if sub_directory['type'] == 'directory' and title.lower() in sub_directory['path'].lower():
for season_dir in sub_directory['contents']:
if season_dir['type'] == 'directory' and season in season_dir['path']:
for episode_file in season_dir['contents']:
if episode_file['type'] == 'file' and episode in episode_file['path']:
episode_path = episode_file['path']
break
if not episode_path:
return jsonify({"error": "Episode not found"}), 404
cache_path = os.path.join(CACHE_DIR, episode_path)
file_url = f"https://huggingface.co/{REPO}/resolve/main/{episode_path}"
proxies = instance.get_system_proxies()
episode_id = instance.encode_episodeid(title, season, episode)
# Start the download in a separate thread if not already downloading
if episode_id not in instance.download_threads or not instance.download_threads[episode_id].is_alive():
thread = Thread(target=instance.download_episode, args=(file_url, TOKEN, cache_path, proxies, episode_id, title))
instance.download_threads[episode_id] = thread
thread.start()
return jsonify({"status": "Download started", "episode_id": episode_id})
@app.route('/api/progress/<id>', methods=['GET'])
def get_progress_api(id):
"""Endpoint to get the download progress of a movie or TV show episode."""
progress = instance.get_download_progress(id)
return jsonify({"id": id, "progress": progress})
@app.route('/api/cache/size', methods=['GET'])
def get_cache_size_api():
total_size = 0
for dirpath, dirnames, filenames in os.walk(CACHE_DIR):
for f in filenames:
fp = os.path.join(dirpath, f)
total_size += os.path.getsize(fp)
readable_size = instance.bytes_to_human_readable(total_size)
return jsonify({"cache_size": readable_size})
@app.route('/api/cache/clear', methods=['POST'])
def clear_cache_api():
for dirpath, dirnames, filenames in os.walk(CACHE_DIR):
for f in filenames:
fp = os.path.join(dirpath, f)
os.remove(fp)
return jsonify({"status": "Cache cleared"})
@app.route('/api/tv/store', methods=['GET'])
def get_tv_store_api():
"""Endpoint to get the TV store JSON."""
if os.path.exists(instance.TV_STORE_JSON_PATH):
with open(instance.TV_STORE_JSON_PATH, 'r') as json_file:
tv_store_data = json.load(json_file)
return jsonify(tv_store_data)
return jsonify({}), 404
@app.route('/api/film/store', methods=['GET'])
def get_film_store_api():
"""Endpoint to get the film store JSON."""
if os.path.exists(instance.FILM_STORE_JSON_PATH):
with open(instance.FILM_STORE_JSON_PATH, 'r') as json_file:
tv_store_data = json.load(json_file)
return jsonify(tv_store_data)
return jsonify({}), 404
@app.route("/api/film/all")
def get_all_films_api():
return instance.get_all_films()
@app.route("/api/tv/all")
def get_all_tvshows_api():
return instance.get_all_tv_shows()
@app.route("/api/get/report",methods=["GET"])
def get_report():
report=instance.compile_report()
return jsonify(report)
# Routes
@app.route('/')
def index():
return jsonify(instance.version)
# Main entry point
if __name__ == "__main__":
app.run(debug=True, host="0.0.0.0", port=7860)
|