Upload 2 files

sources/filemoon.py

@@ -0,0 +1,36 @@
+import re
+import requests
+from utils import Utilities
+from typing import Optional, Tuple, Dict, Any
+
+class FilemoonExtractor:
+    @staticmethod
+    def unpack(p: str, a: int, c: int, k: list, e: Optional[Any]=None, d: Optional[Any]=None) -> str:
+        for i in range(c-1, -1, -1):
+            if k[i]: p = re.sub("\\b"+Utilities.int_2_base(i,a)+"\\b", k[i], p)
+        return p
+
+    def resolve_source(self, url: str, **kwargs: Dict[str, Any]) -> Tuple[Optional[str], None, Optional[str]]:
+        req = requests.get(url)
+        if req.status_code != 200:
+            print(f"[FilemoonExtractor] Failed to retrieve media, status code: {req.status_code}...")
+            return None, None, None
+
+        matches = re.search(r"eval\(function\(p,a,c,k,e,d\).*?\}\('(.*?)'\.split", req.text)
+        if not matches:
+            print("[FilemoonExtractor] Failed to retrieve media, could not find eval function...")
+            return None, None, None
+        
+        DE_packer_args = re.search(r"^(.*?}\);)\',(.*?),(.*?),'(.*?)$", matches.group(1))
+        processed_matches = list(DE_packer_args.groups())
+        processed_matches[1] = int(processed_matches[1])
+        processed_matches[2] = int(processed_matches[2])
+        processed_matches[3] = processed_matches[3].split("|")
+
+        unpacked = self.unpack(*processed_matches)
+        hls_urls = re.findall(r"\{file:\"([^\"]*)\"\}", unpacked)
+
+        # hls_filename = hls_urls[0].split("?")[0].rsplit("/")[-1]
+        # mp4_url = hls_urls[0].replace("hls2", "download") #.replace(hls_filename, "media") # filename is arbitrary
+        
+        return hls_urls, None, url

sources/vidplay.py

@@ -0,0 +1,73 @@
+import re
+import json
+import base64
+import requests
+from urllib.parse import unquote
+from typing import Optional, Tuple, Dict, List
+from utils import Utilities, CouldntFetchKeys
+
+class VidplayExtractor:
+    KEY_URL = "https://github.com/Ciarands/vidsrc-keys/blob/main/keys.json"
+
+    @staticmethod
+    def get_futoken(key: str, url: str, provider_url: str) -> str:
+        req = requests.get(f"{provider_url}/futoken", headers={"Referer": url})
+        fu_key = re.search(r"var\s+k\s*=\s*'([^']+)'", req.text).group(1)
+        
+        return f"{fu_key},{','.join([str(ord(fu_key[i % len(fu_key)]) + ord(key[i])) for i in range(len(key))])}"
+    
+    @staticmethod
+    def get_vidplay_subtitles(url_data: str) -> Dict:
+        subtitles_url = re.search(r"info=([^&]+)", url_data)
+        if not subtitles_url:
+            return {}
+        
+        subtitles_url_formatted = unquote(subtitles_url.group(1))
+        req = requests.get(subtitles_url_formatted)
+        
+        if req.status_code == 200:
+            return {subtitle.get("label"): subtitle.get("file") for subtitle in req.json()}
+        
+        return {}
+
+    @staticmethod
+    def encode_id(v_id: str) -> str:
+        req = requests.get(VidplayExtractor.KEY_URL)
+
+        if req.status_code != 200:
+            raise CouldntFetchKeys("Failed to fetch decryption keys!")
+        
+        matches = re.search(r"\"rawLines\":\s*\[\"(.+)\"\]", req.text)
+        if not matches:
+            raise CouldntFetchKeys("Failed to extract rawLines from keys page!")
+
+        key1, key2 = json.loads(matches.group(1).replace("\\", ""))
+        decoded_id = Utilities.decode_data(key1, v_id)
+        encoded_result = Utilities.decode_data(key2, decoded_id)
+        
+        encoded_base64 = base64.b64encode(encoded_result)
+        decoded_result = encoded_base64.decode("utf-8")
+
+        return decoded_result.replace("/", "_")
+    
+    def resolve_source(self, url: str, fetch_subtitles: bool, provider_url: str) -> Tuple[Optional[List], Optional[Dict], Optional[str]]:
+        url_data = url.split("?")
+
+        subtitles = {}
+        if fetch_subtitles:
+            subtitles = self.get_vidplay_subtitles(url_data[1])
+
+        key = self.encode_id(url_data[0].split("/e/")[-1])
+        futoken = self.get_futoken(key, url, provider_url)
+        
+        req = requests.get(f"{provider_url}/mediainfo/{futoken}?{url_data[1]}&autostart=true", headers={"Referer": url})
+        if req.status_code != 200:
+            print(f"[VidplayExtractor] Failed to retrieve media, status code: {req.status_code}...")
+            return None, None, None
+
+        req_data = req.json()
+        if (req_data.get("result")) and (type(req_data.get("result")) == dict):
+            sources = req_data.get("result").get("sources")
+            return [value.get("file") for value in sources], subtitles, url
+        
+        return None, None, None