Upload 5 files

comet/main.py

@@ -0,0 +1,469 @@
+import aiohttp, asyncio, bencodepy, hashlib, re, base64, json, os, RTN, time
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import RedirectResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from contextlib import asynccontextmanager
+from databases import Database
+
+from .utils.logger import logger
+from .utils.general import translate, isVideo, bytesToSize
+
+database = Database(f"sqlite:///{os.getenv('DATABASE_PATH', 'database.db')}")
+
+class BestOverallRanking(RTN.BaseRankingModel):
+    uhd: int = 100
+    fhd: int = 90
+    hd: int = 80
+    sd: int = 70
+    dolby_video: int = 100
+    hdr: int = 80
+    hdr10: int = 90
+    dts_x: int = 100
+    dts_hd: int = 80
+    dts_hd_ma: int = 90
+    atmos: int = 90
+    truehd: int = 60
+    ddplus: int = 40
+    aac: int = 30
+    ac3: int = 20
+    remux: int = 150
+    bluray: int = 120
+    webdl: int = 90
+
+settings = RTN.SettingsModel()
+ranking_model = BestOverallRanking()
+rtn = RTN.RTN(settings=settings, ranking_model=ranking_model)
+
+infoHashPattern = re.compile(r"\b([a-fA-F0-9]{40})\b")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await database.connect()
+    await database.execute("CREATE TABLE IF NOT EXISTS cache (cacheKey BLOB PRIMARY KEY, timestamp INTEGER, results TEXT)")
+    yield
+    await database.disconnect()
+
+app = FastAPI(lifespan=lifespan, docs_url=None)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+templates = Jinja2Templates("comet/templates")
+app.mount("/static", StaticFiles(directory="comet/templates"), name="static")
+
+@app.get("/")
+async def root():
+    return RedirectResponse("/configure")
+
+indexers = os.getenv("INDEXER_MANAGER_INDEXERS")
+if "," in indexers:
+    indexers = indexers.split(",")
+else:
+    indexers = [indexers]
+
+webConfig = {
+    "indexers": indexers,
+    "languages": [indexer.replace(" ", "_") for indexer in RTN.patterns.language_code_mapping.keys()],
+    "resolutions": ["480p", "720p", "1080p", "1440p", "2160p", "2880p", "4320p"]
+}
+
+@app.get("/configure")
+@app.get("/{b64config}/configure")
+async def configure(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request, "CUSTOM_HEADER_HTML": os.getenv("CUSTOM_HEADER_HTML", ""), "webConfig": webConfig})
+
+def configChecking(b64config: str):
+    try:
+        config = json.loads(base64.b64decode(b64config).decode())
+
+        if not isinstance(config["debridService"], str) or config["debridService"] not in ["realdebrid"]:
+            return False
+        
+        if not isinstance(config["debridApiKey"], str):
+            return False
+
+        if not isinstance(config["indexers"], list):
+            return False
+
+        if not isinstance(config["maxResults"], int) or config["maxResults"] < 0:
+            return False
+        
+        if not isinstance(config["resolutions"], list) or len(config["resolutions"]) == 0:
+            return False
+        
+        if not isinstance(config["languages"], list) or len(config["languages"]) == 0:
+            return False
+
+        return config
+    except:
+        return False
+
+@app.get("/manifest.json")
+@app.get("/{b64config}/manifest.json")
+async def manifest():
+    return {
+        "id": "stremio.comet.fast",
+        "version": "1.0.0",
+        "name": "Comet",
+        "description": "Stremio's fastest torrent/debrid search add-on.",
+        "logo": "https://i.imgur.com/jmVoVMu.jpeg",
+        "background": "https://i.imgur.com/WwnXB3k.jpeg",
+        "resources": [
+            "stream"
+        ],
+        "types": [
+            "movie",
+            "series"
+        ],
+        "idPrefixes": [
+            "tt"
+        ],
+        "catalogs": [],
+        "behaviorHints": {
+            "configurable": True
+        }
+    }
+
+async def getIndexerManager(session: aiohttp.ClientSession, indexerManagerType: str, indexers: list, query: str):
+    try:
+        timeout = aiohttp.ClientTimeout(total=int(os.getenv("INDEXER_MANAGER_TIMEOUT", 30)))
+        results = []
+
+        if indexerManagerType == "jackett":
+            response = await session.get(f"{os.getenv('INDEXER_MANAGER_URL', 'http://127.0.0.1:9117')}/api/v2.0/indexers/all/results?apikey={os.getenv('INDEXER_MANAGER_API_KEY')}&Query={query}&Tracker[]={'&Tracker[]='.join(indexer for indexer in indexers)}", timeout=timeout)
+            response = await response.json()
+
+            for result in response["Results"]:
+                results.append(result)
+        
+        if indexerManagerType == "prowlarr":
+            getIndexers = await session.get(f"{os.getenv('INDEXER_MANAGER_URL', 'http://127.0.0.1:9696')}/api/v1/indexer", headers={
+                "X-Api-Key": os.getenv("INDEXER_MANAGER_API_KEY")
+            })
+            getIndexers = await getIndexers.json()
+
+            indexersId = []
+            for indexer in getIndexers:
+                if indexer["definitionName"] in indexers:
+                    indexersId.append(indexer["id"])
+
+            response = await session.get(f"{os.getenv('INDEXER_MANAGER_URL', 'http://127.0.0.1:9696')}/api/v1/search?query={query}&indexerIds={'&indexerIds='.join(str(indexerId) for indexerId in indexersId)}&type=search", headers={
+                "X-Api-Key": os.getenv("INDEXER_MANAGER_API_KEY")            
+            })
+            response = await response.json()
+
+            for result in response:
+                results.append(result)
+
+        return results
+    except Exception as e:
+        logger.warning(f"Exception while getting {indexerManagerType} results for {query} with {indexers}: {e}")
+
+async def getTorrentHash(session: aiohttp.ClientSession, indexerManagerType: str, torrent: dict):
+    if "InfoHash" in torrent and torrent["InfoHash"] != None:
+        return torrent["InfoHash"]
+    
+    if "infoHash" in torrent:
+        return torrent["infoHash"]
+
+    url = torrent["Link"] if indexerManagerType == "jackett" else torrent["downloadUrl"]
+
+    try:
+        timeout = aiohttp.ClientTimeout(total=int(os.getenv("GET_TORRENT_TIMEOUT", 5)))
+        response = await session.get(url, allow_redirects=False, timeout=timeout)
+        if response.status == 200:
+            torrentData = await response.read()
+            torrentDict = bencodepy.decode(torrentData)
+            info = bencodepy.encode(torrentDict[b"info"])
+            hash = hashlib.sha1(info).hexdigest()
+        else:
+            location = response.headers.get("Location", "")
+            if not location:
+                return
+
+            match = infoHashPattern.search(location)
+            if not match:
+                return
+            
+            hash = match.group(1).upper()
+
+        return hash
+    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}")
+        # logger.warning(f"Exception while getting torrent info hash for {jackettIndexerPattern.findall(url)[0]}|{jackettNamePattern.search(url)[0]}: {e}")
+
+@app.get("/stream/{type}/{id}.json")
+@app.get("/{b64config}/stream/{type}/{id}.json")
+async def stream(request: Request, b64config: str, type: str, id: str):
+    config = configChecking(b64config)
+    if not config:
+            return {
+                "streams": [
+                    {
+                        "name": "[⚠️] Comet", 
+                        "title": "Invalid Comet config.",
+                        "url": "https://comet.fast"
+                    }
+                ]
+            }
+    
+    async with aiohttp.ClientSession() as session:
+        checkDebrid = await session.get("https://api.real-debrid.com/rest/1.0/user", headers={
+            "Authorization": f"Bearer {config['debridApiKey']}"
+        })
+        checkDebrid = await checkDebrid.text()
+        if not '"type": "premium"' in checkDebrid:
+            return {
+                "streams": [
+                    {
+                        "name": "[⚠️] Comet", 
+                        "title": "Invalid Real-Debrid account.",
+                        "url": "https://comet.fast"
+                    }
+                ]
+            }
+
+        season = None
+        episode = None
+        if type == "series":
+            info = id.split(":")
+
+            id = info[0]
+            season = int(info[1])
+            episode = int(info[2])
+
+        getMetadata = await session.get(f"https://v3.sg.media-imdb.com/suggestion/a/{id}.json")
+        metadata = await getMetadata.json()
+
+        name = metadata["d"][0]["l"]
+        name = translate(name)
+
+        cacheKey = hashlib.md5(json.dumps({"debridService": config["debridService"], "name": name, "season": season, "episode": episode, "indexers": config["indexers"], "resolutions": config["resolutions"], "languages": config["languages"]}).encode("utf-8")).hexdigest()
+        cached = await database.fetch_one(f"SELECT EXISTS (SELECT 1 FROM cache WHERE cacheKey = '{cacheKey}')")
+        if cached[0] != 0:
+            logger.info(f"Cache found for {name}")
+
+            timestamp = await database.fetch_one(f"SELECT timestamp FROM cache WHERE cacheKey = '{cacheKey}'")
+            if timestamp[0] + int(os.getenv("CACHE_TTL", 86400)) < time.time():
+                await database.execute(f"DELETE FROM cache WHERE cacheKey = '{cacheKey}'")
+
+                logger.info(f"Cache expired for {name}")
+            else:
+                sortedRankedFiles = await database.fetch_one(f"SELECT results FROM cache WHERE cacheKey = '{cacheKey}'")
+                sortedRankedFiles = json.loads(sortedRankedFiles[0])
+                
+                results = []
+                for hash in sortedRankedFiles:
+                    results.append({
+                        "name": f"[RD⚡] Comet {sortedRankedFiles[hash]['data']['resolution'][0] if len(sortedRankedFiles[hash]['data']['resolution']) > 0 else 'Unknown'}",
+                        "title": f"{sortedRankedFiles[hash]['data']['title']}\n💾 {bytesToSize(sortedRankedFiles[hash]['data']['size'])}",
+                        "url": f"{request.url.scheme}://{request.url.netloc}/{b64config}/playback/{hash}/{sortedRankedFiles[hash]['data']['index']}"
+                    })
+
+                return {"streams": results}
+        else:
+            logger.info(f"No cache found for {name} with user configuration")
+
+        indexerManagerType = os.getenv("INDEXER_MANAGER_TYPE", "jackett")
+
+        logger.info(f"Start of {indexerManagerType} search for {name} with indexers {config['indexers']}")
+
+        tasks = []
+        tasks.append(getIndexerManager(session, indexerManagerType, config["indexers"], name))
+        if type == "series":
+            tasks.append(getIndexerManager(session, indexerManagerType, config["indexers"], f"{name} S0{season}E0{episode}"))
+        searchResponses = await asyncio.gather(*tasks)
+
+        torrents = []
+        for results in searchResponses:
+            if results == None:
+                continue
+
+            for result in results:
+                torrents.append(result)
+
+        logger.info(f"{len(torrents)} torrents found for {name}")
+
+        if len(torrents) == 0:
+            return {"streams": []}
+
+        tasks = []
+        filtered = 0
+        for torrent in torrents:
+            parsedTorrent = RTN.parse(torrent["Title"]) if indexerManagerType == "jackett" else RTN.parse(torrent["title"])
+            if not "All" in config["resolutions"] and len(parsedTorrent.resolution) > 0 and parsedTorrent.resolution[0] not in config["resolutions"]:
+                filtered += 1
+
+                continue
+            if not "All" in config["languages"] and not parsedTorrent.is_multi_audio and not any(language in parsedTorrent.language for language in config["languages"]):
+                filtered += 1
+
+                continue
+
+            tasks.append(getTorrentHash(session, indexerManagerType, torrent))
+    
+        torrentHashes = await asyncio.gather(*tasks)
+        torrentHashes = list(set([hash for hash in torrentHashes if hash]))
+
+        logger.info(f"{len(torrentHashes)} info hashes found for {name}")
+        
+        if len(torrentHashes) == 0:
+            return {"streams": []}
+
+        getAvailability = await session.get(f"https://api.real-debrid.com/rest/1.0/torrents/instantAvailability/{'/'.join(torrentHashes)}", headers={
+            "Authorization": f"Bearer {config['debridApiKey']}"
+        })
+
+        files = {}
+
+        availability = await getAvailability.json()
+        for hash, details in availability.items():
+            if not "rd" in details:
+                continue
+
+            if type == "series":
+                for variants in details["rd"]:
+                    for index, file in variants.items():
+                        filename = file["filename"].lower()
+                        
+                        if not isVideo(filename):
+                            continue
+
+                        filenameParsed = RTN.parse(file["filename"])
+                        if season in filenameParsed.season and episode in filenameParsed.episode:
+                            files[hash] = {
+                                "index": index,
+                                "title": file["filename"],
+                                "size": file["filesize"]
+                            }
+
+                continue
+
+            for variants in details["rd"]:
+                for index, file in variants.items():
+                    filename = file["filename"].lower()
+
+                    if not isVideo(filename):
+                        continue
+
+                    files[hash] = {
+                        "index": index,
+                        "title": file["filename"],
+                        "size": file["filesize"]
+                    }
+
+        rankedFiles = set()
+        for hash in files:
+            # try:
+            rankedFile = rtn.rank(files[hash]["title"], hash) # , remove_trash=True, correct_title=name - removed because it's not working great
+            rankedFiles.add(rankedFile)
+            # except:
+            #     continue
+        
+        sortedRankedFiles = RTN.sort_torrents(rankedFiles)
+
+        logger.info(f"{len(sortedRankedFiles)} cached files found on Real-Debrid for {name}")
+
+        if len(sortedRankedFiles) == 0:
+            return {"streams": []}
+        
+        sortedRankedFiles = {
+            key: (value.model_dump() if isinstance(value, RTN.Torrent) else value)
+            for key, value in sortedRankedFiles.items()
+        }
+        for hash in sortedRankedFiles: # needed for caching
+            sortedRankedFiles[hash]["data"]["title"] = files[hash]["title"]
+            sortedRankedFiles[hash]["data"]["size"] = files[hash]["size"]
+            sortedRankedFiles[hash]["data"]["index"] = files[hash]["index"]
+        
+        jsonData = json.dumps(sortedRankedFiles).replace("'", "''")
+        await database.execute(f"INSERT INTO cache (cacheKey, results, timestamp) VALUES ('{cacheKey}', '{jsonData}', {time.time()})")
+        logger.info(f"Results have been cached for {name}")
+        
+        results = []
+        for hash in sortedRankedFiles:
+            results.append({
+                "name": f"[RD⚡] Comet {sortedRankedFiles[hash]['data']['resolution'][0] if len(sortedRankedFiles[hash]['data']['resolution']) > 0 else 'Unknown'}",
+                "title": f"{sortedRankedFiles[hash]['data']['title']}\n💾 {bytesToSize(sortedRankedFiles[hash]['data']['size'])}",
+                "url": f"{request.url.scheme}://{request.url.netloc}/{b64config}/playback/{hash}/{sortedRankedFiles[hash]['data']['index']}"
+            })
+
+        return {
+            "streams": results
+        }
+    
+async def generateDownloadLink(debridApiKey: str, hash: str, index: str):
+    try:
+        async with aiohttp.ClientSession() as session:
+            checkBlacklisted = await session.get("https://real-debrid.com/vpn")
+            checkBlacklisted = await checkBlacklisted.text()
+
+            proxy = None
+            if "Your ISP or VPN provider IP address is currently blocked on our website" in checkBlacklisted:
+                proxy = os.getenv("DEBRID_PROXY_URL", "http://127.0.0.1:1080")
+                
+                logger.warning(f"Real-Debrid blacklisted server's IP. Switching to proxy {proxy} for {hash}|{index}")
+
+            addMagnet = await session.post(f"https://api.real-debrid.com/rest/1.0/torrents/addMagnet", headers={
+                "Authorization": f"Bearer {debridApiKey}"
+            }, data={
+                "magnet": f"magnet:?xt=urn:btih:{hash}"
+            }, proxy=proxy)
+            addMagnet = await addMagnet.json()
+
+            getMagnetInfo = await session.get(addMagnet["uri"], headers={
+                "Authorization": f"Bearer {debridApiKey}"
+            }, proxy=proxy)
+            getMagnetInfo = await getMagnetInfo.json()
+
+            selectFile = await session.post(f"https://api.real-debrid.com/rest/1.0/torrents/selectFiles/{addMagnet['id']}", headers={
+                "Authorization": f"Bearer {debridApiKey}"
+            }, data={
+                "files": index
+            }, proxy=proxy)
+
+            getMagnetInfo = await session.get(addMagnet["uri"], headers={
+                "Authorization": f"Bearer {debridApiKey}"
+            }, proxy=proxy)
+            getMagnetInfo = await getMagnetInfo.json()
+
+            unrestrictLink = await session.post(f"https://api.real-debrid.com/rest/1.0/unrestrict/link", headers={
+                "Authorization": f"Bearer {debridApiKey}"
+            }, data={
+                "link": getMagnetInfo["links"][0]
+            }, proxy=proxy)
+            unrestrictLink = await unrestrictLink.json()
+
+            return unrestrictLink["download"]
+    except Exception as e:
+        logger.warning(f"Exception while getting download link from Real Debrid for {hash}|{index}: {e}")
+
+        return "https://comet.fast"
+
+@app.head("/{b64config}/playback/{hash}/{index}")
+async def stream(b64config: str, hash: str, index: str):
+    config = configChecking(b64config)
+    if not config:
+        return
+
+    downloadLink = await generateDownloadLink(config["debridApiKey"], hash, index)
+
+    return RedirectResponse(downloadLink, status_code=302)
+    
+@app.get("/{b64config}/playback/{hash}/{index}")
+async def stream(b64config: str, hash: str, index: str):
+    config = configChecking(b64config)
+    if not config:
+        return
+
+    downloadLink = await generateDownloadLink(config["debridApiKey"], hash, index)
+
+    return RedirectResponse(downloadLink, status_code=302)

comet/templates/index.html

@@ -0,0 +1,563 @@
+<!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 {
+                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;
+            }
+
+            ::-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;
+            }
+            
+            .form-container {
+                background-color: #1a1d20;
+                padding: 2rem;
+                border-radius: 0.375rem;
+                box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
+                width: 50%;
+                margin-bottom: 50px;
+            }
+
+            .form-item {
+                margin-bottom: 0.75rem;
+            }
+
+            .centered-item {
+                display: flex;
+                justify-content: center;
+            }
+
+            .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>
+            document.addEventListener("DOMContentLoaded", function() {
+                const starsContainer = document.querySelector('.stars');
+                const isMobile = window.innerWidth <= 750;
+                const starCount = isMobile ? 30 : 30; // Reduce the number of stars on mobile because of performance issues (currently disabled because we need to find a better workarround)
+
+                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">🚀 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"></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-select id="debridService" value="realdebrid" label="Debrid Service" placeholder="Select debrid service">
+                    <sl-option value="realdebrid">Real-Debrid</sl-option>
+                </sl-select>
+            </div>
+
+            <div class="form-item">
+                <sl-input id="debridApiKey" label="Debrid API Key" placeholder="Enter API key"></sl-input>
+            </div>
+
+            <div class="centered-item">
+                <sl-button id="install" variant="neutral">Install</sl-button>
+
+                <sl-alert 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">
+                    let defaultLanguages = [];
+                    let defaultResolutions = [];
+            
+                    document.addEventListener("DOMContentLoaded", function() {
+                        fetch("/static/config.json")
+                            .then(response => response.json())
+                            .then(data => {
+                                populateSelect("indexers", data.indexers);
+                                populateSelect("languages", data.languages);
+                                populateSelect("resolutions", data.resolutions);
+            
+                                defaultLanguages = data.languages;
+                                defaultResolutions = data.resolutions;
+                            });
+                    });
+            
+                    function populateSelect(selectId, options) {
+                        const selectElement = document.getElementById(selectId);
+                        options.forEach(option => {
+                            const optionElement = document.createElement("sl-option");
+                            optionElement.value = option;
+                            optionElement.textContent = option;
+                            selectElement.appendChild(optionElement);
+                        });
+                        selectElement.value = options;
+                    }
+            
+                    const button = document.querySelector("sl-button");
+                    const alert = document.querySelector('sl-alert[variant="neutral"]');
+                    button.addEventListener("click", () => {
+                        const debridService = document.getElementById("debridService").value;
+                        const debridApiKey = document.getElementById("debridApiKey").value;
+                        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 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 settings = {
+                            debridService: debridService,
+                            debridApiKey: debridApiKey,
+                            indexers: indexers,
+                            maxResults: parseInt(maxResults),
+                            resolutions: selectedResolutions,
+                            languages: selectedLanguages
+                        };
+            
+                        navigator.clipboard.writeText(`${window.location.origin}/${btoa(JSON.stringify(settings))}/manifest.json`).then(() => {
+                            alert.toast();
+                        });
+                    });
+                </script>
+            </div>
+        </div>
+    </body>
+</html>

comet/utils/general.py

@@ -0,0 +1,36 @@
+import math
+
+translationTable = {
+    'ā': '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',
+}
+translationTable = str.maketrans(translationTable)
+
+def translate(title: str):
+    return title.translate(translationTable)
+
+def isVideo(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 bytesToSize(bytes: int):
+    sizes = ["Bytes", "KB", "MB", "GB", "TB"]
+
+    if bytes == 0:
+        return "0 Byte"
+    
+    i = int(math.floor(math.log(bytes, 1024)))
+
+    return f"{round(bytes / math.pow(1024, i), 2)} {sizes[i]}"

comet/utils/logger.py

@@ -0,0 +1,26 @@
+import sys
+from loguru import logger
+
+def setupLogger(level: str):
+    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")