109 lines
4.1 KiB
Python
109 lines
4.1 KiB
Python
import os
|
|
import json
|
|
import requests
|
|
|
|
from typing import List
|
|
|
|
from stream_fusion.logging_config import logger
|
|
from stream_fusion.utils.torrent.torrent_item import TorrentItem
|
|
from stream_fusion.constants import EXCLUDED_TRACKERS
|
|
from stream_fusion.settings import settings
|
|
|
|
|
|
def search_public(media):
|
|
if not settings.public_cache_url:
|
|
return None
|
|
|
|
logger.info("Searching for public cached " + media.type + " results")
|
|
url = settings.public_cache_url + "getResult/" + media.type + "/"
|
|
# Without that, the cache doesn't return results. Maybe make multiple requests? One for each language, just like jackett?
|
|
cache_search = media.__dict__
|
|
cache_search["title"] = cache_search["titles"][0]
|
|
cache_search["language"] = cache_search["languages"][0]
|
|
# Wtf, why do we need to use __dict__ here? And also, why is it stuck when we use media directly?
|
|
response = requests.get(url, json=cache_search)
|
|
try:
|
|
response.raise_for_status() # Lève une exception pour les codes d'état HTTP d'erreur (4xx ou 5xx)
|
|
return response.json()
|
|
except requests.exceptions.RequestException as e:
|
|
logger.error(f"Search: Erreur lors de la récupération des résultats du cache public: {e}")
|
|
return None
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Search: Erreur de décodage JSON pour le cache public: {e}. Contenu de la réponse: {response.text[:200]}")
|
|
return None
|
|
|
|
|
|
def cache_public(torrents: List[TorrentItem], media):
|
|
if not settings.public_cache_url:
|
|
return
|
|
|
|
if os.getenv("NODE_ENV") == "development":
|
|
return
|
|
|
|
logger.info("Started Public Caching results")
|
|
|
|
cache_items = []
|
|
for torrent in torrents:
|
|
if torrent.indexer in EXCLUDED_TRACKERS:
|
|
continue
|
|
|
|
try:
|
|
cache_item = dict()
|
|
|
|
cache_item["title"] = torrent.raw_title
|
|
cache_item["trackers"] = (
|
|
"tracker:".join(torrent.trackers) if torrent.trackers else "Unknown"
|
|
)
|
|
cache_item["magnet"] = torrent.magnet if torrent.magnet else "Unknown"
|
|
cache_item["files"] = [] # I guess keep it empty?
|
|
cache_item["hash"] = torrent.info_hash
|
|
cache_item["indexer"] = torrent.indexer if torrent.indexer else "Unknown"
|
|
cache_item["quality"] = (
|
|
torrent.parsed_data.resolution
|
|
if torrent.parsed_data.resolution
|
|
else "Unknown"
|
|
)
|
|
cache_item["qualitySpec"] = (
|
|
";".join(torrent.parsed_data.quality)
|
|
if torrent.parsed_data.quality
|
|
else "Unknown"
|
|
)
|
|
cache_item["seeders"] = torrent.seeders if torrent.seeders else 0
|
|
cache_item["size"] = torrent.size
|
|
cache_item["language"] = (
|
|
";".join(torrent.languages) if torrent.languages else "Unknown"
|
|
)
|
|
cache_item["type"] = media.type
|
|
cache_item["availability"] = False
|
|
|
|
if media.type == "movie":
|
|
cache_item["year"] = media.year if media.year else "1990"
|
|
elif media.type == "series":
|
|
cache_item["season"] = media.season
|
|
cache_item["episode"] = media.episode
|
|
cache_item["seasonfile"] = (
|
|
False # I guess keep it false to not mess up results?
|
|
)
|
|
|
|
cache_items.append(cache_item)
|
|
except:
|
|
logger.exception("An exception occured durring public cache parsing")
|
|
pass
|
|
|
|
try:
|
|
url = f"{settings.public_cache_url}pushResult/{media.type}"
|
|
cache_data = json.dumps(cache_items, indent=4)
|
|
response = requests.post(url, data=cache_data)
|
|
response.raise_for_status()
|
|
|
|
if response.status_code == 200:
|
|
logger.info(
|
|
f"Cached {str(len(cache_items))} {media.type} results on Public Cache"
|
|
)
|
|
else:
|
|
logger.error(
|
|
f"Failed to public cache {media.type} results: {str(response)}"
|
|
)
|
|
except:
|
|
logger.error("Failed to public cache results")
|
|
pass
|