4 | {addon_url}',
16 | quote=True,
17 | parse_mode=enums.ParseMode.HTML
18 | )
19 |
20 | except Exception as e:
21 | await message.reply_text(f"⚠️ Error: {e}")
22 | print(f"Error in /start handler: {e}")
--------------------------------------------------------------------------------
/Backend/logger.py:
--------------------------------------------------------------------------------
1 | import pytz
2 | from logging import getLogger, FileHandler, StreamHandler, INFO, ERROR, Formatter, basicConfig
3 | from datetime import datetime
4 |
5 | IST = pytz.timezone("Asia/Kolkata")
6 |
7 | class ISTFormatter(Formatter):
8 | def formatTime(self, record, datefmt=None):
9 | dt = datetime.fromtimestamp(record.created, IST)
10 | return dt.strftime(datefmt or "%d-%b-%y %I:%M:%S %p")
11 |
12 | file_handler = FileHandler("log.txt")
13 | stream_handler = StreamHandler()
14 | formatter = ISTFormatter("[%(asctime)s] [%(levelname)s] - %(message)s", "%d-%b-%y %I:%M:%S %p")
15 | file_handler.setFormatter(formatter)
16 | stream_handler.setFormatter(formatter)
17 |
18 | basicConfig(
19 | handlers=[file_handler, stream_handler],
20 | level=INFO
21 | )
22 |
23 | getLogger("httpx").setLevel(ERROR)
24 | getLogger("pyrogram").setLevel(ERROR)
25 | getLogger("fastapi").setLevel(ERROR)
26 |
27 |
28 | LOGGER = getLogger(__name__)
29 | LOGGER.setLevel(INFO)
30 |
31 | LOGGER.info("Logger initialized with IST timezone.")
32 |
--------------------------------------------------------------------------------
/Backend/config.py:
--------------------------------------------------------------------------------
1 | from os import getenv, path
2 | from dotenv import load_dotenv
3 |
4 | load_dotenv(path.join(path.dirname(path.dirname(__file__)), "config.env"))
5 |
6 | class Telegram:
7 | API_ID = int(getenv("API_ID", "0"))
8 | API_HASH = getenv("API_HASH", "")
9 | BOT_TOKEN = getenv("BOT_TOKEN", "")
10 | HELPER_BOT_TOKEN = getenv("HELPER_BOT_TOKEN", "")
11 |
12 | BASE_URL = getenv("BASE_URL", "").rstrip('/')
13 | PORT = int(getenv("PORT", "8000"))
14 |
15 | AUTH_CHANNEL = [channel.strip() for channel in (getenv("AUTH_CHANNEL") or "").split(",") if channel.strip()]
16 | DATABASE = [db.strip() for db in (getenv("DATABASE") or "").split(",") if db.strip()]
17 |
18 | TMDB_API = getenv("TMDB_API", "")
19 |
20 | UPSTREAM_REPO = getenv("UPSTREAM_REPO", "")
21 | UPSTREAM_BRANCH = getenv("UPSTREAM_BRANCH", "")
22 |
23 | OWNER_ID = int(getenv("OWNER_ID", "5422223708"))
24 | REPLACE_MODE = getenv("REPLACE_MODE", "true").lower() == "true"
25 |
26 | ADMIN_USERNAME = getenv("ADMIN_USERNAME", "fyvio")
27 | ADMIN_PASSWORD = getenv("ADMIN_PASSWORD", "fyvio")
28 |
29 |
--------------------------------------------------------------------------------
/Backend/fastapi/security/credentials.py:
--------------------------------------------------------------------------------
1 | from fastapi import HTTPException, Request
2 | from fastapi.security import HTTPBearer
3 | from Backend.config import Telegram
4 | from typing import Optional
5 | import hashlib
6 |
7 | ADMIN_PASSWORD_HASH = hashlib.sha256(Telegram.ADMIN_PASSWORD.encode()).hexdigest()
8 |
9 | security = HTTPBearer(auto_error=False)
10 |
11 | def verify_password(password: str) -> bool:
12 | return hashlib.sha256(password.encode()).hexdigest() == ADMIN_PASSWORD_HASH
13 |
14 | def verify_credentials(username: str, password: str) -> bool:
15 | return username == Telegram.ADMIN_USERNAME and verify_password(password)
16 |
17 | def is_authenticated(request: Request) -> bool:
18 | return request.session.get("authenticated", False)
19 |
20 | def require_auth(request: Request):
21 | if not is_authenticated(request):
22 | raise HTTPException(status_code=401, detail="Authentication required")
23 | return True
24 |
25 | def get_current_user(request: Request) -> Optional[str]:
26 | if is_authenticated(request):
27 | return request.session.get("username")
28 | return None
29 |
--------------------------------------------------------------------------------
/Backend/helper/task_manager.py:
--------------------------------------------------------------------------------
1 | from asyncio import sleep
2 | from pyrogram.errors import FloodWait
3 | from Backend.logger import LOGGER
4 | from Backend.pyrofork.bot import Helper
5 |
6 | async def edit_message(chat_id: int, msg_id: int, new_caption: str):
7 | try:
8 | await Helper.edit_message_caption(
9 | chat_id=chat_id,
10 | message_id=msg_id,
11 | caption=new_caption
12 | )
13 | await sleep(2)
14 | except FloodWait as e:
15 | LOGGER.warning(f"FloodWait for {e.value} seconds while editing message {msg_id} in {chat_id}")
16 | await sleep(e.value)
17 | except Exception as e:
18 | LOGGER.error(f"Error while editing message {msg_id} in {chat_id}: {e}")
19 |
20 | async def delete_message(chat_id: int, msg_id: int):
21 | try:
22 | await Helper.delete_messages(
23 | chat_id=chat_id,
24 | message_ids=msg_id
25 | )
26 | await sleep(2)
27 | LOGGER.info(f"Deleted message {msg_id} in {chat_id}")
28 | except FloodWait as e:
29 | LOGGER.warning(f"FloodWait for {e.value} seconds while deleting message {msg_id} in {chat_id}")
30 | await sleep(e.value)
31 | except Exception as e:
32 | LOGGER.error(f"Error while deleting message {msg_id} in {chat_id}: {e}")
33 |
--------------------------------------------------------------------------------
/Backend/pyrofork/plugins/restart.py:
--------------------------------------------------------------------------------
1 | from pyrogram import filters, Client, enums
2 | from pyrogram.types import Message
3 | from Backend.helper.custom_filter import CustomFilters
4 | from Backend.logger import LOGGER
5 | from asyncio import create_subprocess_exec, gather
6 | from aiofiles import open as aiopen
7 | from os import execl as osexecl
8 | import shutil
9 |
10 | @Client.on_message(filters.command('restart') & filters.private & CustomFilters.owner, group=10)
11 | async def restart(client: Client, message: Message):
12 | try:
13 | restart_message = await message.reply_text(
14 | '⚙️ Restarting Backend API... \n\n✨ Please wait as we bring everything back online! 🚀', 15 | quote=True, 16 | parse_mode=enums.ParseMode.HTML 17 | ) 18 | 19 | proc1 = await create_subprocess_exec('uv', 'run', 'update.py') 20 | await gather(proc1.wait()) 21 | 22 | async with aiopen(".restartmsg", "w") as f: 23 | await f.write(f"{restart_message.chat.id}\n{restart_message.id}\n") 24 | 25 | LOGGER.info("Restarting the bot using uv package manager...") 26 | 27 | uv_path = shutil.which("uv") 28 | if uv_path: 29 | osexecl(uv_path, uv_path, "run", "-m", "Backend") 30 | else: 31 | raise RuntimeError("uv not found in PATH.") 32 | 33 | except Exception as e: 34 | LOGGER.error(f"Error during restart: {e}") 35 | await message.reply_text("**❌ Failed to restart. Check logs for details.**") 36 | 37 | -------------------------------------------------------------------------------- /Backend/pyrofork/plugins/manual.py: -------------------------------------------------------------------------------- 1 | import Backend 2 | from Backend.helper.custom_filter import CustomFilters 3 | from pyrogram import filters, Client, enums 4 | from pyrogram.types import Message 5 | from Backend.logger import LOGGER 6 | 7 | 8 | @Client.on_message(filters.command('set') & filters.private & CustomFilters.owner, group=10) 9 | async def manual(client: Client, message: Message): 10 | try: 11 | command = message.text.split(maxsplit=1) 12 | 13 | if len(command) == 2: 14 | url = command[1].strip() 15 | Backend.USE_DEFAULT_ID = url 16 | 17 | await message.reply_text( 18 | f"✅ Default IMDB/TMDB URL Set!\n\n" 19 | f"Now the bot will use this URL for any files you send:\n" 20 | f"
{Backend.USE_DEFAULT_ID}\n\n"
21 | f"Instructions:\n"
22 | f"1. Forward the related movie or TV show files to your channel.\n"
23 | f"2. Once all files are uploaded, clear the default URL by sending /set without any URL.",
24 | quote=True,
25 | parse_mode=enums.ParseMode.HTML
26 | )
27 | else:
28 | Backend.USE_DEFAULT_ID = None
29 | await message.reply_text(
30 | "✅ Default IMDB/TMDB URL Removed!\n\n"
31 | "You can now manually upload files without linking to a default IMDB URL.",
32 | quote=True,
33 | parse_mode=enums.ParseMode.HTML
34 | )
35 |
36 | except Exception as e:
37 | LOGGER.error(f"Error in /set handler: {e}")
38 | await message.reply_text(f"⚠️ An error occurred: {e}")
39 |
40 |
--------------------------------------------------------------------------------
/Backend/helper/encrypt.py:
--------------------------------------------------------------------------------
1 | import zlib
2 | import json
3 | import asyncio
4 | from concurrent.futures import ThreadPoolExecutor
5 |
6 | executor = ThreadPoolExecutor()
7 |
8 | def compress_data(data):
9 | return zlib.compress(data.encode(), level=zlib.Z_BEST_COMPRESSION)
10 |
11 | def decompress_data(data):
12 | return zlib.decompress(data).decode()
13 |
14 | def base62_encode(data):
15 | BASE62_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
16 | num = int.from_bytes(data, 'big')
17 | base62 = []
18 | while num:
19 | num, rem = divmod(num, 62)
20 | base62.append(BASE62_ALPHABET[rem])
21 | return ''.join(reversed(base62)) or '0'
22 |
23 | def base62_decode(data):
24 | BASE62_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
25 | num = 0
26 | for char in data:
27 | num = num * 62 + BASE62_ALPHABET.index(char)
28 | return num.to_bytes((num.bit_length() + 7) // 8, 'big') or b'\0'
29 |
30 | async def async_compress_data(data):
31 | loop = asyncio.get_running_loop()
32 | return await loop.run_in_executor(executor, compress_data, data)
33 |
34 | async def async_decompress_data(data):
35 | loop = asyncio.get_running_loop()
36 | return await loop.run_in_executor(executor, decompress_data, data)
37 |
38 | async def async_base62_encode(data):
39 | loop = asyncio.get_running_loop()
40 | return await loop.run_in_executor(executor, base62_encode, data)
41 |
42 | async def async_base62_decode(data):
43 | loop = asyncio.get_running_loop()
44 | return await loop.run_in_executor(executor, base62_decode, data)
45 |
46 | async def encode_string(data):
47 | json_data = json.dumps(data)
48 | compressed_data = await async_compress_data(json_data)
49 | return await async_base62_encode(compressed_data)
50 |
51 | async def decode_string(encoded_data):
52 | compressed_data = await async_base62_decode(encoded_data)
53 | json_data = await async_decompress_data(compressed_data)
54 | return json.loads(json_data)
55 |
--------------------------------------------------------------------------------
/Backend/pyrofork/clients.py:
--------------------------------------------------------------------------------
1 | from asyncio import gather, create_task
2 | from pyrogram import Client
3 | from Backend.logger import LOGGER
4 | from Backend.config import Telegram
5 | from Backend.pyrofork.bot import multi_clients, work_loads, StreamBot
6 | from os import environ
7 |
8 | class TokenParser:
9 | @staticmethod
10 | def parse_from_env():
11 | tokens = {
12 | c + 1: t
13 | for c, (_, t) in enumerate(
14 | filter(
15 | lambda n: n[0].startswith("MULTI_TOKEN"),
16 | sorted(environ.items())
17 | )
18 | )
19 | }
20 | return tokens
21 |
22 | async def start_client(client_id, token):
23 | try:
24 | LOGGER.info(f"Starting - Bot Client {client_id}")
25 | client = await Client(
26 | name=str(client_id),
27 | api_id=Telegram.API_ID,
28 | api_hash=Telegram.API_HASH,
29 | bot_token=token,
30 | sleep_threshold=100,
31 | no_updates=True,
32 | in_memory=True
33 | ).start()
34 | work_loads[client_id] = 0
35 | return client_id, client
36 | except Exception as e:
37 | LOGGER.error(f"Failed to start Client - {client_id} Error: {e}", exc_info=True)
38 | return None
39 |
40 | async def initialize_clients():
41 | multi_clients[0], work_loads[0] = StreamBot, 0
42 | all_tokens = TokenParser.parse_from_env()
43 | if not all_tokens:
44 | LOGGER.info("No additional Bot Clients found, Using default client")
45 | return
46 |
47 | tasks = [create_task(start_client(i, token)) for i, token in all_tokens.items()]
48 | clients = await gather(*tasks)
49 | clients = {client_id: client for client_id, client in clients if client}
50 | multi_clients.update(clients)
51 |
52 | if len(multi_clients) != 1:
53 | LOGGER.info(f"Multi-Client Mode Enabled with {len(multi_clients)} clients")
54 | else:
55 | LOGGER.info("No additional clients were initialized, using default client")
56 |
57 |
--------------------------------------------------------------------------------
/bump-version.py:
--------------------------------------------------------------------------------
1 | import re
2 | import sys
3 | from pathlib import Path
4 |
5 | def bump_version(version: str, part: str) -> str:
6 | major, minor, patch = map(int, version.split("."))
7 | if part == "patch":
8 | patch += 1
9 | elif part == "minor":
10 | minor += 1
11 | patch = 0
12 | elif part == "major":
13 | major += 1
14 | minor = patch = 0
15 | else:
16 | raise ValueError(f"Unknown part to bump: {part}")
17 | return f"{major}.{minor}.{patch}"
18 |
19 | def update_pyproject(path: Path, new_version: str):
20 | content = path.read_text()
21 | updated_content = re.sub(
22 | r'version\s*=\s*"[0-9]+\.[0-9]+\.[0-9]+"',
23 | f'version = "{new_version}"',
24 | content
25 | )
26 | path.write_text(updated_content)
27 | print(f"Updated pyproject.toml to version {new_version}")
28 |
29 | def update_init(path: Path, new_version: str):
30 | content = path.read_text()
31 | updated_content = re.sub(
32 | r'__version__\s*=\s*"[0-9]+\.[0-9]+\.[0-9]+"',
33 | f'__version__ = "{new_version}"',
34 | content
35 | )
36 | path.write_text(updated_content)
37 | print(f"Updated Backend/__init__.py to version {new_version}")
38 |
39 | def main(part: str = "patch"):
40 | pyproject_path = Path("pyproject.toml")
41 | init_path = Path("Backend/__init__.py")
42 |
43 | if not pyproject_path.exists() or not init_path.exists():
44 | print("Error: pyproject.toml or Backend/__init__.py not found.")
45 | sys.exit(1)
46 |
47 | # Read current version from pyproject.toml
48 | content = pyproject_path.read_text()
49 | match = re.search(r'version\s*=\s*"([0-9]+\.[0-9]+\.[0-9]+)"', content)
50 | if not match:
51 | print("Error: version not found in pyproject.toml")
52 | sys.exit(1)
53 |
54 | current_version = match.group(1)
55 | new_version = bump_version(current_version, part)
56 |
57 | update_pyproject(pyproject_path, new_version)
58 | update_init(init_path, new_version)
59 |
60 | if __name__ == "__main__":
61 | part = sys.argv[1] if len(sys.argv) > 1 else "patch" # default bump is patch
62 | main(part)
63 |
--------------------------------------------------------------------------------
/update.py:
--------------------------------------------------------------------------------
1 | from logging import FileHandler, StreamHandler, INFO, ERROR, Formatter, basicConfig, error as log_error, info as log_info
2 | from os import path as ospath, environ
3 | from pathlib import Path
4 | from subprocess import run as srun, PIPE
5 | from dotenv import load_dotenv
6 | from datetime import datetime
7 | import pytz
8 |
9 | IST = pytz.timezone("Asia/Kolkata")
10 |
11 | class ISTFormatter(Formatter):
12 | def formatTime(self, record, datefmt=None):
13 | dt = datetime.fromtimestamp(record.created, IST)
14 | return dt.strftime(datefmt or "%d-%b-%y %I:%M:%S %p")
15 |
16 | log_file = "log.txt"
17 | if ospath.exists(log_file):
18 | with open(log_file, "w") as f:
19 | f.truncate(0)
20 |
21 | file_handler = FileHandler(log_file)
22 | stream_handler = StreamHandler()
23 |
24 | formatter = ISTFormatter("[%(asctime)s] [%(levelname)s] - %(message)s", "%d-%b-%y %I:%M:%S %p")
25 | file_handler.setFormatter(formatter)
26 | stream_handler.setFormatter(formatter)
27 |
28 | basicConfig(handlers=[file_handler, stream_handler], level=INFO)
29 |
30 | load_dotenv("config.env")
31 |
32 | UPSTREAM_REPO = environ.get("UPSTREAM_REPO", "").strip() or None
33 | UPSTREAM_BRANCH = environ.get("UPSTREAM_BRANCH", "").strip() or "master"
34 |
35 | if UPSTREAM_REPO:
36 | if Path(".git").exists():
37 | srun(["rm", "-rf", ".git"])
38 |
39 | update_cmd = (
40 | f"git init -q && "
41 | f"git config --global user.email 'doc.adhikari@gmail.com' && "
42 | f"git config --global user.name 'weebzone' && "
43 | f"git add . && git commit -sm 'update' -q && "
44 | f"git remote add origin {UPSTREAM_REPO} && "
45 | f"git fetch origin -q && "
46 | f"git reset --hard origin/{UPSTREAM_BRANCH} -q"
47 | )
48 |
49 | update = srun(update_cmd, shell=True)
50 | repo = UPSTREAM_REPO.strip("/").split("/")
51 | repo_url = f"https://github.com/{repo[-2]}/{repo[-1]}"
52 | log_info(f"UPSTREAM_REPO: {repo_url} | UPSTREAM_BRANCH: {UPSTREAM_BRANCH}")
53 |
54 | if update.returncode == 0:
55 | log_info("Successfully updated with latest commits!!")
56 | else:
57 | log_error("❌ Update failed! Retry or ask for support.")
58 |
--------------------------------------------------------------------------------
/Backend/fastapi/templates/login.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 |
3 | {% block title %}Login - Telegram Stremio{% endblock %}
4 |
5 | {% block content %}
6 | Sign in to access the admin panel
11 |40 | Public pages: 41 | System Status | 42 | Stremio Guide 43 |
44 |Current status of Telegram Stremio services
11 |{{ stats.status|title }}
21 |{{ stats.uptime }}
29 |{{ stats.version }}
37 |Login to access the full admin dashboard
64 | 65 | Admin Login 66 | 67 |Install the Telegram Stremio addon to access your media through Stremio
11 |Copy the manifest URL below to your clipboard
23 |Launch the Stremio application on your device
40 |Go to the "Addons" section in Stremio's main menu
52 |Paste the URL in the "Add Addon" field and click install
64 |Both Stremio and this server must be on the same network or the server must be accessible via internet
79 |The addon provides access to movies and TV shows in your media collection
83 |The addon will automatically sync with your media library changes
87 |Edit and organize movie collections
149 |Edit and organize TV series
164 |Configure addon installation
179 |Install the addon to access media content through Stremio
195 |Copy the manifest URL below
204 |Open Stremio and go to Addons section
208 |Paste the URL in "Add Addon" field and install
212 |Manage your movie and TV show collections
12 |
3 |
4 |
8 | A powerful, self-hosted Telegram Stremio Media Server built with FastAPI, MongoDB, and PyroFork — seamlessly integrated with Stremio for automated media streaming and discovery. 9 |
10 | 11 |
12 | 
|
|
|
540 | |:---:|:---:|:---:|
541 | |[`Karan`](https://github.com/Weebzone)|[`Stremio`](https://github.com/Stremio)|[`ChatGPT`](https://github.com/OPENAI)|
542 | |Author|Stremio SDK|Refactor
543 |
544 |
--------------------------------------------------------------------------------
/Backend/helper/metadata.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 | import traceback
3 | import PTN
4 | import re
5 | from re import compile, IGNORECASE
6 | from Backend.helper.imdb import get_detail, get_season, search_title
7 | from themoviedb import aioTMDb
8 | from Backend.config import Telegram
9 | import Backend
10 | from Backend.logger import LOGGER
11 | from Backend.helper.encrypt import encode_string
12 |
13 | # ----------------- Configuration -----------------
14 | DELAY = 0
15 | tmdb = aioTMDb(key=Telegram.TMDB_API, language="en-US", region="US")
16 |
17 | # Cache dictionaries (per run)
18 | IMDB_CACHE: dict = {}
19 | TMDB_SEARCH_CACHE: dict = {}
20 | TMDB_DETAILS_CACHE: dict = {}
21 | EPISODE_CACHE: dict = {}
22 |
23 | # Concurrency semaphore for external API calls
24 | API_SEMAPHORE = asyncio.Semaphore(12)
25 |
26 | # ----------------- Helpers -----------------
27 | def format_tmdb_image(path: str, size="w500") -> str:
28 | if not path:
29 | return ""
30 | return f"https://image.tmdb.org/t/p/{size}{path}"
31 |
32 | def get_tmdb_logo(images) -> str:
33 | if not images:
34 | return ""
35 | logos = getattr(images, "logos", None)
36 | if not logos:
37 | return ""
38 | for logo in logos:
39 | iso_lang = getattr(logo, "iso_639_1", None)
40 | file_path = getattr(logo, "file_path", None)
41 | if iso_lang == "en" and file_path:
42 | return format_tmdb_image(file_path, "w300")
43 | for logo in logos:
44 | file_path = getattr(logo, "file_path", None)
45 | if file_path:
46 | return format_tmdb_image(file_path, "w300")
47 | return ""
48 |
49 |
50 | def format_imdb_images(imdb_id: str) -> dict:
51 | if not imdb_id:
52 | return {"poster": "", "backdrop": "", "logo": ""}
53 | return {
54 | "poster": f"https://images.metahub.space/poster/small/{imdb_id}/img",
55 | "backdrop": f"https://images.metahub.space/background/medium/{imdb_id}/img",
56 | "logo": f"https://images.metahub.space/logo/medium/{imdb_id}/img",
57 | }
58 |
59 | def extract_default_id(url: str) -> str | None:
60 | # IMDb
61 | imdb_match = re.search(r'/title/(tt\d+)', url)
62 | if imdb_match:
63 | return imdb_match.group(1)
64 |
65 | # TMDb movie or TV
66 | tmdb_match = re.search(r'/((movie|tv))/(\d+)', url)
67 | if tmdb_match:
68 | return tmdb_match.group(3)
69 |
70 | return None
71 |
72 | async def safe_imdb_search(title: str, type_: str) -> str | None:
73 | key = f"imdb::{type_}::{title}"
74 | if key in IMDB_CACHE:
75 | return IMDB_CACHE[key]
76 | try:
77 | async with API_SEMAPHORE:
78 | result = await search_title(query=title, type=type_)
79 | imdb_id = result["id"] if result else None
80 | IMDB_CACHE[key] = imdb_id
81 | return imdb_id
82 | except Exception as e:
83 | LOGGER.warning(f"IMDb search failed for '{title}' [{type_}]: {e}")
84 | return None
85 |
86 | async def safe_tmdb_search(title: str, type_: str, year=None):
87 | key = f"tmdb_search::{type_}::{title}::{year}"
88 | if key in TMDB_SEARCH_CACHE:
89 | return TMDB_SEARCH_CACHE[key]
90 | try:
91 | async with API_SEMAPHORE:
92 | if type_ == "movie":
93 | results = await tmdb.search().movies(query=title, year=year) if year else await tmdb.search().movies(query=title)
94 | else:
95 | results = await tmdb.search().tv(query=title)
96 | res = results[0] if results else None
97 | TMDB_SEARCH_CACHE[key] = res
98 | return res
99 | except Exception as e:
100 | LOGGER.error(f"TMDb search failed for '{title}' [{type_}]: {e}")
101 | TMDB_SEARCH_CACHE[key] = None
102 | return None
103 |
104 | async def _tmdb_movie_details(movie_id):
105 | if movie_id in TMDB_DETAILS_CACHE:
106 | return TMDB_DETAILS_CACHE[movie_id]
107 | try:
108 | async with API_SEMAPHORE:
109 | details = await tmdb.movie(movie_id).details(
110 | append_to_response="external_ids,credits"
111 | )
112 | images = await tmdb.movie(movie_id).images()
113 | details.images = images
114 |
115 | TMDB_DETAILS_CACHE[movie_id] = details
116 | return details
117 | except Exception as e:
118 | LOGGER.warning(f"TMDb movie details fetch failed for id={movie_id}: {e}")
119 | TMDB_DETAILS_CACHE[movie_id] = None
120 | return None
121 |
122 |
123 | async def _tmdb_tv_details(tv_id):
124 | if tv_id in TMDB_DETAILS_CACHE:
125 | return TMDB_DETAILS_CACHE[tv_id]
126 | try:
127 | async with API_SEMAPHORE:
128 | details = await tmdb.tv(tv_id).details(
129 | append_to_response="external_ids,credits"
130 | )
131 | images = await tmdb.tv(tv_id).images()
132 | details.images = images
133 | TMDB_DETAILS_CACHE[tv_id] = details
134 | return details
135 | except Exception as e:
136 | LOGGER.warning(f"TMDb tv details fetch failed for id={tv_id}: {e}")
137 | TMDB_DETAILS_CACHE[tv_id] = None
138 | return None
139 |
140 |
141 | async def _tmdb_episode_details(tv_id, season, episode):
142 | key = (tv_id, season, episode)
143 | if key in EPISODE_CACHE:
144 | return EPISODE_CACHE[key]
145 | try:
146 | async with API_SEMAPHORE:
147 | details = await tmdb.episode(tv_id, season, episode).details()
148 | EPISODE_CACHE[key] = details
149 | return details
150 | except Exception:
151 | EPISODE_CACHE[key] = None
152 | return None
153 |
154 | # ----------------- Main Metadata -----------------
155 | async def metadata(filename: str, channel: int, msg_id) -> dict | None:
156 | try:
157 | parsed = PTN.parse(filename)
158 | except Exception as e:
159 | LOGGER.error(f"PTN parsing failed for {filename}: {e}\n{traceback.format_exc()}")
160 | return None
161 |
162 | # Skip combined/invalid files
163 | if "excess" in parsed and any("combined" in item.lower() for item in parsed["excess"]):
164 | LOGGER.info(f"Skipping {filename}: contains 'combined'")
165 | return None
166 |
167 | # Skip split/multipart files
168 | multipart_pattern = compile(r'(?:part|cd|disc|disk)[s._-]*\d+(?=\.\w+$)', IGNORECASE)
169 | if multipart_pattern.search(filename):
170 | LOGGER.info(f"Skipping {filename}: seems to be a split/multipart file")
171 | return None
172 |
173 | title = parsed.get("title")
174 | season = parsed.get("season")
175 | episode = parsed.get("episode")
176 | year = parsed.get("year")
177 | quality = parsed.get("resolution")
178 | if isinstance(season, list) or isinstance(episode, list):
179 | LOGGER.warning(f"Invalid season/episode format for {filename}: {parsed}")
180 | return None
181 | if season and not episode:
182 | LOGGER.warning(f"Missing episode in {filename}: {parsed}")
183 | return None
184 | if not quality:
185 | LOGGER.warning(f"Skipping {filename}: No resolution (parsed={parsed})")
186 | return None
187 | if not title:
188 | LOGGER.info(f"No title parsed from: {filename} (parsed={parsed})")
189 | return None
190 |
191 |
192 | default_id = None
193 | try:
194 | default_id = extract_default_id(Backend.USE_DEFAULT_ID)
195 | except Exception:
196 | pass
197 | if not default_id:
198 | try:
199 | default_id = extract_default_id(filename)
200 | except Exception:
201 | pass
202 |
203 | data = {"chat_id": channel, "msg_id": msg_id}
204 | try:
205 | encoded_string = await encode_string(data)
206 | except Exception:
207 | encoded_string = None
208 |
209 | try:
210 | if season and episode:
211 | LOGGER.info(f"Fetching TV metadata: {title} S{season}E{episode}")
212 | return await fetch_tv_metadata(title, season, episode, encoded_string, year, quality, default_id)
213 | else:
214 | LOGGER.info(f"Fetching Movie metadata: {title} ({year})")
215 | return await fetch_movie_metadata(title, encoded_string, year, quality, default_id)
216 | except Exception as e:
217 | LOGGER.error(f"Error while fetching metadata for {filename}: {e}\n{traceback.format_exc()}")
218 | return None
219 |
220 | # ----------------- TV Metadata -----------------
221 | async def fetch_tv_metadata(title, season, episode, encoded_string, year=None, quality=None, default_id=None) -> dict | None:
222 | imdb_id = None
223 | tmdb_id = None
224 | imdb_tv = None
225 | imdb_ep = None
226 | use_tmdb = False
227 |
228 | # -------------------------------------------------------
229 | # 1. Handle default ID (IMDb / TMDb)
230 | # -------------------------------------------------------
231 | if default_id:
232 | default_id = str(default_id)
233 | if default_id.startswith("tt"):
234 | imdb_id = default_id
235 | use_tmdb = False
236 | elif default_id.isdigit():
237 | tmdb_id = int(default_id)
238 | use_tmdb = True
239 |
240 | # -------------------------------------------------------
241 | # 2. If no ID → Try IMDb search first
242 | # -------------------------------------------------------
243 | if not imdb_id and not tmdb_id:
244 | imdb_id = await safe_imdb_search(title, "tvSeries")
245 | use_tmdb = not bool(imdb_id)
246 |
247 | # -------------------------------------------------------
248 | # 3. IMDb fetch (series + episode)
249 | # -------------------------------------------------------
250 | if imdb_id and not use_tmdb:
251 | try:
252 | # ----- series details
253 | if imdb_id in IMDB_CACHE:
254 | imdb_tv = IMDB_CACHE[imdb_id]
255 | else:
256 | async with API_SEMAPHORE:
257 | imdb_tv = await get_detail(imdb_id=imdb_id, media_type="tvSeries")
258 | IMDB_CACHE[imdb_id] = imdb_tv
259 |
260 | # ----- episode details
261 | ep_key = f"{imdb_id}::{season}::{episode}"
262 | if ep_key in EPISODE_CACHE:
263 | imdb_ep = EPISODE_CACHE[ep_key]
264 | else:
265 | async with API_SEMAPHORE:
266 | imdb_ep = await get_season(imdb_id=imdb_id, season_id=season, episode_id=episode)
267 | EPISODE_CACHE[ep_key] = imdb_ep
268 |
269 | except Exception as e:
270 | LOGGER.warning(f"IMDb TV fetch failed [{imdb_id}] → {e}")
271 | imdb_tv = None
272 | imdb_ep = None
273 | use_tmdb = True
274 |
275 | # -------------------------------------------------------
276 | # 4. Decide if TMDb required
277 | # -------------------------------------------------------
278 | must_use_tmdb = (
279 | use_tmdb or
280 | imdb_tv is None or
281 | imdb_tv == {}
282 | )
283 |
284 | # =======================================================
285 | # 5. TMDb MODE
286 | # =======================================================
287 | if must_use_tmdb:
288 | LOGGER.info(f"No valid IMDb TV data for '{title}' → using TMDb")
289 |
290 | # Search TMDb by title
291 | if not tmdb_id:
292 | tmdb_search = await safe_tmdb_search(title, "tv", year)
293 | if not tmdb_search:
294 | LOGGER.warning(f"No TMDb TV result for '{title}'")
295 | return None
296 | tmdb_id = tmdb_search.id
297 |
298 | # Fetch full TV show details
299 | tv = await _tmdb_tv_details(tmdb_id)
300 | if not tv:
301 | LOGGER.warning(f"TMDb TV details failed for id={tmdb_id}")
302 | return None
303 |
304 | # Fetch episode
305 | ep = await _tmdb_episode_details(tmdb_id, season, episode)
306 |
307 | # Cast list
308 | credits = getattr(tv, "credits", None) or {}
309 | cast_arr = getattr(credits, "cast", []) or []
310 | cast = [
311 | getattr(c, "name", None) or getattr(c, "original_name", None)
312 | for c in cast_arr
313 | ]
314 |
315 | # Runtime (prefer episode → series → empty)
316 | ep_runtime = getattr(ep, "runtime", None) if ep else None
317 | series_runtime = (
318 | tv.episode_run_time[0] if getattr(tv, "episode_run_time", None) else None
319 | )
320 | runtime_val = ep_runtime or series_runtime
321 | runtime = f"{runtime_val} min" if runtime_val else ""
322 |
323 | return {
324 | "tmdb_id": tv.id,
325 | "imdb_id": getattr(getattr(tv, "external_ids", None), "imdb_id", None),
326 | "title": tv.name,
327 | "year": getattr(tv.first_air_date, "year", 0) if getattr(tv, "first_air_date", None) else 0,
328 | "rate": getattr(tv, "vote_average", 0) or 0,
329 | "description": tv.overview or "",
330 | "poster": format_tmdb_image(tv.poster_path),
331 | "backdrop": format_tmdb_image(tv.backdrop_path, "original"),
332 | "logo": get_tmdb_logo(getattr(tv, "images", None)),
333 | "genres": [g.name for g in (tv.genres or [])],
334 | "media_type": "tv",
335 | "cast": cast,
336 | "runtime": str(runtime),
337 |
338 | "season_number": season,
339 | "episode_number": episode,
340 | "episode_title": getattr(ep, "name", f"S{season}E{episode}") if ep else f"S{season}E{episode}",
341 | "episode_backdrop": format_tmdb_image(getattr(ep, "still_path", None), "original") if ep else "",
342 | "episode_overview": getattr(ep, "overview", "") if ep else "",
343 | "episode_released": (
344 | ep.air_date.strftime("%Y-%m-%dT05:00:00.000Z")
345 | if getattr(ep, "air_date", None)
346 | else ""
347 | ),
348 |
349 | "quality": quality,
350 | "encoded_string": encoded_string,
351 | }
352 |
353 | # =======================================================
354 | # 6. IMDb MODE
355 | # =======================================================
356 | imdb = imdb_tv or {}
357 | ep = imdb_ep or {}
358 |
359 | images = format_imdb_images(imdb_id)
360 |
361 | return {
362 | "tmdb_id": imdb.get("moviedb_id") or imdb_id.replace("tt", ""),
363 | "imdb_id": imdb_id,
364 | "title": imdb.get("title", title),
365 | "year": imdb.get("releaseDetailed", {}).get("year", 0),
366 | "rate": imdb.get("rating", {}).get("star", 0),
367 | "description": imdb.get("plot", ""),
368 | "poster": images["poster"],
369 | "backdrop": images["backdrop"],
370 | "logo": images["logo"],
371 | "cast": imdb.get("cast", []),
372 | "runtime": str(imdb.get("runtime") or ""),
373 | "genres": imdb.get("genre", []),
374 | "media_type": "tv",
375 |
376 | "season_number": season,
377 | "episode_number": episode,
378 | "episode_title": ep.get("title", f"S{season}E{episode}"),
379 | "episode_backdrop": ep.get("image", ""),
380 | "episode_overview": ep.get("plot", ""),
381 | "episode_released": str(ep.get("released", "")),
382 |
383 | "quality": quality,
384 | "encoded_string": encoded_string,
385 | }
386 |
387 |
388 | # ----------------- Movie Metadata -----------------
389 | async def fetch_movie_metadata(title, encoded_string, year=None, quality=None, default_id=None) -> dict | None:
390 | imdb_id = None
391 | tmdb_id = None
392 | imdb_details = None
393 | use_tmdb = False
394 |
395 | # -------------------------------------------------------
396 | # 1. PROCESS DEFAULT ID (tt = IMDb, digits = TMDb)
397 | # -------------------------------------------------------
398 | if default_id:
399 | default_id = str(default_id).strip()
400 |
401 | if default_id.startswith("tt"):
402 | imdb_id = default_id
403 | use_tmdb = False # force IMDb
404 | elif default_id.isdigit():
405 | tmdb_id = int(default_id)
406 | use_tmdb = True # force TMDb
407 |
408 | # -------------------------------------------------------
409 | # 2. IF NO DEFAULT ID → SEARCH IMDb FIRST
410 | # -------------------------------------------------------
411 | if not imdb_id and not tmdb_id:
412 | imdb_id = await safe_imdb_search(
413 | f"{title} {year}" if year else title,
414 | "movie"
415 | )
416 | use_tmdb = not bool(imdb_id)
417 |
418 | # -------------------------------------------------------
419 | # 3. FETCH IMDb DETAILS (only if imdb_id exists)
420 | # -------------------------------------------------------
421 | if imdb_id and not use_tmdb:
422 | try:
423 | if imdb_id in IMDB_CACHE:
424 | imdb_details = IMDB_CACHE[imdb_id]
425 | else:
426 | async with API_SEMAPHORE:
427 | imdb_details = await get_detail(
428 | imdb_id=imdb_id,
429 | media_type="movie"
430 | )
431 |
432 | IMDB_CACHE[imdb_id] = imdb_details
433 |
434 | except Exception as e:
435 | LOGGER.warning(f"IMDb movie fetch failed [{title}] → {e}")
436 | imdb_details = None
437 | use_tmdb = True
438 |
439 | # -------------------------------------------------------
440 | # 4. DECIDE FINAL DATA SOURCE
441 | # -------------------------------------------------------
442 | must_use_tmdb = (
443 | use_tmdb or
444 | imdb_details is None or
445 | imdb_details == {}
446 | )
447 |
448 | # =======================================================
449 | # 5. TMDb MODE
450 | # =======================================================
451 | if must_use_tmdb:
452 | LOGGER.info(f"No valid IMDb data for '{title}' → using TMDb")
453 |
454 | # TMDb search if id unknown
455 | if not tmdb_id:
456 | tmdb_result = await safe_tmdb_search(title, "movie", year)
457 | if not tmdb_result:
458 | LOGGER.warning(f"No TMDb movie found for '{title}'")
459 | return None
460 | tmdb_id = tmdb_result.id
461 |
462 | # Fetch TMDb details
463 | movie = await _tmdb_movie_details(tmdb_id)
464 | if not movie:
465 | LOGGER.warning(f"TMDb details failed for {tmdb_id}")
466 | return None
467 |
468 | # Cast extraction
469 | credits = getattr(movie, "credits", None) or {}
470 | cast_arr = getattr(credits, "cast", []) or []
471 | cast_names = [
472 | getattr(c, "name", None) or getattr(c, "original_name", None)
473 | for c in cast_arr
474 | ]
475 |
476 | runtime_val = getattr(movie, "runtime", None)
477 | runtime = f"{runtime_val} min" if runtime_val else ""
478 |
479 | return {
480 | "tmdb_id": movie.id,
481 | "imdb_id": getattr(movie.external_ids, "imdb_id", None),
482 | "title": movie.title,
483 | "year": getattr(movie.release_date, "year", 0) if getattr(movie, "release_date", None) else 0,
484 | "rate": getattr(movie, "vote_average", 0) or 0,
485 | "description": movie.overview or "",
486 | "poster": format_tmdb_image(movie.poster_path),
487 | "backdrop": format_tmdb_image(movie.backdrop_path, "original"),
488 | "logo": get_tmdb_logo(getattr(movie, "images", None)),
489 | "cast": cast_names,
490 | "runtime": str(runtime),
491 | "media_type": "movie",
492 | "genres": [g.name for g in (movie.genres or [])],
493 | "quality": quality,
494 | "encoded_string": encoded_string,
495 | }
496 |
497 | # =======================================================
498 | # 6. IMDb MODE
499 | # =======================================================
500 | images = format_imdb_images(imdb_id)
501 | imdb = imdb_details or {}
502 |
503 | return {
504 | "tmdb_id": imdb.get("moviedb_id") or imdb_id.replace("tt", ""),
505 | "imdb_id": imdb_id,
506 | "title": imdb.get("title", title),
507 | "year": imdb.get("releaseDetailed", {}).get("year", 0),
508 | "rate": imdb.get("rating", {}).get("star", 0),
509 | "description": imdb.get("plot", ""),
510 | "poster": images["poster"],
511 | "backdrop": images["backdrop"],
512 | "logo": images["logo"],
513 | "cast": imdb.get("cast", []),
514 | "runtime": str(imdb.get("runtime") or ""),
515 | "media_type": "movie",
516 | "genres": imdb.get("genre", []),
517 | "quality": quality,
518 | "encoded_string": encoded_string,
519 | }
520 |
--------------------------------------------------------------------------------