a

Dockerfile

@@ -8,7 +8,7 @@ WORKDIR /app
 ADD . /app
 # Install any needed packages specified in requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt
-#EXPOSE the port
+#EXPOSE the port, for now default is 8080 cause it's the only one really allowed by HuggingFace
 EXPOSE 8080
 
 # Run run.py when the container launches

config.json

@@ -3,16 +3,19 @@
            "StreamingCommunity": {
                "enabled": "1",    
                "domain": "boston",
-               "fast_search": "0"
+               "fast_search": "1"
            },
            "Filmpertutti": {
                "enabled": "0",    
                "domain": "makeup"
            },
-           "Tantifilm":{
+           "Tuttifilm":{
                "enabled": "1",    
                "domain": "bond",
                "fast_search": "0"
+           },
+           "Mysterius":{
+               "enabled": "0"    
            }
    },
    "General":{

config.py

@@ -10,10 +10,13 @@ with open('config.json') as f:
 SITE = config["Siti"]
 FT_DOMAIN = SITE["Filmpertutti"]['domain']
 SC_DOMAIN = SITE["StreamingCommunity"]['domain']
-TF_DOMAIN = SITE["Filmpertutti"]['enabled']
+TF_DOMAIN = SITE["Tuttifilm"]['enabled']
 FILMPERTUTTI = SITE["Filmpertutti"]['enabled']
 STREAMINGCOMMUNITY = SITE["StreamingCommunity"]['enabled']
+MYSTERIUS = SITE["Mysterius"]['enabled']
+TUTTIFILM = SITE["Tuttifilm"]['enabled']
 SC_FAST_SEARCH = SITE["StreamingCommunity"]['fast_search']
+TF_FAST_SEARCH = SITE["Tuttifilm"]['fast_search']
 #General
 GENERAL = config['General']
 dotenv = GENERAL["load_env"]

convert.py

@@ -1,7 +1,7 @@
-import requests
+import requests 
 from tmdbv3api import TMDb, Movie, TV
 from loadenv import load_env
-TMDB_KEY= load_env()
+TMDB_KEY,_= load_env()
 def get_TMDb_id_from_IMDb_id(imdb_id):  
     response = requests.get(f'https://api.themoviedb.org/3/find/{imdb_id}', 
                             params={'external_source': 'imdb_id', 'api_key': f'{TMDB_KEY}'})

cool.py

@@ -0,0 +1,139 @@
+import requests
+import json
+from info import get_info_tmdb,is_movie
+from convert import get_TMDb_id_from_IMDb_id
+from loadenv import load_env
+_,MYSTERIUS_KEY = load_env()
+def get_links(slug,season,episode,ismovie):
+    try:
+        headers = {
+            "x-api-key": MYSTERIUS_KEY
+        }
+        response = requests.get("https://mythus-ulala1243.hf.space/api/cookie", headers=headers)
+        print(response.text)
+        Auths = response.json()
+        Bearer = Auths.get('cookie')
+        ap_session = Auths.get('auth')
+
+        cookies = {'ap_session': ap_session}
+
+        headers = {
+            'accept': 'application/json, text/plain, */*',
+            'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+            'authorization': f'Bearer {Bearer}',
+            'referer': f'https://altadefinizione-originale.com/play/{slug}',
+            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 OPR/111.0.0.0',
+            'x-requested-with': 'XMLHttpRequest',
+        }
+        if ismovie == 1:
+
+            response = requests.get(f'https://altadefinizione-originale.com/api/post/urls/stream/{slug}',cookies=cookies,headers=headers)
+        elif ismovie == 0:
+            response = requests.get(f'https://altadefinizione-originale.com/api/post/urls/stream/{slug}/{{season}}/{{episode}}',cookies=cookies,headers=headers)
+        try:
+            video_data = response.json()  # Assuming this is the JSON response containing video streams
+
+            if 'streams' not in video_data:
+                print("Invalid JSON format: 'streams' key not found or incorrect structure")
+                return None
+            
+            streams = video_data['streams']
+
+            resolutions = {}
+
+            for stream in streams:
+                resolution_name = stream['resolution']['name'].lower()  # Convert resolution name to lowercase
+                url = stream['url']
+
+                # Remove everything after '.mp4' in the URL
+                mp4_index = url.find('.mp4')
+                if mp4_index != -1:
+                    url = url[:mp4_index + 4]  # +4 to include '.mp4' in the substring
+
+                resolutions[resolution_name] = url
+            
+            return resolutions
+
+        except KeyError as e:
+            print(f"KeyError: {e}")
+            return None
+        except json.JSONDecodeError as e:
+            print(f"JSONDecodeError: {e}")
+            return None
+
+    except requests.RequestException as e:
+        print(f"Request error: {e}")
+        return None
+    
+
+# Example usage: Fetch video links
+
+
+# Print the dictionary
+
+
+
+
+
+def search_imdb(showname,tmdba):
+        tmdba = str(tmdba)
+        query = f'https://altadefinizione-originale.com/api/search?search={showname}&page=1'
+        response = requests.get(query)
+        if response.status_code == 200:
+            data = response.json()
+            if 'data' in data:
+                for item in data['data']:
+                    if item.get('tmdb_id') == tmdba:
+                        slug = item.get('slug')
+                        print(slug)
+                        return slug
+                    
+
+
+def parse_links(resolution_links):  
+    results = {}      
+    if resolution_links:
+        print("Video links:")
+        for resolution, link in resolution_links.items():
+            print(f"{resolution}: {link}")
+            results[resolution] = link
+        return results    
+    else:
+        print("Failed to fetch video links")
+
+
+def cool(imdb):
+    try:
+        type = "Cool"    
+        general = is_movie(imdb)
+        ismovie = general[0]
+        imdb_id = general[1]
+        if ismovie == 0 : 
+            season = int(general[2])
+            episode = int(general[3])
+        
+        if "tt" in imdb:
+                #Get showname
+            tmdba = get_TMDb_id_from_IMDb_id(imdb_id)
+        else:
+            tmdba = imdb_id.replace("tmdb:","")
+
+        showname = get_info_tmdb(tmdba,ismovie,type)
+        
+
+        slug = search_imdb(showname,tmdba)
+        if ismovie == 1:
+            season = None
+            episode = None
+            resolution_links = get_links(slug,episode,season,ismovie)
+            results = parse_links(resolution_links)
+            return results
+        elif ismovie == 0:
+            season = season -1
+            episode = episode - 1
+            resolution_links = get_links(slug,episode,season,ismovie)
+            results = parse_links(resolution_links)
+            return results
+    except Exception as e:
+        print("Cool Error")
+        return None

example.env

@@ -0,0 +1,3 @@
+TMDB_KEY= "INSERT YOUR API KEY HERE"
+
+

info.py

@@ -4,7 +4,8 @@ from convert_date import convert_US_date, convert_IT_date
 import requests
 import config
 SC_FAST_SEARCH = config.SC_FAST_SEARCH
-TMDB_KEY= load_env()
+TF_FAST_SEARCH = config.TF_FAST_SEARCH
+TMDB_KEY,_= load_env()
 
 def get_info_tmdb(tmbda,ismovie,type):
     tmdb = TMDb()
@@ -22,19 +23,41 @@ def get_info_tmdb(tmbda,ismovie,type):
             if SC_FAST_SEARCH == "0":
                 n_season = show.number_of_seasons
                 return showname,n_season
+            else:
+                return showname
+        elif type == "Tuttifilm":
+            if TF_FAST_SEARCH == "0":
+                date = show.first_air_date
+                date = date.split("-")[0]
+                print("Real date",date)
+                return showname,date
+            else:
+                return showname
+        elif type == "Cool":
+            return showname
             
-    else:
+    elif ismovie == 1:
         movie = Movie()
         show= movie.details(tmbda)
         showname= show.title
         #Get all release dates
-        date = show.release_dates
         if type == "Filmpertutti":
+            date = show.release_dates
             #GET US RELEASE DATE because filmpertutti somewhy uses US release date
             date = convert_US_date(date)
-    return showname,date
-
-
+            return showname,date
+        elif type == "StreamingCommunity":
+            return showname
+        elif type == "Tuttifilm":
+            if TF_FAST_SEARCH == "0":
+                date = show.release_date
+                date = date.split("-")[0]
+                print("Real date",date)
+                return showname,date
+            else:
+                return showname
+        elif type == "Cool":
+            return showname
 
 
 def get_info_imdb(imdb_id, ismovie, type):
@@ -49,6 +72,12 @@ def get_info_imdb(imdb_id, ismovie, type):
             return showname, date
         elif type == "StreamingCommunity":
             return showname
+        elif type == "Tuttifilm":
+            date = data['tv_results'][0]['first_air_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "Cool":
+            return showname
 
     elif ismovie == 1:
         showname= data['movie_results'][0]['title']
@@ -56,6 +85,14 @@ def get_info_imdb(imdb_id, ismovie, type):
             return
         elif type == "StreamingCommunity":
             return showname
+        elif type == "Tuttifilm":
+            date = data['movie_results'][0]['release_date']
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+        elif type == "Cool":
+            return showname
+
             
 
 

loadenv.py

@@ -1,6 +1,7 @@
 import os
 import config
-
+import config
+MYSTERIUS = config.MYSTERIUS  
 dotenv = config.dotenv
 #You need to keep dotenv disabled on remote servers
 if dotenv == "1":
@@ -10,4 +11,7 @@ if dotenv == "1":
 
 def load_env():
     TMDB_KEY = os.getenv('TMDB_KEY')
+    if MYSTERIUS == "1":
+        MYSTERIUS_KEY = os.getenv('MYSTERIUS_KEY')
+        return TMDB_KEY, MYSTERIUS_KEY
     return TMDB_KEY

requirements.txt

@@ -1,6 +1,6 @@
 bs4
 tmdbv3api
 dateparser
+python-dotenv
 flask
-requests
 lxml

run.py

@@ -1,14 +1,17 @@
 from flask import Flask, jsonify, abort
 from filmpertutti import filmpertutti
 from streamingcommunity import streaming_community
+from tantifilm import tantifilm
 import json
 import config
-
 FILMPERTUTTI = config.FILMPERTUTTI
 STREAMINGCOMMUNITY = config.STREAMINGCOMMUNITY
+MYSTERIUS = config.MYSTERIUS
+TUTTIFILM = config.TUTTIFILM
 HOST = config.HOST
 PORT = int(config.PORT)
-
+if MYSTERIUS == "1":
+    from cool import cool
 
 
 app = Flask(__name__)
@@ -45,19 +48,26 @@ def addon_stream(type, id):
     if type not in MANIFEST['types']:
         abort(404) 
     streams = {'streams': []}
+    if MYSTERIUS == "1":
+        results = cool(id)
+        if results:
+            for resolution, link in results.items():
+                streams['streams'].append({'title': f'Mysterious {resolution}', 'url': link})
     if STREAMINGCOMMUNITY == "1":
         url_streaming_community = streaming_community(id)
         print(url_streaming_community)
         if url_streaming_community is not None:
-            streams['streams'].append({'title': 'HF StreamingCommunity 1080p', 'url': f'{url_streaming_community}?rendition=1080p'})
-            streams['streams'].append({'title': 'HF StreamingCommunity 720p', 'url': f'{url_streaming_community}?rendition=720p'})
+            streams['streams'].append({'title': 'StreamingCommunity 1080p', 'url': f'{url_streaming_community}?rendition=1080p'})
+            streams['streams'].append({'title': 'StreamingCommunity 720p', 'url': f'{url_streaming_community}?rendition=720p'})
             
     # If FILMPERTUTTI == 1, scrape that site      
     if FILMPERTUTTI == "1":
         url_filmpertutti = filmpertutti(id)
         if url_filmpertutti is not None:
             streams['streams'].append({'title': 'Filmpertutti', 'url': url_filmpertutti})
-    
+    if TUTTIFILM == "1":
+        url_tuttifilm = tantifilm(id)
+        streams['streams'].append({'title': 'Tantifilm', 'url': url_tuttifilm,'behaviorHints': {'proxyHeaders': {"request": {"Referer": "https://d000d.com/"}},'notWebReady': True}})
     # If no streams were added, abort with a 404 error
     if not streams['streams']:
         abort(404)

streamingcommunity.py

@@ -36,15 +36,19 @@ def get_version():
         version = "65e52dcf34d64173542cd2dc6b8bb75b"
         return version
 
-def search(query,n_season):
+def search(query,n_season,ismovie):
     #Do a request to get the ID of serie/move and it's slug in the URL
     response = requests.get(query).json()
     for item in response['data']:
         tid = item['id']
         slug = item['slug']
-        number_of_seasons = item['seasons_count']
+        idk = item['seasons_count'] 
         if SC_FAST_SEARCH == "0":
-            if number_of_seasons == n_season:
+            if ismovie == 0:
+                seasons_count = item['seasons_count']
+                if seasons_count == n_season:
+                    return tid,slug
+            elif ismovie == 1:
                 return tid,slug
         elif SC_FAST_SEARCH == "1":
             return tid,slug
@@ -98,40 +102,56 @@ def get_episode_link(episode_id,tid):
 
 
 def streaming_community(imdb):
-    general = is_movie(imdb)
-    ismovie = general[0]
-    imdb_id = general[1]
-    type = "StreamingCommunity"
-    if ismovie == 0 : 
-        season = int(general[2])
-        episode = int(general[3])
-        #Check if fast search is enabled or disabled
-        if SC_FAST_SEARCH == "1":
+    try:
+        general = is_movie(imdb)
+        ismovie = general[0]
+        imdb_id = general[1]
+        type = "StreamingCommunity"
+        if ismovie == 0 : 
+            season = int(general[2])
+            episode = int(general[3])
+            #Check if fast search is enabled or disabled
+            if SC_FAST_SEARCH == "1":
+                if "tt" in imdb:
+                #Get showname
+                    showname = get_info_imdb(imdb_id,ismovie,type)
+                    n_season = None
+                else:
+                    #I just set n season to None to avoid bugs, but it is not needed if Fast search is enabled
+                    n_season = None
+                    #else just equals them
+                    tmdba = imdb_id.replace("tmdb:","")
+                    showname = get_info_tmdb(tmdba,ismovie,type)
+            elif SC_FAST_SEARCH == "0":
+                tmdba = get_TMDb_id_from_IMDb_id(imdb_id)
+                showname,n_season = get_info_tmdb(tmdba,ismovie,type)  
+        #HERE THE CASE IF IT IS A MOVIE
+        else:
             if "tt" in imdb:
-            #Get showname
-                showname = get_info_imdb(imdb_id,ismovie,type)
+                #Get showname
                 n_season = None
+                showname = get_info_imdb(imdb_id,ismovie,type)
             else:
-                #I just set n season to None to avoid bugs, but it is not needed if Fast search is enabled
-                n_season = None
-                #else just equals them
-                tmdba = imdb_id.replace("tmdb:","")
-                showname = get_info_tmdb(tmdba,ismovie,type)
-        elif SC_FAST_SEARCH == "0":
-            tmdba = get_TMDb_id_from_IMDb_id(imdb_id)
-            showname,n_season = get_info_tmdb(tmdba,ismovie,type)   
-    showname = showname.replace(" ", "+").replace("–", "+").replace("—","+")
-    query = f'https://streamingcommunity.{SC_DOMAIN}/api/search?q={showname}'
-    tid,slug = search(query,n_season)
-    if ismovie == 1:
-        #TID means temporaly ID
-        url = get_film(tid)
-        print(url)
-        return url
-    if ismovie == 0:
-        #Uid = URL ID
-        version = get_version()
-        episode_id = get_season_episode_id(tid,slug,season,episode,version)
-        url = get_episode_link(episode_id,tid)
-        print(url)
-        return url
+                    #I just set n season to None to avoid bugs, but it is not needed if Fast search is enabled
+                    #else just equals them
+                    n_season = None
+                    tmdba = imdb_id.replace("tmdb:","")
+                    showname = get_info_tmdb(tmdba,ismovie,type) 
+
+        showname = showname.replace(" ", "+").replace("–", "+").replace("—","+")
+        query = f'https://streamingcommunity.{SC_DOMAIN}/api/search?q={showname}'
+        tid,slug = search(query,n_season,ismovie)
+        if ismovie == 1:
+            #TID means temporaly ID
+            url = get_film(tid)
+            print(url)
+            return url
+        if ismovie == 0:
+            #Uid = URL ID
+            version = get_version()
+            episode_id = get_season_episode_id(tid,slug,season,episode,version)
+            url = get_episode_link(episode_id,tid)
+            print(url)
+            return url
+    except Exception as e:
+        print("Nope It failed")

tantifilm.py

@@ -0,0 +1,224 @@
+import requests
+from bs4 import BeautifulSoup,SoupStrainer
+import re
+import time
+from info import is_movie,get_info_imdb,get_info_tmdb
+import config
+TF_FAST_SEARCH = config.TF_FAST_SEARCH
+TF_DOMAIN = config.TF_DOMAIN
+
+
+##FOR NOW ONLY MOVIES WORK, I HOPE I CAN FIX SERIES
+def search(showname,ismovie,season,episode,date):
+    url = f'https://www.tanti.bond/search/{showname}'
+    response = requests.get(url)
+    soup = BeautifulSoup(response.text, "lxml")
+    if ismovie == 1:
+        all_link = soup.select('#movies .col .list-media')
+        for link in all_link:
+            url = link['href']
+            response = requests.get(url)
+            pattern = r'Data di rilascio\s*</div>\s*<div class="text">\s*(\d{4})\s*</div>'
+            found_date = re.search(pattern, response.text)
+            release_date = str(found_date.group(1))
+            print(release_date)
+            if release_date == date:
+                tid= url.split('-')[1]
+                print(tid)
+                #Return URL and even the soup so I can use it later
+                #I try to get doodstream link inside this function so I do not have to get again the response
+                print(url)
+                return tid
+    elif ismovie == 0: 
+        all_link = soup.select('#series .col .list-media')
+        for link in all_link:
+            base_url = link['href']
+            url = f'{base_url}-{season}-season-{episode}-episode'
+            response = requests.get(url)
+            pattern = r'Data di rilascio\s*</div>\s*<div class="text">\s*(\d{4})\s*</div>'
+            found_date = re.search(pattern, response.text)
+            release_date = str(found_date.group(1))
+            if release_date == date:
+                print("RELEASE DATE IS EQUAL")
+                tid= url.split('-')[1]
+                print(tid)
+                #I try to get doodstream link inside this function so I do not have to get again the response
+                return tid
+
+
+
+def get_protect_link(id):
+    #Get the link where the Iframe is located, which contains the doodstream url kind of. 
+    response = requests.get(f"https://p.hdplayer.casa/myadmin/play.php?id={id}")
+    soup = BeautifulSoup(response.text, "lxml", parse_only=SoupStrainer('iframe'))
+    print(soup)
+    protect_link = soup.iframe['src'] 
+    print("HERE PROTECT_LINK",protect_link)
+    return  protect_link
+
+
+
+def true_url(protect_link):
+    # Define headers
+    headers = {
+        "Range": "bytes=0-",
+        "Referer": "https://d000d.com/",
+    }
+    response = requests.get(protect_link)
+    link = response.url
+    #Get the ID
+    doodstream_id = link.rsplit('/e/', 1)[-1]
+    # Make a GET request
+    
+    if response.status_code == 200:
+        # Get unique timestamp for the request      
+        real_time = str(int(time.time()))
+
+        # Regular Expression Pattern for the match
+        pattern = r"(\/pass_md5\/.*?)'.*(\?token=.*?expiry=)"
+        
+        # Find the match 
+        match = re.search(pattern, response.text, re.DOTALL)
+
+        # If a match was found
+        if match:
+            # Create real link (match[0] includes all matched elements)
+            url =f'https://d000d.com{match[1]}'
+            rebobo = requests.get(url, headers=headers)
+            real_url = f'{rebobo.text}123456789{match[2]}{real_time}'
+            print(real_url)
+            return real_url
+        else:
+            print("No match found in the text.")
+            return None
+  
+    print("Error: Could not get the response.")
+    return None
+
+
+
+
+#Get temporaly ID
+def tantifilm(imdb):
+    try:
+        general = is_movie(imdb)
+        ismovie = general[0]
+        imdb_id = general[1]
+        type = "Tuttifilm"
+        if ismovie == 0 : 
+            print("Series not supported yet")
+            return
+            season = int(general[2])
+            episode = int(general[3])
+            if "tt" in imdb:
+                if TF_FAST_SEARCH == "0":
+                    showname,date = get_info_imdb(imdb_id,ismovie,type)
+                elif TF_FAST_SEARCH == "1":
+                    showname = get_info_imdb(imdb_id,ismovie,type)
+                    date = None
+            else:
+                    #else just equals them
+                    tmdba = imdb_id.replace("tmdb:","")
+                    if TF_FAST_SEARCH == "0":
+                        showname = get_info_tmdb(tmdba,ismovie,type)
+                        date = None
+        elif ismovie == 1:
+            season = None
+            episode = None
+            if "tt" in imdb:
+                #Get showname
+                    if TF_FAST_SEARCH == "0":
+                        showname,date = get_info_imdb(imdb_id,ismovie,type)
+                    
+                    elif TF_FAST_SEARCH == "1":
+                        showname = get_info_imdb(imdb_id,ismovie,type)
+                        date = None
+            else:
+            
+                #else just equals themtantifilm("tt2096673")
+
+                if TF_FAST_SEARCH == "0":
+                    showname,date = get_info_tmdb(imdb,ismovie,type)
+                    date = None
+                elif TF_FAST_SEARCH == "1":
+                    showname = get_info_tmdb(imdb,ismovie,type)
+                    date = None
+    
+        tid = search(showname,ismovie,season,episode,date)
+        protect_link = get_protect_link(tid)
+        url = true_url(protect_link)
+        return url
+
+    except Exception as e:
+        print("Tantifilm Error")
+ 
+
+
+
+
+
+
+
+
+
+
+
+#OLD SEARC THAT DOESN't CHECK THE DATE
+def mamma(showname,ismovie,season,episode):
+    url = f'https://www.tanti.bond/search/{showname}'
+    response = requests.get(url)
+    soup = BeautifulSoup(response.text, "lxml")
+    if ismovie == 1:
+        first_link = soup.select_one('#movies .col .list-media')
+        url = first_link['href']
+        return url
+    elif ismovie == 0: 
+        first_link = soup.select_one('#series .col .list-media')
+        base_url = first_link['href']
+        url = f'{base_url}-{season}-{episode}'
+        print(url)
+        return url
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def searcht(showname,ismovie,season,episode):
+    url = f'https://www.tanti.bond/search/{showname}'
+    response = requests.get(url)
+    soup = BeautifulSoup(response.text, "lxml")
+    date = "2020"
+    if ismovie == 1:
+        all_link = soup.select('#movies .col .list-media')
+        for link in all_link:
+            url = link['href']
+            response = requests.get(url)
+            info_soup = BeautifulSoup(response.text, "lxml")
+            release_date= info_soup.select('div.video-attr div.text')[4].text.strip()
+            if release_date == date:
+                print("WOW")
+                #Return URL and even the soup so I can use it later
+                return url,info_soup
+    elif ismovie == 0: 
+        all_link = soup.select('#series .col .list-media')
+        for link in all_link:
+            base_url = link['href']
+            url = f'{base_url}-{season}-season-{episode}-episode'
+            response = requests.get(url)
+            info_soup = BeautifulSoup(response.text, "lxml")
+            release_date= info_soup.select('div.video-attr div.text')[4].text.strip()
+            if release_date == date:
+                print("RELEASE DATE IS EQUAL")
+                #Return URL and even the soup so I can use it later
+                return url,info_soup