Upload 26 files

.env-sample

@@ -0,0 +1,27 @@
+ADDON_ID=stremio.comet.fast # for Stremio
+ADDON_NAME=Comet # for Stremio
+FASTAPI_HOST=0.0.0.0
+FASTAPI_PORT=8000
+FASTAPI_WORKERS=1 # remove to destroy CPU -> max performances :)
+DASHBOARD_ADMIN_PASSWORD=CHANGE_ME # The password to access the dashboard with active connections and soon more...
+DATABASE_TYPE=sqlite # or postgresql if you know what you're doing
+DATABASE_URL=username:password@hostname:port # to connect to PostgreSQL
+DATABASE_PATH=data/comet.db # only change it if you know what it is - folders in path must exist - ignored if PostgreSQL used
+CACHE_TTL=86400 # cache duration in seconds
+DEBRID_PROXY_URL=http://127.0.0.1:1080 # https://github.com/cmj2002/warp-docker to bypass Debrid Services and Torrentio server IP blacklist 
+INDEXER_MANAGER_TYPE=jackett # or prowlarr or None if you want to disable it completely and use Zilean or Torrentio
+INDEXER_MANAGER_URL=http://127.0.0.1:9117
+INDEXER_MANAGER_API_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+INDEXER_MANAGER_TIMEOUT=60 # maximum time to obtain search results from indexer manager in seconds
+INDEXER_MANAGER_INDEXERS='["EXAMPLE1_CHANGETHIS", "EXAMPLE2_CHANGETHIS"]'
+GET_TORRENT_TIMEOUT=5 # maximum time to obtain the torrent info hash in seconds
+ZILEAN_URL=None # for DMM search - https://github.com/iPromKnight/zilean - ex: http://127.0.0.1:8181
+ZILEAN_TAKE_FIRST=500 # only change it if you know what it is
+SCRAPE_TORRENTIO=False # scrape Torrentio
+PROXY_DEBRID_STREAM=False # Proxy Debrid Streams (very useful to use your debrid service on multiple IPs at same time)
+PROXY_DEBRID_STREAM_PASSWORD=CHANGE_ME # Secret password to enter on configuration page to prevent people from abusing your debrid stream proxy
+PROXY_DEBRID_STREAM_MAX_CONNECTIONS=100 # IP-Based connection limit for the Debrid Stream Proxy
+PROXY_DEBRID_STREAM_DEBRID_DEFAULT_SERVICE=realdebrid # if you want your users who use the Debrid Stream Proxy not to have to specify Debrid information, but to use the default one instead
+PROXY_DEBRID_STREAM_DEBRID_DEFAULT_APIKEY=CHANGE_ME # if you want your users who use the Debrid Stream Proxy not to have to specify Debrid information, but to use the default one instead
+TITLE_MATCH_CHECK=True # disable if you only use Jackett / Prowlarr / Torrentio and are sure you're only scraping good titles, for example (keep it True if Zilean is enabled)
+CUSTOM_HEADER_HTML=None # only set it if you know what it is

.gitignore

@@ -0,0 +1,167 @@
+# Project Based
+*.db
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+logs/
+.vscode/
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Goldy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

comet/api/core.py

@@ -0,0 +1,79 @@
+import PTT
+import RTN
+
+from fastapi import APIRouter, Request
+from fastapi.responses import RedirectResponse
+from fastapi.templating import Jinja2Templates
+
+from comet.utils.models import settings
+from comet.utils.general import config_check, get_debrid_extension
+
+templates = Jinja2Templates("comet/templates")
+main = APIRouter()
+
+
+@main.get("/", status_code=200)
+async def root():
+    return RedirectResponse("/configure")
+
+
+@main.get("/health", status_code=200)
+async def health():
+    return {"status": "ok"}
+
+
+indexers = settings.INDEXER_MANAGER_INDEXERS
+languages = [language for language in PTT.parse.LANGUAGES_TRANSLATION_TABLE.values()]
+languages.insert(0, "Multi")
+web_config = {
+    "indexers": [indexer.replace(" ", "_").lower() for indexer in indexers],
+    "languages": languages,
+    "resolutions": [resolution.value for resolution in RTN.models.Resolution],
+    "resultFormat": ["Title", "Metadata", "Size", "Tracker", "Languages"],
+}
+
+
+@main.get("/configure")
+@main.get("/{b64config}/configure")
+async def configure(request: Request):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "CUSTOM_HEADER_HTML": settings.CUSTOM_HEADER_HTML
+            if settings.CUSTOM_HEADER_HTML
+            else "",
+            "webConfig": web_config,
+            "indexerManager": settings.INDEXER_MANAGER_TYPE,
+            "proxyDebridStream": settings.PROXY_DEBRID_STREAM,
+        },
+    )
+
+
+@main.get("/manifest.json")
+@main.get("/{b64config}/manifest.json")
+async def manifest(b64config: str = None):
+    config = config_check(b64config)
+    if not config:
+        config = {"debridService": None}
+
+    debrid_extension = get_debrid_extension(config["debridService"])
+
+    return {
+        "id": settings.ADDON_ID,
+        "name": f"{settings.ADDON_NAME}{(' | ' + debrid_extension) if debrid_extension is not None else ''}",
+        "description": "Stremio's fastest torrent/debrid search add-on.",
+        "version": "1.0.0",
+        "catalogs": [],
+        "resources": [
+            {
+                "name": "stream",
+                "types": ["movie", "series"],
+                "idPrefixes": ["tt", "kitsu"],
+            }
+        ],
+        "types": ["movie", "series", "anime", "other"],
+        "logo": "https://i.imgur.com/jmVoVMu.jpeg",
+        "background": "https://i.imgur.com/WwnXB3k.jpeg",
+        "behaviorHints": {"configurable": True, "configurationRequired": False},
+    }

comet/api/stream.py

@@ -0,0 +1,601 @@
+import asyncio
+import hashlib
+import json
+import time
+import aiohttp
+import httpx
+import uuid
+import orjson
+
+from fastapi import APIRouter, Request
+from fastapi.responses import (
+    RedirectResponse,
+    StreamingResponse,
+    FileResponse,
+    Response,
+)
+from starlette.background import BackgroundTask
+from RTN import Torrent, sort_torrents
+
+from comet.debrid.manager import getDebrid
+from comet.utils.general import (
+    config_check,
+    get_debrid_extension,
+    get_indexer_manager,
+    get_zilean,
+    get_torrentio,
+    filter,
+    get_torrent_hash,
+    translate,
+    get_balanced_hashes,
+    format_title,
+    get_client_ip,
+)
+from comet.utils.logger import logger
+from comet.utils.models import database, rtn, settings
+
+streams = APIRouter()
+
+
+@streams.get("/stream/{type}/{id}.json")
+@streams.get("/{b64config}/stream/{type}/{id}.json")
+async def stream(request: Request, b64config: str, type: str, id: str):
+    config = config_check(b64config)
+    if not config:
+        return {
+            "streams": [
+                {
+                    "name": "[⚠️] Comet",
+                    "title": "Invalid Comet config.",
+                    "url": "https://comet.fast",
+                }
+            ]
+        }
+
+    connector = aiohttp.TCPConnector(limit=0)
+    async with aiohttp.ClientSession(connector=connector) as session:
+        full_id = id
+        season = None
+        episode = None
+        if type == "series":
+            info = id.split(":")
+            id = info[0]
+            season = int(info[1])
+            episode = int(info[2])
+
+        try:
+            kitsu = False
+            if id == "kitsu":
+                kitsu = True
+                get_metadata = await session.get(
+                    f"https://kitsu.io/api/edge/anime/{season}"
+                )
+                metadata = await get_metadata.json()
+                name = metadata["data"]["attributes"]["canonicalTitle"]
+                season = 1
+                year = None
+            else:
+                get_metadata = await session.get(
+                    f"https://v3.sg.media-imdb.com/suggestion/a/{id}.json"
+                )
+                metadata = await get_metadata.json()
+                element = metadata["d"][
+                    0
+                    if metadata["d"][0]["id"]
+                    not in ["/imdbpicks/summer-watch-guide", "/emmys"]
+                    else 1
+                ]
+
+                for element in metadata["d"]:
+                    if "/" not in element["id"]:
+                        break
+
+                name = element["l"]
+                year = element["y"]
+        except Exception as e:
+            logger.warning(f"Exception while getting metadata for {id}: {e}")
+
+            return {
+                "streams": [
+                    {
+                        "name": "[⚠️] Comet",
+                        "title": f"Can't get metadata for {id}",
+                        "url": "https://comet.fast",
+                    }
+                ]
+            }
+
+        name = translate(name)
+        log_name = name
+        if type == "series":
+            log_name = f"{name} S0{season}E0{episode}"
+
+        cache_key = hashlib.md5(
+            json.dumps(
+                {
+                    "debridService": config["debridService"],
+                    "name": name,
+                    "season": season,
+                    "episode": episode,
+                    "indexers": config["indexers"],
+                }
+            ).encode("utf-8")
+        ).hexdigest()
+        cached = await database.fetch_one(
+            f"SELECT EXISTS (SELECT 1 FROM cache WHERE cacheKey = '{cache_key}')"
+        )
+        if cached[0] != 0:
+            logger.info(f"Cache found for {log_name}")
+
+            timestamp = await database.fetch_one(
+                f"SELECT timestamp FROM cache WHERE cacheKey = '{cache_key}'"
+            )
+            if timestamp[0] + settings.CACHE_TTL < time.time():
+                await database.execute(
+                    f"DELETE FROM cache WHERE cacheKey = '{cache_key}'"
+                )
+
+                logger.info(f"Cache expired for {log_name}")
+            else:
+                sorted_ranked_files = await database.fetch_one(
+                    f"SELECT results FROM cache WHERE cacheKey = '{cache_key}'"
+                )
+                sorted_ranked_files = json.loads(sorted_ranked_files[0])
+
+                debrid_extension = get_debrid_extension(config["debridService"])
+
+                balanced_hashes = get_balanced_hashes(sorted_ranked_files, config)
+
+                results = []
+                if (
+                    config["debridStreamProxyPassword"] != ""
+                    and settings.PROXY_DEBRID_STREAM
+                    and settings.PROXY_DEBRID_STREAM_PASSWORD
+                    != config["debridStreamProxyPassword"]
+                ):
+                    results.append(
+                        {
+                            "name": "[⚠️] Comet",
+                            "title": "Debrid Stream Proxy Password incorrect.\nStreams will not be proxied.",
+                            "url": "https://comet.fast",
+                        }
+                    )
+
+                for (
+                    hash,
+                    hash_data,
+                ) in sorted_ranked_files.items():
+                    for resolution, hash_list in balanced_hashes.items():
+                        if hash in hash_list:
+                            data = hash_data["data"]
+                            results.append(
+                                {
+                                    "name": f"[{debrid_extension}⚡] Comet {data['resolution']}",
+                                    "title": format_title(data, config),
+                                    "torrentTitle": (
+                                        data["torrent_title"]
+                                        if "torrent_title" in data
+                                        else None
+                                    ),
+                                    "torrentSize": (
+                                        data["torrent_size"]
+                                        if "torrent_size" in data
+                                        else None
+                                    ),
+                                    "url": f"{request.url.scheme}://{request.url.netloc}/{b64config}/playback/{hash}/{data['index']}",
+                                    "behaviorHints": {
+                                        "filename": data["raw_title"],
+                                        "bingeGroup": "comet|" + hash,
+                                    },
+                                }
+                            )
+
+                            continue
+
+                return {"streams": results}
+        else:
+            logger.info(f"No cache found for {log_name} with user configuration")
+
+        if (
+            settings.PROXY_DEBRID_STREAM
+            and settings.PROXY_DEBRID_STREAM_PASSWORD
+            == config["debridStreamProxyPassword"]
+            and config["debridApiKey"] == ""
+        ):
+            config["debridService"] = (
+                settings.PROXY_DEBRID_STREAM_DEBRID_DEFAULT_SERVICE
+            )
+            config["debridApiKey"] = settings.PROXY_DEBRID_STREAM_DEBRID_DEFAULT_APIKEY
+
+        debrid = getDebrid(session, config, get_client_ip(request))
+
+        check_premium = await debrid.check_premium()
+        if not check_premium:
+            additional_info = ""
+            if config["debridService"] == "alldebrid":
+                additional_info = "\nCheck your email!"
+
+            return {
+                "streams": [
+                    {
+                        "name": "[⚠️] Comet",
+                        "title": f"Invalid {config['debridService']} account.{additional_info}",
+                        "url": "https://comet.fast",
+                    }
+                ]
+            }
+
+        indexer_manager_type = settings.INDEXER_MANAGER_TYPE
+
+        search_indexer = len(config["indexers"]) != 0
+        torrents = []
+        tasks = []
+        if indexer_manager_type and search_indexer:
+            logger.info(
+                f"Start of {indexer_manager_type} search for {log_name} with indexers {config['indexers']}"
+            )
+
+            search_terms = [name]
+            if type == "series":
+                if not kitsu:
+                    search_terms.append(f"{name} S0{season}E0{episode}")
+                else:
+                    search_terms.append(f"{name} {episode}")
+            tasks.extend(
+                get_indexer_manager(
+                    session, indexer_manager_type, config["indexers"], term
+                )
+                for term in search_terms
+            )
+        else:
+            logger.info(
+                f"No indexer {'manager ' if not indexer_manager_type else ''}{'selected by user' if indexer_manager_type else 'defined'} for {log_name}"
+            )
+
+        if settings.ZILEAN_URL:
+            tasks.append(get_zilean(session, name, log_name, season, episode))
+
+        if settings.SCRAPE_TORRENTIO:
+            tasks.append(get_torrentio(log_name, type, full_id))
+
+        search_response = await asyncio.gather(*tasks)
+        for results in search_response:
+            for result in results:
+                torrents.append(result)
+
+        logger.info(
+            f"{len(torrents)} torrents found for {log_name}"
+            + (
+                " with "
+                + ", ".join(
+                    part
+                    for part in [
+                        indexer_manager_type,
+                        "Zilean" if settings.ZILEAN_URL else None,
+                        "Torrentio" if settings.SCRAPE_TORRENTIO else None,
+                    ]
+                    if part
+                )
+                if any(
+                    [
+                        indexer_manager_type,
+                        settings.ZILEAN_URL,
+                        settings.SCRAPE_TORRENTIO,
+                    ]
+                )
+                else ""
+            )
+        )
+
+        if len(torrents) == 0:
+            return {"streams": []}
+
+        if settings.TITLE_MATCH_CHECK:
+            indexed_torrents = [(i, torrents[i]["Title"]) for i in range(len(torrents))]
+            chunk_size = 50
+            chunks = [
+                indexed_torrents[i : i + chunk_size]
+                for i in range(0, len(indexed_torrents), chunk_size)
+            ]
+
+            tasks = []
+            for chunk in chunks:
+                tasks.append(filter(chunk, name, year))
+
+            filtered_torrents = await asyncio.gather(*tasks)
+            index_less = 0
+            for result in filtered_torrents:
+                for filtered in result:
+                    if not filtered[1]:
+                        del torrents[filtered[0] - index_less]
+                        index_less += 1
+                        continue
+
+            logger.info(
+                f"{len(torrents)} torrents passed title match check for {log_name}"
+            )
+
+            if len(torrents) == 0:
+                return {"streams": []}
+
+        tasks = []
+        for i in range(len(torrents)):
+            tasks.append(get_torrent_hash(session, (i, torrents[i])))
+
+        torrent_hashes = await asyncio.gather(*tasks)
+        index_less = 0
+        for hash in torrent_hashes:
+            if not hash[1]:
+                del torrents[hash[0] - index_less]
+                index_less += 1
+                continue
+
+            torrents[hash[0] - index_less]["InfoHash"] = hash[1]
+
+        logger.info(f"{len(torrents)} info hashes found for {log_name}")
+
+        if len(torrents) == 0:
+            return {"streams": []}
+
+        files = await debrid.get_files(
+            [hash[1] for hash in torrent_hashes if hash[1] is not None],
+            type,
+            season,
+            episode,
+            kitsu,
+        )
+
+        ranked_files = set()
+        for hash in files:
+            try:
+                ranked_file = rtn.rank(
+                    files[hash]["title"],
+                    hash,  # , correct_title=name, remove_trash=True
+                )
+
+                ranked_files.add(ranked_file)
+            except:
+                pass
+
+        sorted_ranked_files = sort_torrents(ranked_files)
+
+        len_sorted_ranked_files = len(sorted_ranked_files)
+        logger.info(
+            f"{len_sorted_ranked_files} cached files found on {config['debridService']} for {log_name}"
+        )
+
+        if len_sorted_ranked_files == 0:
+            return {"streams": []}
+
+        sorted_ranked_files = {
+            key: (value.model_dump() if isinstance(value, Torrent) else value)
+            for key, value in sorted_ranked_files.items()
+        }
+        torrents_by_hash = {torrent["InfoHash"]: torrent for torrent in torrents}
+        for hash in sorted_ranked_files:  # needed for caching
+            sorted_ranked_files[hash]["data"]["title"] = files[hash]["title"]
+            sorted_ranked_files[hash]["data"]["torrent_title"] = torrents_by_hash[hash][
+                "Title"
+            ]
+            sorted_ranked_files[hash]["data"]["tracker"] = torrents_by_hash[hash][
+                "Tracker"
+            ]
+            sorted_ranked_files[hash]["data"]["size"] = files[hash]["size"]
+            torrent_size = torrents_by_hash[hash]["Size"]
+            sorted_ranked_files[hash]["data"]["torrent_size"] = (
+                torrent_size if torrent_size else files[hash]["size"]
+            )
+            sorted_ranked_files[hash]["data"]["index"] = files[hash]["index"]
+
+        json_data = json.dumps(sorted_ranked_files).replace("'", "''")
+        await database.execute(
+            f"INSERT {'OR IGNORE ' if settings.DATABASE_TYPE == 'sqlite' else ''}INTO cache (cacheKey, results, timestamp) VALUES (:cache_key, :json_data, :timestamp){' ON CONFLICT DO NOTHING' if settings.DATABASE_TYPE == 'postgresql' else ''}",
+            {"cache_key": cache_key, "json_data": json_data, "timestamp": time.time()},
+        )
+        logger.info(f"Results have been cached for {log_name}")
+
+        debrid_extension = get_debrid_extension(config["debridService"])
+
+        balanced_hashes = get_balanced_hashes(sorted_ranked_files, config)
+
+        results = []
+        if (
+            config["debridStreamProxyPassword"] != ""
+            and settings.PROXY_DEBRID_STREAM
+            and settings.PROXY_DEBRID_STREAM_PASSWORD
+            != config["debridStreamProxyPassword"]
+        ):
+            results.append(
+                {
+                    "name": "[⚠️] Comet",
+                    "title": "Debrid Stream Proxy Password incorrect.\nStreams will not be proxied.",
+                    "url": "https://comet.fast",
+                }
+            )
+
+        for hash, hash_data in sorted_ranked_files.items():
+            for resolution, hash_list in balanced_hashes.items():
+                if hash in hash_list:
+                    data = hash_data["data"]
+                    results.append(
+                        {
+                            "name": f"[{debrid_extension}⚡] Comet {data['resolution']}",
+                            "title": format_title(data, config),
+                            "torrentTitle": data["torrent_title"],
+                            "torrentSize": data["torrent_size"],
+                            "url": f"{request.url.scheme}://{request.url.netloc}/{b64config}/playback/{hash}/{data['index']}",
+                            "behaviorHints": {
+                                "filename": data["raw_title"],
+                                "bingeGroup": "comet|" + hash,
+                            },
+                        }
+                    )
+
+                    continue
+
+        return {"streams": results}
+
+
+@streams.head("/{b64config}/playback/{hash}/{index}")
+async def playback(b64config: str, hash: str, index: str):
+    return RedirectResponse("https://stremio.fast", status_code=302)
+
+
+class CustomORJSONResponse(Response):
+    media_type = "application/json"
+
+    def render(self, content) -> bytes:
+        assert orjson is not None, "orjson must be installed"
+        return orjson.dumps(content, option=orjson.OPT_INDENT_2)
+
+
+@streams.get("/active-connections", response_class=CustomORJSONResponse)
+async def active_connections(request: Request, password: str):
+    if password != settings.DASHBOARD_ADMIN_PASSWORD:
+        return "Invalid Password"
+
+    active_connections = await database.fetch_all("SELECT * FROM active_connections")
+
+    return {
+        "total_connections": len(active_connections),
+        "active_connections": active_connections,
+    }
+
+
+@streams.get("/{b64config}/playback/{hash}/{index}")
+async def playback(request: Request, b64config: str, hash: str, index: str):
+    config = config_check(b64config)
+    if not config:
+        return FileResponse("comet/assets/invalidconfig.mp4")
+
+    if (
+        settings.PROXY_DEBRID_STREAM
+        and settings.PROXY_DEBRID_STREAM_PASSWORD == config["debridStreamProxyPassword"]
+        and config["debridApiKey"] == ""
+    ):
+        config["debridService"] = settings.PROXY_DEBRID_STREAM_DEBRID_DEFAULT_SERVICE
+        config["debridApiKey"] = settings.PROXY_DEBRID_STREAM_DEBRID_DEFAULT_APIKEY
+
+    async with aiohttp.ClientSession() as session:
+        # Check for cached download link
+        cached_link = await database.fetch_one(
+            f"SELECT link, timestamp FROM download_links WHERE debrid_key = '{config['debridApiKey']}' AND hash = '{hash}' AND file_index = '{index}'"
+        )
+
+        current_time = time.time()
+        download_link = None
+        if cached_link:
+            link = cached_link["link"]
+            timestamp = cached_link["timestamp"]
+
+            if current_time - timestamp < 3600:
+                download_link = link
+            else:
+                # Cache expired, remove old entry
+                await database.execute(
+                    f"DELETE FROM download_links WHERE debrid_key = '{config['debridApiKey']}' AND hash = '{hash}' AND file_index = '{index}'"
+                )
+
+        ip = get_client_ip(request)
+        if not download_link:
+            debrid = getDebrid(session, config, ip)
+            download_link = await debrid.generate_download_link(hash, index)
+            if not download_link:
+                return FileResponse("comet/assets/uncached.mp4")
+
+            # Cache the new download link
+            await database.execute(
+                f"INSERT {'OR IGNORE ' if settings.DATABASE_TYPE == 'sqlite' else ''}INTO download_links (debrid_key, hash, file_index, link, timestamp) VALUES (:debrid_key, :hash, :file_index, :link, :timestamp){' ON CONFLICT DO NOTHING' if settings.DATABASE_TYPE == 'postgresql' else ''}",
+                {
+                    "debrid_key": config["debridApiKey"],
+                    "hash": hash,
+                    "file_index": index,
+                    "link": download_link,
+                    "timestamp": current_time,
+                },
+            )
+
+        if (
+            settings.PROXY_DEBRID_STREAM
+            and settings.PROXY_DEBRID_STREAM_PASSWORD
+            == config["debridStreamProxyPassword"]
+        ):
+            active_ip_connections = await database.fetch_all(
+                "SELECT ip, COUNT(*) as connections FROM active_connections GROUP BY ip"
+            )
+            if any(
+                connection["ip"] == ip
+                and connection["connections"]
+                >= settings.PROXY_DEBRID_STREAM_MAX_CONNECTIONS
+                for connection in active_ip_connections
+            ):
+                return FileResponse("comet/assets/proxylimit.mp4")
+
+            proxy = None
+
+            class Streamer:
+                def __init__(self, id: str):
+                    self.id = id
+
+                    self.client = httpx.AsyncClient(proxy=proxy)
+                    self.response = None
+
+                async def stream_content(self, headers: dict):
+                    async with self.client.stream(
+                        "GET", download_link, headers=headers
+                    ) as self.response:
+                        async for chunk in self.response.aiter_raw():
+                            yield chunk
+
+                async def close(self):
+                    await database.execute(
+                        f"DELETE FROM active_connections WHERE id = '{self.id}'"
+                    )
+
+                    if self.response is not None:
+                        await self.response.aclose()
+                    if self.client is not None:
+                        await self.client.aclose()
+
+            range_header = request.headers.get("range", "bytes=0-")
+
+            response = await session.head(
+                download_link, headers={"Range": range_header}
+            )
+            if response.status == 503 and config["debridService"] == "alldebrid":
+                proxy = (
+                    settings.DEBRID_PROXY_URL
+                )  # proxy is not needed to proxy realdebrid stream
+
+                response = await session.head(
+                    download_link, headers={"Range": range_header}, proxy=proxy
+                )
+
+            if response.status == 206:
+                id = str(uuid.uuid4())
+                await database.execute(
+                    f"INSERT  {'OR IGNORE ' if settings.DATABASE_TYPE == 'sqlite' else ''}INTO active_connections (id, ip, content, timestamp) VALUES (:id, :ip, :content, :timestamp){' ON CONFLICT DO NOTHING' if settings.DATABASE_TYPE == 'postgresql' else ''}",
+                    {
+                        "id": id,
+                        "ip": ip,
+                        "content": str(response.url),
+                        "timestamp": current_time,
+                    },
+                )
+
+                streamer = Streamer(id)
+
+                return StreamingResponse(
+                    streamer.stream_content({"Range": range_header}),
+                    status_code=206,
+                    headers={
+                        "Content-Range": response.headers["Content-Range"],
+                        "Content-Length": response.headers["Content-Length"],
+                        "Accept-Ranges": "bytes",
+                    },
+                    background=BackgroundTask(streamer.close),
+                )
+
+            return FileResponse("comet/assets/uncached.mp4")
+
+        return RedirectResponse(download_link, status_code=302)

comet/debrid/alldebrid.py

@@ -0,0 +1,172 @@
+import aiohttp
+import asyncio
+
+from RTN import parse
+
+from comet.utils.general import is_video
+from comet.utils.logger import logger
+from comet.utils.models import settings
+
+
+class AllDebrid:
+    def __init__(self, session: aiohttp.ClientSession, debrid_api_key: str):
+        session.headers["Authorization"] = f"Bearer {debrid_api_key}"
+        self.session = session
+        self.proxy = None
+
+        self.api_url = "http://api.alldebrid.com/v4"
+        self.agent = "comet"
+
+    async def check_premium(self):
+        try:
+            check_premium = await self.session.get(
+                f"{self.api_url}/user?agent={self.agent}"
+            )
+            check_premium = await check_premium.text()
+            if '"isPremium":true' in check_premium:
+                return True
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking premium status on All-Debrid: {e}"
+            )
+
+        return False
+
+    async def get_instant(self, chunk: list):
+        try:
+            get_instant = await self.session.get(
+                f"{self.api_url}/magnet/instant?agent={self.agent}&magnets[]={'&magnets[]='.join(chunk)}"
+            )
+            return await get_instant.json()
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking hashes instant availability on All-Debrid: {e}"
+            )
+
+    async def get_files(
+        self, torrent_hashes: list, type: str, season: str, episode: str, kitsu: bool
+    ):
+        chunk_size = 500
+        chunks = [
+            torrent_hashes[i : i + chunk_size]
+            for i in range(0, len(torrent_hashes), chunk_size)
+        ]
+
+        tasks = []
+        for chunk in chunks:
+            tasks.append(self.get_instant(chunk))
+
+        responses = await asyncio.gather(*tasks)
+
+        availability = [response for response in responses if response]
+
+        files = {}
+
+        if type == "series":
+            for result in availability:
+                if "status" not in result or result["status"] != "success":
+                    continue
+
+                for magnet in result["data"]["magnets"]:
+                    if not magnet["instant"]:
+                        continue
+
+                    for file in magnet["files"]:
+                        filename = file["n"]
+                        pack = False
+                        if "e" in file:  # PACK
+                            filename = file["e"][0]["n"]
+                            pack = True
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        filename_parsed = parse(filename)
+                        if episode not in filename_parsed.episodes:
+                            continue
+
+                        if kitsu:
+                            if filename_parsed.seasons:
+                                continue
+                        else:
+                            if season not in filename_parsed.seasons:
+                                continue
+
+                        files[magnet["hash"]] = {
+                            "index": magnet["files"].index(file),
+                            "title": filename,
+                            "size": file["e"][0]["s"] if pack else file["s"],
+                        }
+
+                        break
+        else:
+            for result in availability:
+                if "status" not in result or result["status"] != "success":
+                    continue
+
+                for magnet in result["data"]["magnets"]:
+                    if not magnet["instant"]:
+                        continue
+
+                    for file in magnet["files"]:
+                        filename = file["n"]
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        files[magnet["hash"]] = {
+                            "index": magnet["files"].index(file),
+                            "title": filename,
+                            "size": file["s"],
+                        }
+
+                        break
+
+        return files
+
+    async def generate_download_link(self, hash: str, index: str):
+        try:
+            check_blacklisted = await self.session.get(
+                f"{self.api_url}/magnet/upload?agent=comet&magnets[]={hash}"
+            )
+            check_blacklisted = await check_blacklisted.text()
+            if "NO_SERVER" in check_blacklisted:
+                self.proxy = settings.DEBRID_PROXY_URL
+                if not self.proxy:
+                    logger.warning(
+                        "All-Debrid blacklisted server's IP. No proxy found."
+                    )
+                else:
+                    logger.warning(
+                        f"All-Debrid blacklisted server's IP. Switching to proxy {self.proxy} for {hash}|{index}"
+                    )
+
+            upload_magnet = await self.session.get(
+                f"{self.api_url}/magnet/upload?agent=comet&magnets[]={hash}",
+                proxy=self.proxy,
+            )
+            upload_magnet = await upload_magnet.json()
+
+            get_magnet_status = await self.session.get(
+                f"{self.api_url}/magnet/status?agent=comet&id={upload_magnet['data']['magnets'][0]['id']}",
+                proxy=self.proxy,
+            )
+            get_magnet_status = await get_magnet_status.json()
+
+            unlock_link = await self.session.get(
+                f"{self.api_url}/link/unlock?agent=comet&link={get_magnet_status['data']['magnets']['links'][int(index)]['link']}",
+                proxy=self.proxy,
+            )
+            unlock_link = await unlock_link.json()
+
+            return unlock_link["data"]["link"]
+        except Exception as e:
+            logger.warning(
+                f"Exception while getting download link from All-Debrid for {hash}|{index}: {e}"
+            )

comet/debrid/debridlink.py

@@ -0,0 +1,126 @@
+import aiohttp
+import asyncio
+
+from RTN import parse
+
+from comet.utils.general import is_video
+from comet.utils.logger import logger
+
+
+class DebridLink:
+    def __init__(self, session: aiohttp.ClientSession, debrid_api_key: str):
+        session.headers["Authorization"] = f"Bearer {debrid_api_key}"
+        self.session = session
+        self.proxy = None
+
+        self.api_url = "https://debrid-link.com/api/v2"
+
+    async def check_premium(self):
+        try:
+            check_premium = await self.session.get(f"{self.api_url}/account/infos")
+            check_premium = await check_premium.text()
+            if '"accountType":1' in check_premium:
+                return True
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking premium status on Debrid-Link: {e}"
+            )
+
+        return False
+
+    async def get_instant(self, chunk: list):
+        try:
+            get_instant = await self.session.get(
+                f"{self.api_url}/seedbox/cached?url={','.join(chunk)}"
+            )
+            return await get_instant.json()
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking hashes instant availability on Debrid-Link: {e}"
+            )
+
+    async def get_files(
+        self, torrent_hashes: list, type: str, season: str, episode: str, kitsu: bool
+    ):
+        chunk_size = 250
+        chunks = [
+            torrent_hashes[i : i + chunk_size]
+            for i in range(0, len(torrent_hashes), chunk_size)
+        ]
+
+        tasks = []
+        for chunk in chunks:
+            tasks.append(self.get_instant(chunk))
+
+        responses = await asyncio.gather(*tasks)
+
+        availability = [
+            response for response in responses if response and response.get("success")
+        ]
+
+        files = {}
+
+        if type == "series":
+            for result in availability:
+                for hash, torrent_data in result["value"].items():
+                    for file in torrent_data["files"]:
+                        filename = file["name"]
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        filename_parsed = parse(filename)
+                        if episode not in filename_parsed.episodes:
+                            continue
+
+                        if kitsu:
+                            if filename_parsed.seasons:
+                                continue
+                        else:
+                            if season not in filename_parsed.seasons:
+                                continue
+
+                        files[hash] = {
+                            "index": torrent_data["files"].index(file),
+                            "title": filename,
+                            "size": file["size"],
+                        }
+
+                        break
+        else:
+            for result in availability:
+                for hash, torrent_data in result["value"].items():
+                    for file in torrent_data["files"]:
+                        filename = file["name"]
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        files[hash] = {
+                            "index": torrent_data["files"].index(file),
+                            "title": filename,
+                            "size": file["size"],
+                        }
+
+                        break
+
+        return files
+
+    async def generate_download_link(self, hash: str, index: str):
+        try:
+            add_torrent = await self.session.post(
+                f"{self.api_url}/seedbox/add", data={"url": hash, "async": True}
+            )
+            add_torrent = await add_torrent.json()
+
+            return add_torrent["value"]["files"][int(index)]["downloadUrl"]
+        except Exception as e:
+            logger.warning(
+                f"Exception while getting download link from Debrid-Link for {hash}|{index}: {e}"
+            )

comet/debrid/manager.py

@@ -0,0 +1,22 @@
+import aiohttp
+
+from .realdebrid import RealDebrid
+from .alldebrid import AllDebrid
+from .premiumize import Premiumize
+from .torbox import TorBox
+from .debridlink import DebridLink
+
+
+def getDebrid(session: aiohttp.ClientSession, config: dict, ip: str):
+    debrid_service = config["debridService"]
+    debrid_api_key = config["debridApiKey"]
+    if debrid_service == "realdebrid":
+        return RealDebrid(session, debrid_api_key, ip)
+    elif debrid_service == "alldebrid":
+        return AllDebrid(session, debrid_api_key)
+    elif debrid_service == "premiumize":
+        return Premiumize(session, debrid_api_key)
+    elif debrid_service == "torbox":
+        return TorBox(session, debrid_api_key)
+    elif debrid_service == "debridlink":
+        return DebridLink(session, debrid_api_key)

comet/debrid/premiumize.py

@@ -0,0 +1,177 @@
+import aiohttp
+import asyncio
+
+from RTN import parse
+
+from comet.utils.general import is_video
+from comet.utils.logger import logger
+
+
+class Premiumize:
+    def __init__(self, session: aiohttp.ClientSession, debrid_api_key: str):
+        self.session = session
+        self.proxy = None
+
+        self.api_url = "https://premiumize.me/api"
+        self.debrid_api_key = debrid_api_key
+
+    async def check_premium(self):
+        try:
+            check_premium = await self.session.get(
+                f"{self.api_url}/account/info?apikey={self.debrid_api_key}"
+            )
+            check_premium = await check_premium.text()
+            if (
+                '"status":"success"' in check_premium
+                and '"premium_until":null' not in check_premium
+            ):
+                return True
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking premium status on Premiumize: {e}"
+            )
+
+        return False
+
+    async def get_instant(self, chunk: list):
+        try:
+            response = await self.session.get(
+                f"{self.api_url}/cache/check?apikey={self.debrid_api_key}&items[]={'&items[]='.join(chunk)}"
+            )
+
+            response = await response.json()
+            response["hashes"] = chunk
+
+            return response
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking hash instant availability on Premiumize: {e}"
+            )
+
+    async def get_files(
+        self, torrent_hashes: list, type: str, season: str, episode: str, kitsu: bool
+    ):
+        chunk_size = 100
+        chunks = [
+            torrent_hashes[i : i + chunk_size]
+            for i in range(0, len(torrent_hashes), chunk_size)
+        ]
+
+        tasks = []
+        for chunk in chunks:
+            tasks.append(self.get_instant(chunk))
+
+        responses = await asyncio.gather(*tasks)
+
+        availability = []
+        for response in responses:
+            if not response:
+                continue
+
+            availability.append(response)
+
+        files = {}
+
+        if type == "series":
+            for result in availability:
+                if result["status"] != "success":
+                    continue
+
+                responses = result["response"]
+                filenames = result["filename"]
+                filesizes = result["filesize"]
+                hashes = result["hashes"]
+                for index, response in enumerate(responses):
+                    if not response:
+                        continue
+
+                    if not filesizes[index]:
+                        continue
+
+                    filename = filenames[index]
+
+                    if "sample" in filename:
+                        continue
+
+                    filename_parsed = parse(filename)
+                    if episode not in filename_parsed.episodes:
+                        continue
+
+                    if kitsu:
+                        if filename_parsed.seasons:
+                            continue
+                    else:
+                        if season not in filename_parsed.seasons:
+                            continue
+
+                    files[hashes[index]] = {
+                        "index": f"{season}|{episode}",
+                        "title": filename,
+                        "size": int(filesizes[index]),
+                    }
+        else:
+            for result in availability:
+                if result["status"] != "success":
+                    continue
+
+                responses = result["response"]
+                filenames = result["filename"]
+                filesizes = result["filesize"]
+                hashes = result["hashes"]
+                for index, response in enumerate(responses):
+                    if response is False:
+                        continue
+
+                    if not filesizes[index]:
+                        continue
+
+                    filename = filenames[index]
+
+                    if "sample" in filename:
+                        continue
+
+                    files[hashes[index]] = {
+                        "index": 0,
+                        "title": filename,
+                        "size": int(filesizes[index]),
+                    }
+
+        return files
+
+    async def generate_download_link(self, hash: str, index: str):
+        try:
+            add_magnet = await self.session.post(
+                f"{self.api_url}/transfer/directdl?apikey={self.debrid_api_key}&src=magnet:?xt=urn:btih:{hash}",
+            )
+            add_magnet = await add_magnet.json()
+
+            season = None
+            if "|" in index:
+                index = index.split("|")
+                season = int(index[0])
+                episode = int(index[1])
+
+            content = add_magnet["content"]
+            for file in content:
+                filename = file["path"]
+                if "/" in filename:
+                    filename = filename.split("/")[1]
+
+                if not is_video(filename):
+                    content.remove(file)
+                    continue
+
+                if season is not None:
+                    filename_parsed = parse(filename)
+                    if (
+                        season in filename_parsed.seasons
+                        and episode in filename_parsed.episodes
+                    ):
+                        return file["link"]
+
+            max_size_item = max(content, key=lambda x: x["size"])
+            return max_size_item["link"]
+        except Exception as e:
+            logger.warning(
+                f"Exception while getting download link from Premiumize for {hash}|{index}: {e}"
+            )

comet/debrid/realdebrid.py

@@ -0,0 +1,192 @@
+import aiohttp
+import asyncio
+
+from RTN import parse
+
+from comet.utils.general import is_video
+from comet.utils.logger import logger
+from comet.utils.models import settings
+
+
+class RealDebrid:
+    def __init__(self, session: aiohttp.ClientSession, debrid_api_key: str, ip: str):
+        session.headers["Authorization"] = f"Bearer {debrid_api_key}"
+        self.session = session
+        self.ip = ip
+        self.proxy = None
+
+        self.api_url = "https://api.real-debrid.com/rest/1.0"
+
+    async def check_premium(self):
+        try:
+            check_premium = await self.session.get(f"{self.api_url}/user")
+            check_premium = await check_premium.text()
+            if '"type": "premium"' in check_premium:
+                return True
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking premium status on Real-Debrid: {e}"
+            )
+
+        return False
+
+    async def get_instant(self, chunk: list):
+        try:
+            response = await self.session.get(
+                f"{self.api_url}/torrents/instantAvailability/{'/'.join(chunk)}"
+            )
+            return await response.json()
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking hash instant availability on Real-Debrid: {e}"
+            )
+
+    async def get_files(
+        self, torrent_hashes: list, type: str, season: str, episode: str, kitsu: bool
+    ):
+        chunk_size = 50
+        chunks = [
+            torrent_hashes[i : i + chunk_size]
+            for i in range(0, len(torrent_hashes), chunk_size)
+        ]
+
+        tasks = []
+        for chunk in chunks:
+            tasks.append(self.get_instant(chunk))
+
+        responses = await asyncio.gather(*tasks)
+
+        availability = {}
+        for response in responses:
+            if response is not None:
+                availability.update(response)
+
+        files = {}
+
+        if type == "series":
+            for hash, details in availability.items():
+                if "rd" not in details:
+                    continue
+
+                for variants in details["rd"]:
+                    for index, file in variants.items():
+                        filename = file["filename"]
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        filename_parsed = parse(filename)
+                        if episode not in filename_parsed.episodes:
+                            continue
+
+                        if kitsu:
+                            if filename_parsed.seasons:
+                                continue
+                        else:
+                            if season not in filename_parsed.seasons:
+                                continue
+
+                        files[hash] = {
+                            "index": index,
+                            "title": filename,
+                            "size": file["filesize"],
+                        }
+
+                        break
+        else:
+            for hash, details in availability.items():
+                if "rd" not in details:
+                    continue
+
+                for variants in details["rd"]:
+                    for index, file in variants.items():
+                        filename = file["filename"]
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        files[hash] = {
+                            "index": index,
+                            "title": filename,
+                            "size": file["filesize"],
+                        }
+
+                        break
+
+        return files
+
+    async def generate_download_link(self, hash: str, index: str):
+        try:
+            check_blacklisted = await self.session.get("https://real-debrid.com/vpn")
+            check_blacklisted = await check_blacklisted.text()
+            if (
+                "Your ISP or VPN provider IP address is currently blocked on our website"
+                in check_blacklisted
+            ):
+                self.proxy = settings.DEBRID_PROXY_URL
+                if not self.proxy:
+                    logger.warning(
+                        "Real-Debrid blacklisted server's IP. No proxy found."
+                    )
+                else:
+                    logger.warning(
+                        f"Real-Debrid blacklisted server's IP. Switching to proxy {self.proxy} for {hash}|{index}"
+                    )
+
+            add_magnet = await self.session.post(
+                f"{self.api_url}/torrents/addMagnet",
+                data={"magnet": f"magnet:?xt=urn:btih:{hash}", "ip": self.ip},
+                proxy=self.proxy,
+            )
+            add_magnet = await add_magnet.json()
+
+            get_magnet_info = await self.session.get(
+                add_magnet["uri"], proxy=self.proxy
+            )
+            get_magnet_info = await get_magnet_info.json()
+
+            await self.session.post(
+                f"{self.api_url}/torrents/selectFiles/{add_magnet['id']}",
+                data={
+                    "files": ",".join(
+                        str(file["id"])
+                        for file in get_magnet_info["files"]
+                        if is_video(file["path"])
+                    ),
+                    "ip": self.ip,
+                },
+                proxy=self.proxy,
+            )
+
+            get_magnet_info = await self.session.get(
+                add_magnet["uri"], proxy=self.proxy
+            )
+            get_magnet_info = await get_magnet_info.json()
+
+            index = int(index)
+            realIndex = index
+            for file in get_magnet_info["files"]:
+                if file["id"] == realIndex:
+                    break
+
+                if file["selected"] != 1:
+                    index -= 1
+
+            unrestrict_link = await self.session.post(
+                f"{self.api_url}/unrestrict/link",
+                data={"link": get_magnet_info["links"][index - 1], "ip": self.ip},
+                proxy=self.proxy,
+            )
+            unrestrict_link = await unrestrict_link.json()
+
+            return unrestrict_link["download"]
+        except Exception as e:
+            logger.warning(
+                f"Exception while getting download link from Real-Debrid for {hash}|{index}: {e}"
+            )

comet/debrid/torbox.py

@@ -0,0 +1,161 @@
+import aiohttp
+import asyncio
+
+from RTN import parse
+
+from comet.utils.general import is_video
+from comet.utils.logger import logger
+
+
+class TorBox:
+    def __init__(self, session: aiohttp.ClientSession, debrid_api_key: str):
+        session.headers["Authorization"] = f"Bearer {debrid_api_key}"
+        self.session = session
+        self.proxy = None
+
+        self.api_url = "https://api.torbox.app/v1/api"
+        self.debrid_api_key = debrid_api_key
+
+    async def check_premium(self):
+        try:
+            check_premium = await self.session.get(
+                f"{self.api_url}/user/me?settings=false"
+            )
+            check_premium = await check_premium.text()
+            if '"success":true' in check_premium and '"plan":0' not in check_premium:
+                return True
+        except Exception as e:
+            logger.warning(f"Exception while checking premium status on TorBox: {e}")
+
+        return False
+
+    async def get_instant(self, chunk: list):
+        try:
+            response = await self.session.get(
+                f"{self.api_url}/torrents/checkcached?hash={','.join(chunk)}&format=list&list_files=true"
+            )
+            return await response.json()
+        except Exception as e:
+            logger.warning(
+                f"Exception while checking hash instant availability on TorBox: {e}"
+            )
+
+    async def get_files(
+        self, torrent_hashes: list, type: str, season: str, episode: str, kitsu: bool
+    ):
+        chunk_size = 100
+        chunks = [
+            torrent_hashes[i : i + chunk_size]
+            for i in range(0, len(torrent_hashes), chunk_size)
+        ]
+
+        tasks = []
+        for chunk in chunks:
+            tasks.append(self.get_instant(chunk))
+
+        responses = await asyncio.gather(*tasks)
+
+        availability = [response for response in responses if response is not None]
+
+        files = {}
+
+        if type == "series":
+            for result in availability:
+                if not result["success"] or not result["data"]:
+                    continue
+
+                for torrent in result["data"]:
+                    torrent_files = torrent["files"]
+                    for file in torrent_files:
+                        filename = file["name"].split("/")[1]
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        filename_parsed = parse(filename)
+                        if episode not in filename_parsed.episodes:
+                            continue
+
+                        if kitsu:
+                            if filename_parsed.seasons:
+                                continue
+                        else:
+                            if season not in filename_parsed.seasons:
+                                continue
+
+                        files[torrent["hash"]] = {
+                            "index": torrent_files.index(file),
+                            "title": filename,
+                            "size": file["size"],
+                        }
+
+                        break
+        else:
+            for result in availability:
+                if not result["success"] or not result["data"]:
+                    continue
+
+                for torrent in result["data"]:
+                    torrent_files = torrent["files"]
+                    for file in torrent_files:
+                        filename = file["name"].split("/")[1]
+
+                        if not is_video(filename):
+                            continue
+
+                        if "sample" in filename:
+                            continue
+
+                        files[torrent["hash"]] = {
+                            "index": torrent_files.index(file),
+                            "title": filename,
+                            "size": file["size"],
+                        }
+
+                        break
+
+        return files
+
+    async def generate_download_link(self, hash: str, index: str):
+        try:
+            get_torrents = await self.session.get(
+                f"{self.api_url}/torrents/mylist?bypass_cache=true"
+            )
+            get_torrents = await get_torrents.json()
+            exists = False
+            for torrent in get_torrents["data"]:
+                if torrent["hash"] == hash:
+                    torrent_id = torrent["id"]
+                    exists = True
+                    break
+            if not exists:
+                create_torrent = await self.session.post(
+                    f"{self.api_url}/torrents/createtorrent",
+                    data={"magnet": f"magnet:?xt=urn:btih:{hash}"},
+                )
+                create_torrent = await create_torrent.json()
+                torrent_id = create_torrent["data"]["torrent_id"]
+
+                # get_torrents = await self.session.get(
+                #     f"{self.api_url}/torrents/mylist?bypass_cache=true"
+                # )
+                # get_torrents = await get_torrents.json()
+
+            # for torrent in get_torrents["data"]:
+            #     if torrent["id"] == torrent_id:
+            #         file_id = torrent["files"][int(index)]["id"]
+            # Useless, we already have file index
+
+            get_download_link = await self.session.get(
+                f"{self.api_url}/torrents/requestdl?token={self.debrid_api_key}&torrent_id={torrent_id}&file_id={index}&zip=false",
+            )
+            get_download_link = await get_download_link.json()
+
+            return get_download_link["data"]
+        except Exception as e:
+            logger.warning(
+                f"Exception while getting download link from TorBox for {hash}|{index}: {e}"
+            )

comet/main.py

@@ -0,0 +1,165 @@
+import contextlib
+import signal
+import sys
+import threading
+import time
+import traceback
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+
+from comet.api.core import main
+from comet.api.stream import streams
+from comet.utils.db import setup_database, teardown_database
+from comet.utils.logger import logger
+from comet.utils.models import settings
+
+
+class LoguruMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        start_time = time.time()
+        try:
+            response = await call_next(request)
+        except Exception as e:
+            logger.exception(f"Exception during request processing: {e}")
+            raise
+        finally:
+            process_time = time.time() - start_time
+            logger.log(
+                "API",
+                f"{request.method} {request.url.path} - {response.status_code if 'response' in locals() else '500'} - {process_time:.2f}s",
+            )
+        return response
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await setup_database()
+    yield
+    await teardown_database()
+
+
+app = FastAPI(
+    title="Comet",
+    summary="Stremio's fastest torrent/debrid search add-on.",
+    version="1.0.0",
+    lifespan=lifespan,
+    redoc_url=None,
+)
+
+app.add_middleware(LoguruMiddleware)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/static", StaticFiles(directory="comet/templates"), name="static")
+
+app.include_router(main)
+app.include_router(streams)
+
+
+class Server(uvicorn.Server):
+    def install_signal_handlers(self):
+        pass
+
+    @contextlib.contextmanager
+    def run_in_thread(self):
+        thread = threading.Thread(target=self.run, name="Comet")
+        thread.start()
+        try:
+            while not self.started:
+                time.sleep(1e-3)
+            yield
+        except Exception as e:
+            logger.error(f"Error in server thread: {e}")
+            logger.exception(traceback.format_exc())
+            raise e
+        finally:
+            self.should_exit = True
+            sys.exit(0)
+
+
+def signal_handler(sig, frame):
+    # This will handle kubernetes/docker shutdowns better
+    # Toss anything that needs to be gracefully shutdown here
+    logger.log("COMET", "Exiting Gracefully.")
+    sys.exit(0)
+
+
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)
+
+config = uvicorn.Config(
+    app,
+    host=settings.FASTAPI_HOST,
+    port=settings.FASTAPI_PORT,
+    proxy_headers=True,
+    workers=settings.FASTAPI_WORKERS,
+    log_config=None,
+)
+server = Server(config=config)
+
+
+def start_log():
+    logger.log(
+        "COMET",
+        f"Server started on http://{settings.FASTAPI_HOST}:{settings.FASTAPI_PORT} - {settings.FASTAPI_WORKERS} workers",
+    )
+    logger.log(
+        "COMET",
+        f"Dashboard Admin Password: {settings.DASHBOARD_ADMIN_PASSWORD} -  http://{settings.FASTAPI_HOST}:{settings.FASTAPI_PORT}/active-connections?password={settings.DASHBOARD_ADMIN_PASSWORD}",
+    )
+    logger.log(
+        "COMET",
+        f"Database ({settings.DATABASE_TYPE}): {settings.DATABASE_PATH if settings.DATABASE_TYPE == 'sqlite' else settings.DATABASE_URL} - TTL: {settings.CACHE_TTL}s",
+    )
+    logger.log("COMET", f"Debrid Proxy: {settings.DEBRID_PROXY_URL}")
+
+    if settings.INDEXER_MANAGER_TYPE:
+        logger.log(
+            "COMET",
+            f"Indexer Manager: {settings.INDEXER_MANAGER_TYPE}|{settings.INDEXER_MANAGER_URL} - Timeout: {settings.INDEXER_MANAGER_TIMEOUT}s",
+        )
+        logger.log("COMET", f"Indexers: {', '.join(settings.INDEXER_MANAGER_INDEXERS)}")
+        logger.log("COMET", f"Get Torrent Timeout: {settings.GET_TORRENT_TIMEOUT}s")
+    else:
+        logger.log("COMET", "Indexer Manager: False")
+
+    if settings.ZILEAN_URL:
+        logger.log(
+            "COMET",
+            f"Zilean: {settings.ZILEAN_URL} - Take first: {settings.ZILEAN_TAKE_FIRST}",
+        )
+    else:
+        logger.log("COMET", "Zilean: False")
+
+    logger.log("COMET", f"Torrentio Scraper: {bool(settings.SCRAPE_TORRENTIO)}")
+    logger.log(
+        "COMET",
+        f"Debrid Stream Proxy: {bool(settings.PROXY_DEBRID_STREAM)} - Password: {settings.PROXY_DEBRID_STREAM_PASSWORD} - Max Connections: {settings.PROXY_DEBRID_STREAM_MAX_CONNECTIONS} - Default Debrid Service: {settings.PROXY_DEBRID_STREAM_DEBRID_DEFAULT_SERVICE} - Default Debrid API Key: {settings.PROXY_DEBRID_STREAM_DEBRID_DEFAULT_APIKEY}",
+    )
+    logger.log("COMET", f"Title Match Check: {bool(settings.TITLE_MATCH_CHECK)}")
+    logger.log("COMET", f"Custom Header HTML: {bool(settings.CUSTOM_HEADER_HTML)}")
+
+
+with server.run_in_thread():
+    start_log()
+    try:
+        while True:
+            time.sleep(1)  # Keep the main thread alive
+    except KeyboardInterrupt:
+        logger.log("COMET", "Server stopped by user")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        logger.exception(traceback.format_exc())
+    finally:
+        logger.log("COMET", "Server Shutdown")

comet/templates/index.html

@@ -0,0 +1,794 @@
+<!DOCTYPE html>
+<html class="sl-theme-dark">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+        <meta content="Comet" property="og:title" />
+        <meta content="Stremio's fastest torrent/debrid search add-on." property="og:description" />
+        <meta content="https://comet.fast" property="og:url" />
+        <meta content="https://i.imgur.com/jmVoVMu.jpeg" property="og:image" />
+        <meta content="#6b6ef8" data-react-helmet="true" name="theme-color" />
+
+        <title>Comet - Stremio's fastest torrent/debrid search add-on.</title>
+        <link id="favicon" rel="icon" type="image/x-icon" href="https://i.imgur.com/jmVoVMu.jpeg">
+
+        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@shoelace-style/shoelace@2.15.1/cdn/themes/dark.css" />
+        <script type="module" src="https://cdn.jsdelivr.net/npm/@shoelace-style/shoelace@2.15.1/cdn/shoelace-autoloader.js"></script>
+
+        <style>
+            :not(:defined) {
+                visibility: hidden;
+            }
+
+            body {
+                opacity: 0;
+                display: flex;
+                flex-direction: column;
+                justify-content: center;
+                align-items: center;
+                min-height: 100vh;
+                margin: 0;
+                background: radial-gradient(ellipse at bottom, #25292c 0%, #0c0d13 100%);
+                font-family: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", "Liberation Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+                font-size: 1rem;
+                font-weight: 400;
+            }
+
+            body.ready {
+                opacity: 1;
+                transition: 0.25s opacity;
+            }
+
+            ::-webkit-scrollbar {
+                overflow: hidden;
+            }
+
+            .header {
+                text-align: center;
+                width: 40%;
+                margin-bottom: 20px;
+            }
+
+            .comet-text {
+                font-size: calc(1.375rem + 1.5vw);
+                font-weight: 500;
+                margin-bottom: 0;
+            }
+
+            .emoji {
+                width: 1em;
+                height: 1em;
+                vertical-align: middle;
+            }
+
+            .form-container {
+                background-color: #1a1d20;
+                padding: 2rem;
+                border-radius: 0.375rem;
+                box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
+                width: 80vw;
+                max-width: 950px;
+                margin-bottom: 50px;
+            }
+
+            .form-item {
+                margin-bottom: 0.75rem;
+            }
+
+            sl-details {
+                margin-bottom: 0.75rem;
+            }
+
+            .centered-item {
+                display: flex;
+                justify-content: center;
+            }
+
+            .margin-left-install {
+                margin-right: 10px;
+            }
+
+            .stars {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 120%;
+            transform: rotate(-45deg);
+            z-index: -1;
+            }
+            .star {
+            --star-color: var(--primary-color);
+            --star-tail-length: 6em;
+            --star-tail-height: 2px;
+            --star-width: calc(var(--star-tail-length) / 6);
+            --fall-duration: 9s;
+            --tail-fade-duration: var(--fall-duration);
+            position: absolute;
+            top: var(--top-offset);
+            left: 0;
+            width: var(--star-tail-length);
+            height: var(--star-tail-height);
+            color: var(--star-color);
+            background: linear-gradient(45deg, currentColor, transparent);
+            border-radius: 50%;
+            filter: drop-shadow(0 0 6px currentColor);
+            transform: translate3d(104em, 0, 0);
+            animation: fall var(--fall-duration) var(--fall-delay) linear infinite, tail-fade var(--tail-fade-duration) var(--fall-delay) ease-out infinite;
+            }
+            @media screen and (max-width: 750px) {
+            .star {
+                animation: fall var(--fall-duration) var(--fall-delay) linear infinite;
+            }
+            }
+            .star:nth-child(1) {
+            --star-tail-length: 6.14em;
+            --top-offset: 3.64vh;
+            --fall-duration: 10.878s;
+            --fall-delay: 0.034s;
+            }
+            .star:nth-child(2) {
+            --star-tail-length: 5.08em;
+            --top-offset: 69.69vh;
+            --fall-duration: 11.372s;
+            --fall-delay: 1.679s;
+            }
+            .star:nth-child(3) {
+            --star-tail-length: 6.1em;
+            --top-offset: 64.3vh;
+            --fall-duration: 7.088s;
+            --fall-delay: 3.382s;
+            }
+            .star:nth-child(4) {
+            --star-tail-length: 6.66em;
+            --top-offset: 34.91vh;
+            --fall-duration: 6.184s;
+            --fall-delay: 9.61s;
+            }
+            .star:nth-child(5) {
+            --star-tail-length: 6.89em;
+            --top-offset: 24.92vh;
+            --fall-duration: 9.465s;
+            --fall-delay: 9.12s;
+            }
+            .star:nth-child(6) {
+            --star-tail-length: 6.5em;
+            --top-offset: 51.9vh;
+            --fall-duration: 10.52s;
+            --fall-delay: 0.214s;
+            }
+            .star:nth-child(7) {
+            --star-tail-length: 5.58em;
+            --top-offset: 24.15vh;
+            --fall-duration: 8.9s;
+            --fall-delay: 0.499s;
+            }
+            .star:nth-child(8) {
+            --star-tail-length: 6.26em;
+            --top-offset: 59.4vh;
+            --fall-duration: 7.671s;
+            --fall-delay: 1.694s;
+            }
+            .star:nth-child(9) {
+            --star-tail-length: 6.46em;
+            --top-offset: 54.52vh;
+            --fall-duration: 6.484s;
+            --fall-delay: 4.616s;
+            }
+            .star:nth-child(10) {
+            --star-tail-length: 5.34em;
+            --top-offset: 74.03vh;
+            --fall-duration: 8.565s;
+            --fall-delay: 1.159s;
+            }
+            .star:nth-child(11) {
+            --star-tail-length: 6.84em;
+            --top-offset: 90.94vh;
+            --fall-duration: 10.133s;
+            --fall-delay: 6.108s;
+            }
+            .star:nth-child(12) {
+            --star-tail-length: 5.48em;
+            --top-offset: 97.27vh;
+            --fall-duration: 10.248s;
+            --fall-delay: 4.186s;
+            }
+            .star:nth-child(13) {
+            --star-tail-length: 7.21em;
+            --top-offset: 17.75vh;
+            --fall-duration: 10.549s;
+            --fall-delay: 1.868s;
+            }
+            .star:nth-child(14) {
+            --star-tail-length: 6.35em;
+            --top-offset: 94.98vh;
+            --fall-duration: 9.682s;
+            --fall-delay: 9.327s;
+            }
+            .star:nth-child(15) {
+            --star-tail-length: 5.18em;
+            --top-offset: 52.87vh;
+            --fall-duration: 9.934s;
+            --fall-delay: 8.919s;
+            }
+            .star:nth-child(16) {
+            --star-tail-length: 5.07em;
+            --top-offset: 50.26vh;
+            --fall-duration: 11.826s;
+            --fall-delay: 8.478s;
+            }
+            .star:nth-child(17) {
+            --star-tail-length: 7.01em;
+            --top-offset: 85.73vh;
+            --fall-duration: 9.87s;
+            --fall-delay: 1.206s;
+            }
+            .star:nth-child(18) {
+            --star-tail-length: 6.39em;
+            --top-offset: 2.81vh;
+            --fall-duration: 10.292s;
+            --fall-delay: 4.394s;
+            }
+            .star:nth-child(19) {
+            --star-tail-length: 5.27em;
+            --top-offset: 56.83vh;
+            --fall-duration: 8.944s;
+            --fall-delay: 8.779s;
+            }
+            .star:nth-child(20) {
+            --star-tail-length: 6.07em;
+            --top-offset: 54.55vh;
+            --fall-duration: 9.324s;
+            --fall-delay: 7.375s;
+            }
+            .star:nth-child(21) {
+            --star-tail-length: 6.1em;
+            --top-offset: 87.67vh;
+            --fall-duration: 11.943s;
+            --fall-delay: 6.919s;
+            }
+            .star:nth-child(22) {
+            --star-tail-length: 5.98em;
+            --top-offset: 70.04vh;
+            --fall-duration: 9.995s;
+            --fall-delay: 4.472s;
+            }
+            .star:nth-child(23) {
+            --star-tail-length: 6.34em;
+            --top-offset: 77.19vh;
+            --fall-duration: 10.073s;
+            --fall-delay: 8.354s;
+            }
+            .star:nth-child(24) {
+            --star-tail-length: 6.95em;
+            --top-offset: 14.48vh;
+            --fall-duration: 9.028s;
+            --fall-delay: 7.638s;
+            }
+            .star:nth-child(25) {
+            --star-tail-length: 6.23em;
+            --top-offset: 8.48vh;
+            --fall-duration: 7.427s;
+            --fall-delay: 0.915s;
+            }
+            .star:nth-child(26) {
+            --star-tail-length: 5.09em;
+            --top-offset: 6.56vh;
+            --fall-duration: 7.706s;
+            --fall-delay: 2.841s;
+            }
+            .star:nth-child(27) {
+            --star-tail-length: 7.01em;
+            --top-offset: 92.85vh;
+            --fall-duration: 7.359s;
+            --fall-delay: 7.229s;
+            }
+            .star:nth-child(28) {
+            --star-tail-length: 5.49em;
+            --top-offset: 27.89vh;
+            --fall-duration: 10.344s;
+            --fall-delay: 2.346s;
+            }
+            .star:nth-child(29) {
+            --star-tail-length: 5.82em;
+            --top-offset: 56.08vh;
+            --fall-duration: 10.911s;
+            --fall-delay: 4.231s;
+            }
+            .star:nth-child(30) {
+            --star-tail-length: 7.24em;
+            --top-offset: 22.54vh;
+            --fall-duration: 9.344s;
+            --fall-delay: 2.112s;
+            }
+            .star:nth-child(31) {
+            --star-tail-length: 6.8em;
+            --top-offset: 59.49vh;
+            --fall-duration: 7.059s;
+            --fall-delay: 0.924s;
+            }
+            .star:nth-child(32) {
+            --star-tail-length: 5.22em;
+            --top-offset: 44.01vh;
+            --fall-duration: 10.121s;
+            --fall-delay: 0.591s;
+            }
+            .star:nth-child(33) {
+            --star-tail-length: 6.1em;
+            --top-offset: 78.61vh;
+            --fall-duration: 8.306s;
+            --fall-delay: 4.403s;
+            }
+            .star:nth-child(34) {
+            --star-tail-length: 7.26em;
+            --top-offset: 85.76vh;
+            --fall-duration: 7.058s;
+            --fall-delay: 6.772s;
+            }
+            .star:nth-child(35) {
+            --star-tail-length: 7.01em;
+            --top-offset: 77.17vh;
+            --fall-duration: 6.29s;
+            --fall-delay: 1.468s;
+            }
+            .star:nth-child(36) {
+            --star-tail-length: 5.17em;
+            --top-offset: 13.63vh;
+            --fall-duration: 6.739s;
+            --fall-delay: 0.019s;
+            }
+            .star:nth-child(37) {
+            --star-tail-length: 6.41em;
+            --top-offset: 70.18vh;
+            --fall-duration: 6.177s;
+            --fall-delay: 8.148s;
+            }
+            .star:nth-child(38) {
+            --star-tail-length: 5.32em;
+            --top-offset: 62.65vh;
+            --fall-duration: 10.476s;
+            --fall-delay: 0.98s;
+            }
+            .star:nth-child(39) {
+            --star-tail-length: 7.24em;
+            --top-offset: 66.12vh;
+            --fall-duration: 8.449s;
+            --fall-delay: 4.255s;
+            }
+            .star:nth-child(40) {
+            --star-tail-length: 6.73em;
+            --top-offset: 14.73vh;
+            --fall-duration: 9.857s;
+            --fall-delay: 6.867s;
+            }
+            .star:nth-child(41) {
+            --star-tail-length: 5.25em;
+            --top-offset: 45.23vh;
+            --fall-duration: 7.898s;
+            --fall-delay: 4.966s;
+            }
+            .star:nth-child(42) {
+            --star-tail-length: 6.73em;
+            --top-offset: 36.17vh;
+            --fall-duration: 7.32s;
+            --fall-delay: 3.93s;
+            }
+            .star:nth-child(43) {
+            --star-tail-length: 7.38em;
+            --top-offset: 83.09vh;
+            --fall-duration: 7.394s;
+            --fall-delay: 5.388s;
+            }
+            .star:nth-child(44) {
+            --star-tail-length: 5.18em;
+            --top-offset: 98.36vh;
+            --fall-duration: 6.905s;
+            --fall-delay: 2.771s;
+            }
+            .star:nth-child(45) {
+            --star-tail-length: 6.66em;
+            --top-offset: 27.99vh;
+            --fall-duration: 7.62s;
+            --fall-delay: 3.624s;
+            }
+            .star:nth-child(46) {
+            --star-tail-length: 5.19em;
+            --top-offset: 92vh;
+            --fall-duration: 9.158s;
+            --fall-delay: 1.984s;
+            }
+            .star:nth-child(47) {
+            --star-tail-length: 6.16em;
+            --top-offset: 2.87vh;
+            --fall-duration: 9.266s;
+            --fall-delay: 4.04s;
+            }
+            .star:nth-child(48) {
+            --star-tail-length: 6.34em;
+            --top-offset: 19.39vh;
+            --fall-duration: 7.503s;
+            --fall-delay: 0.045s;
+            }
+            .star:nth-child(49) {
+            --star-tail-length: 6.85em;
+            --top-offset: 79.92vh;
+            --fall-duration: 7.472s;
+            --fall-delay: 1.514s;
+            }
+            .star:nth-child(50) {
+            --star-tail-length: 7.35em;
+            --top-offset: 63.71vh;
+            --fall-duration: 8.117s;
+            --fall-delay: 4.46s;
+            }
+            .star::before, .star::after {
+            position: absolute;
+            content: "";
+            top: 0;
+            left: calc(var(--star-width) / -2);
+            width: var(--star-width);
+            height: 100%;
+            background: linear-gradient(45deg, transparent, currentColor, transparent);
+            border-radius: inherit;
+            animation: blink 2s linear infinite;
+            }
+            .star::before {
+            transform: rotate(45deg);
+            }
+            .star::after {
+            transform: rotate(-45deg);
+            }
+
+            @keyframes fall {
+            to {
+                transform: translate3d(-30em, 0, 0);
+            }
+            }
+            @keyframes tail-fade {
+            0%, 50% {
+                width: var(--star-tail-length);
+                opacity: 1;
+            }
+            70%, 80% {
+                width: 0;
+                opacity: 0.4;
+            }
+            100% {
+                width: 0;
+                opacity: 0;
+            }
+            }
+            @keyframes blink {
+            50% {
+                opacity: 0.6;
+            }
+            }
+        </style>
+    </head>
+
+    <body>
+        <div class="stars"></div>
+
+        <script>
+            let hasTouchScreen = false;
+            if ("maxTouchPoints" in navigator) {
+                hasTouchScreen = navigator.maxTouchPoints > 0;
+            } else if ("msMaxTouchPoints" in navigator) {
+                hasTouchScreen = navigator.msMaxTouchPoints > 0;
+            } else {
+                const mQ = matchMedia?.("(pointer:coarse)");
+                if (mQ?.media === "(pointer:coarse)") {
+                    hasTouchScreen = !!mQ.matches;
+                } else if ("orientation" in window) {
+                    hasTouchScreen = true;
+                } else {
+                    const UA = navigator.userAgent;
+                    hasTouchScreen =
+                        /\b(BlackBerry|webOS|iPhone|IEMobile)\b/i.test(UA) ||
+                        /\b(Android|Windows Phone|iPad|iPod)\b/i.test(UA);
+                }
+            }
+
+            if (!hasTouchScreen) {
+                document.addEventListener("DOMContentLoaded", function() {
+                    const starsContainer = document.querySelector('.stars');
+                    const starCount = 30
+
+                    for (let i = 0; i < starCount; i++) {
+                        const star = document.createElement("div");
+                        star.classList.add("star");
+                        starsContainer.appendChild(star);
+                    }
+                });
+            }
+        </script>
+        <div class="header">
+            <p class="comet-text">
+                <img class="emoji" src="https://fonts.gstatic.com/s/e/notoemoji/latest/1f4ab/512.gif">
+                Comet - <a href="https://github.com/g0ldyy/comet">GitHub</a>
+            </p>
+            {{CUSTOM_HEADER_HTML|safe}}
+        </div>
+
+        <div class="form-container">
+            <div class="form-item">
+                <sl-select id="indexers" multiple clearable label="Indexers" placeholder="Select indexers" {% if not indexerManager %} disabled {% endif %}></sl-select>
+            </div>
+
+            <div class="form-item">
+                <sl-select id="languages" multiple clearable label="Languages" placeholder="Select languages"></sl-select>
+            </div>
+
+            <div class="form-item">
+                <sl-select id="resolutions" multiple clearable label="Resolutions" placeholder="Select resolutions"></sl-select>
+            </div>
+
+            <div class="form-item">
+                <sl-input id="maxResults" type="number" min=0 value=0 label="Max Results" placeholder="Enter max results"></sl-input>
+            </div>
+
+            <div class="form-item">
+                <sl-input id="maxSize" type="number" min=0 value=0 label="Max Size (GB)" placeholder="Enter max size in gigabytes"></sl-input>
+            </div>
+
+            <div class="form-item">
+                <sl-input id="debridStreamProxyPassword" label="Debrid Stream Proxy Password" placeholder="{% if not proxyDebridStream %}Configuration required, see docs{% else %}Enter password{% endif %}" help-text="Debrid Stream Proxying allows you to use your Debrid Service from multiple IPs at same time!" {% if not proxyDebridStream %} disabled {% endif %}></sl-input>
+            </div>
+
+            <div class="form-item">
+                <sl-select id="debridService" value="realdebrid" label="Debrid Service" placeholder="Select debrid service">
+                    <sl-option value="realdebrid">Real-Debrid</sl-option>
+                    <sl-option value="alldebrid">All-Debrid</sl-option>
+                    <sl-option value="premiumize">Premiumize</sl-option>
+                    <sl-option value="torbox">TorBox</sl-option>
+                    <sl-option value="debridlink">Debrid-Link</sl-option>
+                </sl-select>
+            </div>
+
+            <div class="form-item">
+                <label for="debridService">
+                    Debrid API Key -
+                    <a id="apiKeyLink" href="https://real-debrid.com/apitoken" target="_blank">Get It Here</a>
+                </label>
+                <sl-input id="debridApiKey" placeholder="Enter API key"></sl-input>
+            </div>
+
+            <sl-details summary="Advanced Settings">
+                <div class="form-item">
+                    <sl-select id="resultFormat" multiple label="Result Format" placeholder="Select what to show in result title" hoist max-options-visible=10>
+                    </sl-select>
+                </div>
+            </sl-details>
+
+            <script>
+                document.getElementById("debridService").addEventListener("sl-change", function(event) {
+                    const selectedService = event.target.value;
+                    const apiKeyLink = document.getElementById("apiKeyLink");
+
+                    if (selectedService === "realdebrid") {
+                        apiKeyLink.href = "https://real-debrid.com/apitoken";
+                    } else if (selectedService === "alldebrid") {
+                        apiKeyLink.href = "https://alldebrid.com/apikeys";
+                    } else if (selectedService === "premiumize") {
+                        apiKeyLink.href = "https://premiumize.me/account";
+                    } else if (selectedService === "torbox") {
+                        apiKeyLink.href = "https://torbox.app/settings";
+                    } else if (selectedService === "debridlink") {
+                        apiKeyLink.href = "https://debrid-link.com/webapp/apikey";
+                    }
+                });
+            </script>
+
+            <div class="centered-item">
+                <sl-button id="install" variant="neutral" class="margin-left-install">Install</sl-button>
+                <sl-alert id="installAlert" variant="neutral" duration="3000" closable>
+                    <sl-icon slot="icon" name="clipboard2-check"></sl-icon>
+                    <strong>Attempting to add the addon to Stremio...</strong>
+                </sl-alert>
+
+                <sl-button id="copy-link" variant="neutral">Copy Link</sl-button>
+                <sl-alert id="copyAlert" variant="neutral" duration="3000" closable>
+                    <sl-icon slot="icon" name="clipboard2-check"></sl-icon>
+                    <strong>The Stremio addon link has been automatically copied.</strong>
+                </sl-alert>
+
+                <script type="module">
+                    const languagesEmojis = {
+                        "Multi": "🌎",
+                        "English": "🇬🇧",
+                        "Japanese": "🇯🇵",
+                        "Chinese": "🇨🇳",
+                        "Russian": "🇷🇺",
+                        "Arabic": "🇸🇦",
+                        "Portuguese": "🇵🇹",
+                        "Spanish": "🇪🇸",
+                        "French": "🇫🇷",
+                        "German": "🇩🇪",
+                        "Italian": "🇮🇹",
+                        "Korean": "🇰🇷",
+                        "Hindi": "🇮🇳",
+                        "Bengali": "🇧🇩",
+                        "Punjabi": "🇵🇰",
+                        "Marathi": "🇮🇳",
+                        "Gujarati": "🇮🇳",
+                        "Tamil": "🇮🇳",
+                        "Telugu": "🇮🇳",
+                        "Kannada": "🇮🇳",
+                        "Malayalam": "🇮🇳",
+                        "Thai": "🇹🇭",
+                        "Vietnamese": "🇻🇳",
+                        "Indonesian": "🇮🇩",
+                        "Turkish": "🇹🇷",
+                        "Hebrew": "🇮🇱",
+                        "Persian": "🇮🇷",
+                        "Ukrainian": "🇺🇦",
+                        "Greek": "🇬🇷",
+                        "Lithuanian": "🇱🇹",
+                        "Latvian": "🇱🇻",
+                        "Estonian": "🇪🇪",
+                        "Polish": "🇵🇱",
+                        "Czech": "🇨🇿",
+                        "Slovak": "🇸🇰",
+                        "Hungarian": "🇭🇺",
+                        "Romanian": "🇷🇴",
+                        "Bulgarian": "🇧🇬",
+                        "Serbian": "🇷🇸",
+                        "Croatian": "🇭🇷",
+                        "Slovenian": "🇸🇮",
+                        "Dutch": "🇳🇱", 
+                        "Danish": "🇩🇰",
+                        "Finnish": "🇫🇮",
+                        "Swedish": "🇸🇪",
+                        "Norwegian": "🇳🇴",
+                        "Malay": "🇲🇾",
+                        "Latino": "💃🏻",
+                    };
+
+                    let defaultLanguages = [];
+                    let defaultResolutions = [];
+                    let defaultResultFormat = [];
+
+                    document.addEventListener("DOMContentLoaded", async () => {
+                        await Promise.allSettled([
+                            customElements.whenDefined("sl-button"),
+                            customElements.whenDefined("sl-alert"),
+                            customElements.whenDefined("sl-select"),
+                            customElements.whenDefined("sl-input"),
+                            customElements.whenDefined("sl-option"),
+                            customElements.whenDefined("sl-icon")
+                        ]);
+
+                        const webConfig = {{webConfig|tojson}};
+                        populateSelect("indexers", webConfig.indexers);
+                        populateSelect("languages", webConfig.languages);
+                        populateSelect("resolutions", webConfig.resolutions);
+                        populateSelect("resultFormat", webConfig.resultFormat);
+                        document.body.classList.add("ready");
+                        defaultLanguages = webConfig.languages;
+                        defaultResolutions = webConfig.resolutions;
+                        defaultResultFormat = webConfig.resultFormat;
+
+                        // try populate the form from previous settings
+                        try {
+                            const settings = getSettingsFromUrl();
+                            if (settings != null) { populateFormFromSettings(settings); }
+                        } catch (error) {
+                            console.log("Failed to retrieve or parse settings from URL:", error);
+                        }
+
+                    });
+
+                    function populateSelect(selectId, options) {
+                        const selectElement = document.getElementById(selectId);
+                        options.forEach(option => {
+                            const optionElement = document.createElement("sl-option");
+                            optionElement.value = option;
+
+                            if (selectId === "languages") {
+                                // For languages, prepend the flag emoji if it exists
+                                const flag = languagesEmojis[option] || '';
+                                optionElement.textContent = `${flag} ${option}`;
+                            } else {
+                                // For other selects, just use the option text as is
+                                optionElement.textContent = option;
+                            }
+
+                            selectElement.appendChild(optionElement);
+                        });
+
+                        // Set the default value
+                        selectElement.value = options; // Assuming first option as default
+                    }
+
+                    const installButton = document.querySelector("#install");
+                    const installAlert = document.querySelector('#installAlert');
+                    const copyLinkButton = document.querySelector("#copy-link");
+                    const copyAlert = document.querySelector('#copyAlert');
+
+                    function getSettings() {
+                        const indexers = Array.from(document.getElementById("indexers").selectedOptions).map(option => option.value);
+                        const languages = Array.from(document.getElementById("languages").selectedOptions).map(option => option.value);
+                        const resolutions = Array.from(document.getElementById("resolutions").selectedOptions).map(option => option.value);
+                        const maxResults = document.getElementById("maxResults").value;
+                        const maxSize = document.getElementById("maxSize").value;
+                        const resultFormat = Array.from(document.getElementById("resultFormat").selectedOptions).map(option => option.value);
+                        const debridService = document.getElementById("debridService").value;
+                        const debridApiKey = document.getElementById("debridApiKey").value;
+                        const debridStreamProxyPassword = document.getElementById("debridStreamProxyPassword").value;
+                        const selectedLanguages = languages.length === defaultLanguages.length && languages.every((val, index) => val === defaultLanguages[index]) ? ["All"] : languages;
+                        const selectedResolutions = resolutions.length === defaultResolutions.length && resolutions.every((val, index) => val === defaultResolutions[index]) ? ["All"] : resolutions;
+                        const selectedResultFormat = resultFormat.length === defaultResultFormat.length && resultFormat.every((val, index) => val === defaultResultFormat[index]) ? ["All"] : resultFormat;
+
+                        return {
+                            indexers: indexers,
+                            maxResults: parseInt(maxResults),
+                            maxSize: parseFloat(maxSize * 1073741824),
+                            resultFormat: selectedResultFormat,
+                            resolutions: selectedResolutions,
+                            languages: selectedLanguages,
+                            debridService: debridService,
+                            debridApiKey: debridApiKey,
+                            debridStreamProxyPassword: debridStreamProxyPassword,
+                        };
+                    }
+
+                    copyLinkButton.addEventListener("click", () => {
+                        const settings = getSettings();
+                        const settingsString = btoa(JSON.stringify(settings))
+
+                        const textArea = document.createElement("textarea");
+                        textArea.value = `${window.location.origin}/${settingsString}/manifest.json`;
+                        document.body.appendChild(textArea);
+                        textArea.focus();
+                        textArea.select();
+                        document.execCommand("copy");
+                        document.body.removeChild(textArea);
+
+                        console.log(settingsString);
+
+                        copyAlert.toast();
+                    });
+
+                    installButton.addEventListener("click", () => {
+                        const settings = getSettings();
+                        const settingsString = btoa(JSON.stringify(settings))
+                        window.location.href = `stremio://${window.location.host}/${settingsString}/manifest.json`;
+                        console.log(settingsString);
+                        installAlert.toast();
+                    });
+
+                    function getSettingsFromUrl() {
+                        const url = window.location.href;
+                        // Try parse settings from the URL
+                        if (url.split("/").length < 5) {
+                            console.log("no previous settings"); return null;
+                        }
+                        const settingsString =  url.split("/")[3];
+                        if (typeof settingsString === "undefined") {
+                            console.log("can't fetch previous settings", settingsString)
+                            return null;
+                        }
+                        const settingsJson = atob(settingsString);
+                        return JSON.parse(settingsJson);
+                    }
+
+                    function populateFormFromSettings(settings) {
+                        document.getElementById("maxResults").value = settings.maxResults;
+                        document.getElementById("maxSize").value = settings.maxSize / 1073741824; // Convert back from bytes to GB
+                        document.getElementById("debridService").value = settings.debridService;
+                        document.getElementById("debridApiKey").value = settings.debridApiKey;
+                        document.getElementById("debridStreamProxyPassword").value = settings.debridStreamProxyPassword;
+                        document.getElementById("indexers").value = settings.indexers;
+                        if (settings.languages != "All")
+                            document.getElementById("languages").value = settings.languages;
+                        if (settings.resolutions != "All")
+                            document.getElementById("resolutions").value = settings.resolutions;
+                        if (settings.resultFormat != "All")
+                            document.getElementById("resultFormat").value = settings.resultFormat;
+                    }
+
+                </script>
+            </div>
+        </div>
+    </body>
+</html>

comet/utils/db.py

@@ -0,0 +1,34 @@
+import os
+
+from comet.utils.logger import logger
+from comet.utils.models import database, settings
+
+
+async def setup_database():
+    try:
+        if settings.DATABASE_TYPE == "sqlite":
+            os.makedirs(os.path.dirname(settings.DATABASE_PATH), exist_ok=True)
+
+            if not os.path.exists(settings.DATABASE_PATH):
+                open(settings.DATABASE_PATH, "a").close()
+
+        await database.connect()
+        await database.execute(
+            "CREATE TABLE IF NOT EXISTS cache (cacheKey TEXT PRIMARY KEY, timestamp INTEGER, results TEXT)"
+        )
+        await database.execute(
+            "CREATE TABLE IF NOT EXISTS download_links (debrid_key TEXT, hash TEXT, file_index TEXT, link TEXT, timestamp INTEGER, PRIMARY KEY (debrid_key, hash, file_index))"
+        )
+        await database.execute("DROP TABLE IF EXISTS active_connections")
+        await database.execute(
+            "CREATE TABLE IF NOT EXISTS active_connections (id TEXT PRIMARY KEY, ip TEXT, content TEXT, timestamp INTEGER)"
+        )
+    except Exception as e:
+        logger.error(f"Error setting up the database: {e}")
+
+
+async def teardown_database():
+    try:
+        await database.disconnect()
+    except Exception as e:
+        logger.error(f"Error tearing down the database: {e}")

comet/utils/general.py

@@ -0,0 +1,614 @@
+import base64
+import hashlib
+import json
+import re
+import aiohttp
+import bencodepy
+import PTT
+import asyncio
+
+from RTN import parse, title_match
+from curl_cffi import requests
+from fastapi import Request
+
+from comet.utils.logger import logger
+from comet.utils.models import settings, ConfigModel
+
+languages_emojis = {
+    "multi": "🌎",  # Dubbed
+    "en": "🇬🇧",  # English
+    "ja": "🇯🇵",  # Japanese
+    "zh": "🇨🇳",  # Chinese
+    "ru": "🇷🇺",  # Russian
+    "ar": "🇸🇦",  # Arabic
+    "pt": "🇵🇹",  # Portuguese
+    "es": "🇪🇸",  # Spanish
+    "fr": "🇫🇷",  # French
+    "de": "🇩🇪",  # German
+    "it": "🇮🇹",  # Italian
+    "ko": "🇰🇷",  # Korean
+    "hi": "🇮🇳",  # Hindi
+    "bn": "🇧🇩",  # Bengali
+    "pa": "🇵🇰",  # Punjabi
+    "mr": "🇮🇳",  # Marathi
+    "gu": "🇮🇳",  # Gujarati
+    "ta": "🇮🇳",  # Tamil
+    "te": "🇮🇳",  # Telugu
+    "kn": "🇮🇳",  # Kannada
+    "ml": "🇮🇳",  # Malayalam
+    "th": "🇹🇭",  # Thai
+    "vi": "🇻🇳",  # Vietnamese
+    "id": "🇮🇩",  # Indonesian
+    "tr": "🇹🇷",  # Turkish
+    "he": "🇮🇱",  # Hebrew
+    "fa": "🇮🇷",  # Persian
+    "uk": "🇺🇦",  # Ukrainian
+    "el": "🇬🇷",  # Greek
+    "lt": "🇱🇹",  # Lithuanian
+    "lv": "🇱🇻",  # Latvian
+    "et": "🇪🇪",  # Estonian
+    "pl": "🇵🇱",  # Polish
+    "cs": "🇨🇿",  # Czech
+    "sk": "🇸🇰",  # Slovak
+    "hu": "🇭🇺",  # Hungarian
+    "ro": "🇷🇴",  # Romanian
+    "bg": "🇧🇬",  # Bulgarian
+    "sr": "🇷🇸",  # Serbian
+    "hr": "🇭🇷",  # Croatian
+    "sl": "🇸🇮",  # Slovenian
+    "nl": "🇳🇱",  # Dutch
+    "da": "🇩🇰",  # Danish
+    "fi": "🇫🇮",  # Finnish
+    "sv": "🇸🇪",  # Swedish
+    "no": "🇳🇴",  # Norwegian
+    "ms": "🇲🇾",  # Malay
+    "la": "💃🏻",  # Latino
+}
+
+
+def get_language_emoji(language: str):
+    language_formatted = language.lower()
+    return (
+        languages_emojis[language_formatted]
+        if language_formatted in languages_emojis
+        else language
+    )
+
+
+translation_table = {
+    "ā": "a",
+    "ă": "a",
+    "ą": "a",
+    "ć": "c",
+    "č": "c",
+    "ç": "c",
+    "ĉ": "c",
+    "ċ": "c",
+    "ď": "d",
+    "đ": "d",
+    "è": "e",
+    "é": "e",
+    "ê": "e",
+    "ë": "e",
+    "ē": "e",
+    "ĕ": "e",
+    "ę": "e",
+    "ě": "e",
+    "ĝ": "g",
+    "ğ": "g",
+    "ġ": "g",
+    "ģ": "g",
+    "ĥ": "h",
+    "î": "i",
+    "ï": "i",
+    "ì": "i",
+    "í": "i",
+    "ī": "i",
+    "ĩ": "i",
+    "ĭ": "i",
+    "ı": "i",
+    "ĵ": "j",
+    "ķ": "k",
+    "ĺ": "l",
+    "ļ": "l",
+    "ł": "l",
+    "ń": "n",
+    "ň": "n",
+    "ñ": "n",
+    "ņ": "n",
+    "ʼn": "n",
+    "ó": "o",
+    "ô": "o",
+    "õ": "o",
+    "ö": "o",
+    "ø": "o",
+    "ō": "o",
+    "ő": "o",
+    "œ": "oe",
+    "ŕ": "r",
+    "ř": "r",
+    "ŗ": "r",
+    "š": "s",
+    "ş": "s",
+    "ś": "s",
+    "ș": "s",
+    "ß": "ss",
+    "ť": "t",
+    "ţ": "t",
+    "ū": "u",
+    "ŭ": "u",
+    "ũ": "u",
+    "û": "u",
+    "ü": "u",
+    "ù": "u",
+    "ú": "u",
+    "ų": "u",
+    "ű": "u",
+    "ŵ": "w",
+    "ý": "y",
+    "ÿ": "y",
+    "ŷ": "y",
+    "ž": "z",
+    "ż": "z",
+    "ź": "z",
+    "æ": "ae",
+    "ǎ": "a",
+    "ǧ": "g",
+    "ə": "e",
+    "ƒ": "f",
+    "ǐ": "i",
+    "ǒ": "o",
+    "ǔ": "u",
+    "ǚ": "u",
+    "ǜ": "u",
+    "ǹ": "n",
+    "ǻ": "a",
+    "ǽ": "ae",
+    "ǿ": "o",
+}
+
+translation_table = str.maketrans(translation_table)
+info_hash_pattern = re.compile(r"\b([a-fA-F0-9]{40})\b")
+
+
+def translate(title: str):
+    return title.translate(translation_table)
+
+
+def is_video(title: str):
+    return title.endswith(
+        tuple(
+            [
+                ".mkv",
+                ".mp4",
+                ".avi",
+                ".mov",
+                ".flv",
+                ".wmv",
+                ".webm",
+                ".mpg",
+                ".mpeg",
+                ".m4v",
+                ".3gp",
+                ".3g2",
+                ".ogv",
+                ".ogg",
+                ".drc",
+                ".gif",
+                ".gifv",
+                ".mng",
+                ".avi",
+                ".mov",
+                ".qt",
+                ".wmv",
+                ".yuv",
+                ".rm",
+                ".rmvb",
+                ".asf",
+                ".amv",
+                ".m4p",
+                ".m4v",
+                ".mpg",
+                ".mp2",
+                ".mpeg",
+                ".mpe",
+                ".mpv",
+                ".mpg",
+                ".mpeg",
+                ".m2v",
+                ".m4v",
+                ".svi",
+                ".3gp",
+                ".3g2",
+                ".mxf",
+                ".roq",
+                ".nsv",
+                ".flv",
+                ".f4v",
+                ".f4p",
+                ".f4a",
+                ".f4b",
+            ]
+        )
+    )
+
+
+def bytes_to_size(bytes: int):
+    sizes = ["Bytes", "KB", "MB", "GB", "TB"]
+    if bytes == 0:
+        return "0 Byte"
+
+    i = 0
+    while bytes >= 1024 and i < len(sizes) - 1:
+        bytes /= 1024
+        i += 1
+
+    return f"{round(bytes, 2)} {sizes[i]}"
+
+
+def config_check(b64config: str):
+    try:
+        config = json.loads(base64.b64decode(b64config).decode())
+        validated_config = ConfigModel(**config)
+        return validated_config.model_dump()
+    except:
+        return False
+
+
+def get_debrid_extension(debridService: str):
+    debrid_extension = None
+    if debridService == "realdebrid":
+        debrid_extension = "RD"
+    elif debridService == "alldebrid":
+        debrid_extension = "AD"
+    elif debridService == "premiumize":
+        debrid_extension = "PM"
+    elif debridService == "torbox":
+        debrid_extension = "TB"
+    elif debridService == "debridlink":
+        debrid_extension = "DL"
+
+    return debrid_extension
+
+
+async def get_indexer_manager(
+    session: aiohttp.ClientSession,
+    indexer_manager_type: str,
+    indexers: list,
+    query: str,
+):
+    results = []
+    try:
+        indexers = [indexer.replace("_", " ") for indexer in indexers]
+
+        if indexer_manager_type == "jackett":
+
+            async def fetch_jackett_results(
+                session: aiohttp.ClientSession, indexer: str, query: str
+            ):
+                try:
+                    async with session.get(
+                        f"{settings.INDEXER_MANAGER_URL}/api/v2.0/indexers/all/results?apikey={settings.INDEXER_MANAGER_API_KEY}&Query={query}&Tracker[]={indexer}",
+                        timeout=aiohttp.ClientTimeout(
+                            total=settings.INDEXER_MANAGER_TIMEOUT
+                        ),
+                    ) as response:
+                        response_json = await response.json()
+                        return response_json.get("Results", [])
+                except Exception as e:
+                    logger.warning(
+                        f"Exception while fetching Jackett results for indexer {indexer}: {e}"
+                    )
+                    return []
+
+            tasks = [
+                fetch_jackett_results(session, indexer, query) for indexer in indexers
+            ]
+            all_results = await asyncio.gather(*tasks)
+
+            for result_set in all_results:
+                results.extend(result_set)
+
+        elif indexer_manager_type == "prowlarr":
+            get_indexers = await session.get(
+                f"{settings.INDEXER_MANAGER_URL}/api/v1/indexer",
+                headers={"X-Api-Key": settings.INDEXER_MANAGER_API_KEY},
+            )
+            get_indexers = await get_indexers.json()
+
+            indexers_id = []
+            for indexer in get_indexers:
+                if (
+                    indexer["name"].lower() in indexers
+                    or indexer["definitionName"].lower() in indexers
+                ):
+                    indexers_id.append(indexer["id"])
+
+            response = await session.get(
+                f"{settings.INDEXER_MANAGER_URL}/api/v1/search?query={query}&indexerIds={'&indexerIds='.join(str(indexer_id) for indexer_id in indexers_id)}&type=search",
+                headers={"X-Api-Key": settings.INDEXER_MANAGER_API_KEY},
+            )
+            response = await response.json()
+
+            for result in response:
+                result["InfoHash"] = (
+                    result["infoHash"] if "infoHash" in result else None
+                )
+                result["Title"] = result["title"]
+                result["Size"] = result["size"]
+                result["Link"] = (
+                    result["downloadUrl"] if "downloadUrl" in result else None
+                )
+                result["Tracker"] = result["indexer"]
+
+                results.append(result)
+    except Exception as e:
+        logger.warning(
+            f"Exception while getting {indexer_manager_type} results for {query} with {indexers}: {e}"
+        )
+        pass
+
+    return results
+
+
+async def get_zilean(
+    session: aiohttp.ClientSession, name: str, log_name: str, season: int, episode: int
+):
+    results = []
+    try:
+        show = f"&season={season}&episode={episode}"
+        get_dmm = await session.get(
+            f"{settings.ZILEAN_URL}/dmm/filtered?query={name}{show if season else ''}"
+        )
+        get_dmm = await get_dmm.json()
+
+        if isinstance(get_dmm, list):
+            take_first = get_dmm[: settings.ZILEAN_TAKE_FIRST]
+            for result in take_first:
+                object = {
+                    "Title": result["raw_title"],
+                    "InfoHash": result["info_hash"],
+                    "Size": result["size"],
+                    "Tracker": "DMM",
+                }
+
+                results.append(object)
+
+        logger.info(f"{len(results)} torrents found for {log_name} with Zilean")
+    except Exception as e:
+        logger.warning(
+            f"Exception while getting torrents for {log_name} with Zilean: {e}"
+        )
+        pass
+
+    return results
+
+
+async def get_torrentio(log_name: str, type: str, full_id: str):
+    results = []
+    try:
+        try:
+            get_torrentio = requests.get(
+                f"https://torrentio.strem.fun/stream/{type}/{full_id}.json"
+            ).json()
+        except:
+            get_torrentio = requests.get(
+                f"https://torrentio.strem.fun/stream/{type}/{full_id}.json",
+                proxies={
+                    "http": settings.DEBRID_PROXY_URL,
+                    "https": settings.DEBRID_PROXY_URL,
+                },
+            ).json()
+
+        for torrent in get_torrentio["streams"]:
+            title = torrent["title"]
+            title_full = title.split("\n👤")[0]
+            tracker = title.split("⚙️ ")[1].split("\n")[0]
+
+            results.append(
+                {
+                    "Title": title_full,
+                    "InfoHash": torrent["infoHash"],
+                    "Size": None,
+                    "Tracker": f"Torrentio|{tracker}",
+                }
+            )
+
+        logger.info(f"{len(results)} torrents found for {log_name} with Torrentio")
+    except Exception as e:
+        logger.warning(
+            f"Exception while getting torrents for {log_name} with Torrentio, your IP is most likely blacklisted (you should try proxying Comet): {e}"
+        )
+        pass
+
+    return results
+
+
+async def filter(torrents: list, name: str, year: int):
+    results = []
+    for torrent in torrents:
+        index = torrent[0]
+        title = torrent[1]
+
+        if "\n" in title:  # Torrentio title parsing
+            title = title.split("\n")[1]
+
+        parsed = parse(title)
+        if not title_match(name, parsed.parsed_title):
+            results.append((index, False))
+            continue
+
+        if year and parsed.year and year != parsed.year:
+            results.append((index, False))
+            continue
+
+        results.append((index, True))
+
+    return results
+
+
+async def get_torrent_hash(session: aiohttp.ClientSession, torrent: tuple):
+    index = torrent[0]
+    torrent = torrent[1]
+    if "InfoHash" in torrent and torrent["InfoHash"] is not None:
+        return (index, torrent["InfoHash"].lower())
+
+    url = torrent["Link"]
+
+    try:
+        timeout = aiohttp.ClientTimeout(total=settings.GET_TORRENT_TIMEOUT)
+        response = await session.get(url, allow_redirects=False, timeout=timeout)
+        if response.status == 200:
+            torrent_data = await response.read()
+            torrent_dict = bencodepy.decode(torrent_data)
+            info = bencodepy.encode(torrent_dict[b"info"])
+            hash = hashlib.sha1(info).hexdigest()
+        else:
+            location = response.headers.get("Location", "")
+            if not location:
+                return (index, None)
+
+            match = info_hash_pattern.search(location)
+            if not match:
+                return (index, None)
+
+            hash = match.group(1).upper()
+
+        return (index, hash.lower())
+    except Exception as e:
+        logger.warning(
+            f"Exception while getting torrent info hash for {torrent['indexer'] if 'indexer' in torrent else (torrent['Tracker'] if 'Tracker' in torrent else '')}|{url}: {e}"
+        )
+
+        return (index, None)
+
+
+def get_balanced_hashes(hashes: dict, config: dict):
+    max_results = config["maxResults"]
+
+    max_size = config["maxSize"]
+    config_resolutions = [resolution.lower() for resolution in config["resolutions"]]
+    include_all_resolutions = "all" in config_resolutions
+
+    languages = [language.lower() for language in config["languages"]]
+    include_all_languages = "all" in languages
+    if not include_all_languages:
+        config_languages = [
+            code
+            for code, name in PTT.parse.LANGUAGES_TRANSLATION_TABLE.items()
+            if name.lower() in languages
+        ]
+
+    hashes_by_resolution = {}
+    for hash, hash_data in hashes.items():
+        hash_info = hash_data["data"]
+
+        if max_size != 0 and hash_info["size"] > max_size:
+            continue
+
+        if (
+            not include_all_languages
+            and not any(lang in hash_info["languages"] for lang in config_languages)
+            and ("multi" not in languages if hash_info["dubbed"] else True)
+        ):
+            continue
+
+        resolution = hash_info["resolution"]
+        if not include_all_resolutions and resolution not in config_resolutions:
+            continue
+
+        if resolution not in hashes_by_resolution:
+            hashes_by_resolution[resolution] = []
+        hashes_by_resolution[resolution].append(hash)
+
+    total_resolutions = len(hashes_by_resolution)
+    if max_results == 0 or total_resolutions == 0:
+        return hashes_by_resolution
+
+    hashes_per_resolution = max_results // total_resolutions
+    extra_hashes = max_results % total_resolutions
+
+    balanced_hashes = {}
+    for resolution, hash_list in hashes_by_resolution.items():
+        selected_count = hashes_per_resolution + (1 if extra_hashes > 0 else 0)
+        balanced_hashes[resolution] = hash_list[:selected_count]
+        if extra_hashes > 0:
+            extra_hashes -= 1
+
+    selected_total = sum(len(hashes) for hashes in balanced_hashes.values())
+    if selected_total < max_results:
+        missing_hashes = max_results - selected_total
+        for resolution, hash_list in hashes_by_resolution.items():
+            if missing_hashes <= 0:
+                break
+            current_count = len(balanced_hashes[resolution])
+            available_hashes = hash_list[current_count : current_count + missing_hashes]
+            balanced_hashes[resolution].extend(available_hashes)
+            missing_hashes -= len(available_hashes)
+
+    return balanced_hashes
+
+
+def format_metadata(data: dict):
+    extras = []
+    if data["quality"]:
+        extras.append(data["quality"])
+    if data["hdr"]:
+        extras.extend(data["hdr"])
+    if data["codec"]:
+        extras.append(data["codec"])
+    if data["audio"]:
+        extras.extend(data["audio"])
+    if data["channels"]:
+        extras.extend(data["channels"])
+    if data["bit_depth"]:
+        extras.append(data["bit_depth"])
+    if data["network"]:
+        extras.append(data["network"])
+    if data["group"]:
+        extras.append(data["group"])
+
+    return "|".join(extras)
+
+
+def format_title(data: dict, config: dict):
+    title = ""
+    if "All" in config["resultFormat"] or "Title" in config["resultFormat"]:
+        title += f"{data['title']}\n"
+
+    if "All" in config["resultFormat"] or "Metadata" in config["resultFormat"]:
+        metadata = format_metadata(data)
+        if metadata != "":
+            title += f"💿 {metadata}\n"
+
+    if "All" in config["resultFormat"] or "Size" in config["resultFormat"]:
+        title += f"💾 {bytes_to_size(data['size'])} "
+
+    if "All" in config["resultFormat"] or "Tracker" in config["resultFormat"]:
+        title += f"🔎 {data['tracker'] if 'tracker' in data else '?'}"
+
+    if "All" in config["resultFormat"] or "Languages" in config["resultFormat"]:
+        languages = data["languages"]
+        if data["dubbed"]:
+            languages.insert(0, "multi")
+        formatted_languages = (
+            "/".join(get_language_emoji(language) for language in languages)
+            if languages
+            else None
+        )
+        languages_str = "\n" + formatted_languages if formatted_languages else ""
+        title += f"{languages_str}"
+
+    if title == "":
+        # Without this, Streamio shows SD as the result, which is confusing
+        title = "Empty result format configuration"
+
+    return title
+
+
+def get_client_ip(request: Request):
+    return (
+        request.headers["cf-connecting-ip"]
+        if "cf-connecting-ip" in request.headers
+        else request.client.host
+    )

comet/utils/logger.py

@@ -0,0 +1,34 @@
+import sys
+
+from loguru import logger
+
+
+def setupLogger(level: str):
+    logger.level("COMET", no=50, icon="🌠", color="<fg #7871d6>")
+    logger.level("API", no=40, icon="👾", color="<fg #7871d6>")
+
+    logger.level("INFO", icon="📰", color="<fg #FC5F39>")
+    logger.level("DEBUG", icon="🕸️", color="<fg #DC5F00>")
+    logger.level("WARNING", icon="⚠️", color="<fg #DC5F00>")
+
+    log_format = (
+        "<white>{time:YYYY-MM-DD}</white> <magenta>{time:HH:mm:ss}</magenta> | "
+        "<level>{level.icon}</level> <level>{level}</level> | "
+        "<cyan>{module}</cyan>.<cyan>{function}</cyan> - <level>{message}</level>"
+    )
+
+    logger.configure(
+        handlers=[
+            {
+                "sink": sys.stderr,
+                "level": level,
+                "format": log_format,
+                "backtrace": False,
+                "diagnose": False,
+                "enqueue": True,
+            }
+        ]
+    )
+
+
+setupLogger("DEBUG")

comet/utils/models.py

@@ -0,0 +1,123 @@
+import os
+import random
+import string
+
+from typing import List, Optional
+from databases import Database
+from pydantic import BaseModel, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from RTN import RTN, BestRanking, SettingsModel
+
+
+class AppSettings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+    ADDON_ID: Optional[str] = "stremio.comet.fast"
+    ADDON_NAME: Optional[str] = "Comet"
+    FASTAPI_HOST: Optional[str] = "0.0.0.0"
+    FASTAPI_PORT: Optional[int] = 8000
+    FASTAPI_WORKERS: Optional[int] = 2 * (os.cpu_count() or 1)
+    DASHBOARD_ADMIN_PASSWORD: Optional[str] = None
+    DATABASE_TYPE: Optional[str] = "sqlite"
+    DATABASE_URL: Optional[str] = "username:password@hostname:port"
+    DATABASE_PATH: Optional[str] = "data/comet.db"
+    CACHE_TTL: Optional[int] = 86400
+    DEBRID_PROXY_URL: Optional[str] = None
+    INDEXER_MANAGER_TYPE: Optional[str] = "jackett"
+    INDEXER_MANAGER_URL: Optional[str] = "http://127.0.0.1:9117"
+    INDEXER_MANAGER_API_KEY: Optional[str] = None
+    INDEXER_MANAGER_TIMEOUT: Optional[int] = 30
+    INDEXER_MANAGER_INDEXERS: List[str] = ["EXAMPLE1_CHANGETHIS", "EXAMPLE2_CHANGETHIS"]
+    GET_TORRENT_TIMEOUT: Optional[int] = 5
+    ZILEAN_URL: Optional[str] = None
+    ZILEAN_TAKE_FIRST: Optional[int] = 500
+    SCRAPE_TORRENTIO: Optional[bool] = False
+    CUSTOM_HEADER_HTML: Optional[str] = None
+    PROXY_DEBRID_STREAM: Optional[bool] = False
+    PROXY_DEBRID_STREAM_PASSWORD: Optional[str] = None
+    PROXY_DEBRID_STREAM_MAX_CONNECTIONS: Optional[int] = 100
+    PROXY_DEBRID_STREAM_DEBRID_DEFAULT_SERVICE: Optional[str] = "realdebrid"
+    PROXY_DEBRID_STREAM_DEBRID_DEFAULT_APIKEY: Optional[str] = None
+    TITLE_MATCH_CHECK: Optional[bool] = True
+
+    @field_validator("DASHBOARD_ADMIN_PASSWORD")
+    def set_dashboard_admin_password(cls, v, values):
+        if v is None:
+            return "".join(random.choices(string.ascii_letters + string.digits, k=16))
+        return v
+
+    @field_validator("INDEXER_MANAGER_TYPE")
+    def set_indexer_manager_type(cls, v, values):
+        if v == "None":
+            return None
+        return v
+
+    @field_validator("PROXY_DEBRID_STREAM_PASSWORD")
+    def set_debrid_stream_proxy_password(cls, v, values):
+        if v is None:
+            return "".join(random.choices(string.ascii_letters + string.digits, k=16))
+        return v
+
+
+settings = AppSettings()
+
+
+class ConfigModel(BaseModel):
+    indexers: List[str]
+    languages: Optional[List[str]] = ["All"]
+    resolutions: Optional[List[str]] = ["All"]
+    resultFormat: Optional[List[str]] = ["All"]
+    maxResults: Optional[int] = 0
+    maxSize: Optional[float] = 0
+    debridService: str
+    debridApiKey: str
+    debridStreamProxyPassword: Optional[str] = ""
+
+    @field_validator("indexers")
+    def check_indexers(cls, v, values):
+        settings.INDEXER_MANAGER_INDEXERS = [
+            indexer.replace(" ", "_").lower()
+            for indexer in settings.INDEXER_MANAGER_INDEXERS
+        ]  # to equal webui
+        valid_indexers = [
+            indexer for indexer in v if indexer in settings.INDEXER_MANAGER_INDEXERS
+        ]
+        # if not valid_indexers: # For only Zilean mode
+        #     raise ValueError(
+        #         f"At least one indexer must be from {settings.INDEXER_MANAGER_INDEXERS}"
+        #     )
+        return valid_indexers
+
+    @field_validator("maxResults")
+    def check_max_results(cls, v):
+        if v < 0:
+            v = 0
+        return v
+
+    @field_validator("maxSize")
+    def check_max_size(cls, v):
+        if v < 0:
+            v = 0
+        return v
+
+    @field_validator("debridService")
+    def check_debrid_service(cls, v):
+        if v not in ["realdebrid", "alldebrid", "premiumize", "torbox", "debridlink"]:
+            raise ValueError("Invalid debridService")
+        return v
+
+
+rtn_settings = SettingsModel()
+rtn_ranking = BestRanking()
+
+# For use anywhere
+rtn = RTN(settings=rtn_settings, ranking_model=rtn_ranking)
+
+database_url = (
+    settings.DATABASE_PATH
+    if settings.DATABASE_TYPE == "sqlite"
+    else settings.DATABASE_URL
+)
+database = Database(
+    f"{'sqlite' if settings.DATABASE_TYPE == 'sqlite' else 'postgresql+asyncpg'}://{'/' if settings.DATABASE_TYPE == 'sqlite' else ''}{database_url}"
+)

compose.yaml

@@ -0,0 +1,14 @@
+volumes:
+  comet_data:
+
+services:
+  comet:
+    container_name: comet
+    image: g0ldyy/comet
+    restart: unless-stopped
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    volumes:
+      - comet_data:/data

pyproject.toml

@@ -0,0 +1,37 @@
+[tool.poetry]
+name = "comet"
+version = "0.1.0"
+description = "Stremio's fastest torrent/debrid search add-on."
+authors = ["Goldy"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/g0ldyy/comet"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+uvicorn = "*"
+fastapi = "*"
+aiohttp = "*"
+asyncio = "*"
+loguru = "*"
+databases = "*"
+pydantic-settings = "*"
+bencode-py = "*"
+httpx = "*"
+curl-cffi = "*"
+orjson = "*"
+asyncpg = "*"
+aiosqlite = "*"
+jinja2 = "*"
+rank-torrent-name = "*"
+parsett = "*"
+
+
+[tool.poetry.group.dev.dependencies]
+isort = "*"
+pyright = "*"
+pytest = "*"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"