Upload 8 files

config.json

@@ -0,0 +1,28 @@
+{
+    "Siti": {
+           "StreamingCommunity": {
+               "enabled": "1",    
+               "domain": "photos",
+               "fast_search": "0"
+           },
+           "Filmpertutti": {
+               "enabled": "0",    
+               "domain": "makeup"
+           },
+           "Tuttifilm":{
+               "enabled": "1",    
+               "domain": "bond",
+               "fast_search": "0"
+           },
+           "Mysterius":{
+               "enabled": "0"    
+           }
+   },
+   "General":{
+       "load_env": "0",
+       "HOST": "0.0.0.0",
+       "PORT": "8080",
+       "HF": "0"
+   }
+   }
+   

config.py

@@ -0,0 +1,25 @@
+#LOAD THE CONFIG
+import json
+
+# Open the configuration file
+with open('config.json') as f:
+    # Load JSON data from file
+    config = json.load(f)
+
+# Accessing SC_DOMAIN
+SITE = config["Siti"]
+FT_DOMAIN = SITE["Filmpertutti"]['domain']
+SC_DOMAIN = SITE["StreamingCommunity"]['domain']
+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"]
+HOST = GENERAL["HOST"]
+PORT = GENERAL["PORT"]
+HF = GENERAL["HF"]

convert.py

@@ -0,0 +1,19 @@
+import requests 
+from tmdbv3api import TMDb, Movie, TV
+from loadenv import load_env
+import config
+MYSTERIUS = config.MYSTERIUS
+if MYSTERIUS == "1":
+    TMDB_KEY,_= load_env()
+else:
+    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}'})
+    tmbda = response.json()
+    if tmbda['movie_results']:
+        return tmbda['movie_results'][0]['id']
+    elif tmbda['tv_results']:
+        return tmbda['tv_results'][0]['id']
+    else:
+        return None

filmpertutti.py

@@ -0,0 +1,136 @@
+
+from tmdbv3api import TMDb, Movie, TV
+import requests 
+from bs4 import BeautifulSoup,SoupStrainer
+import string
+import re
+from datetime import datetime
+import dateparser
+from convert import get_TMDb_id_from_IMDb_id
+from info import get_info_tmdb, is_movie, get_info_imdb
+from convert_date import convert_US_date
+import logging
+import config
+
+FT_DOMAIN = config.FT_DOMAIN
+
+#Some basic headers
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.10; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+    'Accept-Language': 'en-US,en;q=0.5'
+}
+#Map months to check if date = date
+month_mapping = {
+    'Jan': 'Gennaio', 'Feb': 'Febbraio', 'Mar': 'Marzo', 'Apr': 'Aprile',
+    'May': 'Maggio', 'Jun': 'Giugno', 'Jul': 'Luglio', 'Aug': 'Agosto',
+    'Sep': 'Settembre', 'Oct': 'Ottobre', 'Nov': 'Novembre', 'Dec': 'Dicembre'
+}
+
+def search(query,date):
+    response = requests.get(query).json()
+    #Get link tid of every item and then open the link to see if the date = date
+    for json in response:
+        link = json['link']
+        tid = json['id']
+        series_response = requests.get(link, headers=headers)
+        series_soup = BeautifulSoup(series_response.text, 'lxml')
+        release_span = series_soup.find('span', class_='released')
+        if release_span:
+            if release_span.text != "Data di uscita: N/A":
+                date_string = release_span.text.split(': ')[-1]  # Get the date part
+            for eng, ita in month_mapping.items():
+                date_string = re.sub(rf'\b{eng}\b', ita, date_string)
+
+    # Swap to YY-MM-DD formatting using dateparser
+        release_date = dateparser.parse(date_string, languages=['it']).strftime("%Y-%m-%d")
+        if release_date == date:
+            url = link
+            tid = tid
+            return url, tid 
+        else:
+            print("Date are not equals")
+
+def get_episode_link(season,episode,tid,url): 
+    #Get the link from where we have to obtain mixdrop link
+    tlink = f'{url}?show_video=true&post_id={tid}&season_id={season-1}&episode_id={episode-1}'
+    return tlink
+
+
+def get_film(url):
+    #Get the link from where we have to obtain mixdrop link
+    tlink = url + "?show_video=true"
+    return tlink
+
+def get_real_link(tlink):
+    #Some basic code to get the mixdrop link
+    page = requests.get(tlink, headers=headers)
+    soup = BeautifulSoup(page.content, features="lxml",parse_only=SoupStrainer('iframe'))
+    iframe_src = soup.find('iframe')['src']
+
+    iframe_page = requests.get(iframe_src, headers=headers)
+    iframe_soup = BeautifulSoup(iframe_page.content, features="lxml")
+
+    mega_button = iframe_soup.find('div', attrs={'class': 'megaButton', 'rel': 'nofollow'}, string='MIXDROP')
+    if mega_button:
+        real_link = mega_button.get('meta-link')
+        return real_link
+    
+def get_true_link(real_link):
+    response = requests.get(real_link, headers=headers)
+    [s1, s2] = re.search(r"\}\('(.+)',.+,'(.+)'\.split", response.text).group(1, 2)
+    schema = s1.split(";")[2][5:-1]
+    terms = s2.split("|")
+    charset = string.digits + string.ascii_letters
+    d = dict()
+    for i in range(len(terms)):
+        d[charset[i]] = terms[i] or charset[i]
+    s = 'https:'
+    for c in schema:
+        s += d[c] if c in d else c
+    return s
+
+def filmpertutti(imdb):
+    general = is_movie(imdb)
+    ismovie = general[0]
+    imdb_id = general[1]
+    type = "Filmpertutti"
+    if ismovie == 0 : 
+        season = int(general[2])
+        episode = int(general[3])
+    if "tt" in imdb:
+        if ismovie == 0:
+        #Get showname and date
+            showname,date = get_info_imdb(imdb_id,ismovie,type)
+        else:
+            #THIS IS needed cause the only way to get all releases dates is by giving a tmdb ID not a IMDB
+            tmdba = get_TMDb_id_from_IMDb_id(imdb_id)
+            showname,date = get_info_tmdb(tmdba,ismovie,type)
+
+    elif "tmdb" in imdb:
+        #Get showname and date
+        tmdba = imdb_id.replace("tmdb:","")
+        showname,date = get_info_tmdb(tmdba,ismovie,type)
+    showname = showname.replace(" ", "+").replace("–", "+").replace("—","+")
+    #Build the query
+    query = f'https://filmpertutti.{FT_DOMAIN}/wp-json/wp/v2/posts?search={showname}&page=1&_fields=link,id'
+    try:
+        url,tid = search(query,date)
+    except:
+        print("No results found")
+        return None
+    if ismovie == 0:
+        episode_link = get_episode_link(season,episode,tid,url)
+        #Let's get mixdrop link 
+        real_link = get_real_link(episode_link)
+        #let's get delivery link, streaming link
+        streaming_link = get_true_link(real_link)
+        print(streaming_link)
+        return streaming_link
+    elif ismovie == 1:
+        film_link = get_film(url)
+        #Let's get mixdrop link
+        real_link = get_real_link(film_link)
+        #let's get delivery link, streaming link
+        streaming_link = get_true_link(real_link)
+        print(streaming_link)
+        return streaming_link

info.py

@@ -0,0 +1,121 @@
+from loadenv import load_env
+from tmdbv3api import TMDb, Movie, TV
+from convert_date import convert_US_date, convert_IT_date
+import requests
+import config
+SC_FAST_SEARCH = config.SC_FAST_SEARCH
+TF_FAST_SEARCH = config.TF_FAST_SEARCH
+MYSTERIUS = config.MYSTERIUS
+if MYSTERIUS == "1":
+    TMDB_KEY,_= load_env()
+else:
+    TMDB_KEY= load_env()
+
+def get_info_tmdb(tmbda,ismovie,type):
+    tmdb = TMDb()
+    tmdb.api_key = f'{TMDB_KEY}'
+    tmdb.language = 'it'
+    if ismovie == 0:
+        tv = TV()
+        show= tv.details(tmbda)
+        showname = show.name
+        if type == "Filmpertutti":
+            date= show.first_air_date
+            print("Real date",date)
+            return showname,date
+        elif type == "StreamingCommunity":
+            if SC_FAST_SEARCH == "0":
+                n_season = show.number_of_seasons
+                full_date = show.first_air_date
+                date = full_date.split("-")[0]
+                print(date)
+                return showname,date
+            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
+    
+    elif ismovie == 1:
+        movie = Movie()
+        show= movie.details(tmbda)
+        showname= show.title
+        #Get all 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
+        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):
+
+    resp = requests.get(f'https://api.themoviedb.org/3/find/{imdb_id}?api_key={TMDB_KEY}&language=it&external_source=imdb_id')
+    data = resp.json()
+    if ismovie == 0:     
+        showname = data['tv_results'][0]['name']
+        if type == "Filmpertutti":
+            date= data['tv_results'][0]['first_air_date']
+            print("Real date",date)
+            return showname, date
+        elif type == "StreamingCommunity":
+            return showname
+        elif type == "Tuttifilm":
+            if TF_FAST_SEARCH == "0":
+                date = data['tv_results'][0]['first_air_date']
+                date = date.split("-")[0]
+                return showname,date
+            elif TF_FAST_SEARCH == "1":
+                return showname
+        elif type == "Cool":
+            return showname
+
+    elif ismovie == 1:
+        showname= data['movie_results'][0]['title']
+        if type == "Filmpertutti":
+            return
+        elif type == "StreamingCommunity":
+            return showname
+        elif type == "Tuttifilm":
+            date = data['movie_results'][0]['release_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "Cool":
+            return showname
+
+            
+
+
+
+
+def is_movie(imdb_id):
+    if "tmdb:" in imdb_id:
+        imdb_id = imdb_id.replace("tmdb:","")
+    if ":"  in imdb_id:
+        season = imdb_id.split(":")[1]
+        episode = imdb_id.split(":")[-1]
+        ismovie = 0
+        imdb_id = imdb_id.split(":")[0]
+        return ismovie,imdb_id,season,episode
+    else:
+        ismovie = 1
+        return ismovie,imdb_id

run.py

@@ -0,0 +1,224 @@
+from flask import Flask, jsonify, abort
+from filmpertutti import filmpertutti
+from streamingcommunity import streaming_community
+from tantifilm import tantifilm
+import json
+import config
+import logging
+
+# Configure logging
+
+FILMPERTUTTI = config.FILMPERTUTTI
+STREAMINGCOMMUNITY = config.STREAMINGCOMMUNITY
+MYSTERIUS = config.MYSTERIUS
+TUTTIFILM = config.TUTTIFILM
+TF_DOMAIN = config.TF_DOMAIN
+HOST = config.HOST
+PORT = int(config.PORT)
+HF = config.HF
+if HF == "1":
+    HF = "🤗️"
+    #Cool code to set the hugging face if the service is hosted there.
+else:
+    HF = ""
+if MYSTERIUS == "1":
+    from cool import cool
+
+app = Flask(__name__)
+
+MANIFEST = {
+    "id": "org.stremio.mammamia",
+    "version": "1.0.0",
+    "catalogs": [
+        {"type": "tv", "id": "tv_channels", "name": "TV Channels"}
+    ],
+    "resources": ["stream", "catalog","meta"],
+    "types": ["movie", "series", "tv"],
+    "name": "Mamma Mia",
+    "description": "Addon providing HTTPS Stream for Italian Movies/Series",
+    "logo": "https://creazilla-store.fra1.digitaloceanspaces.com/emojis/49647/pizza-emoji-clipart-md.png"
+}
+
+STREAMS = {
+    "tv": {
+        "skysport24": [
+            {
+                "title": "Sky Sport 24",
+                "poster": f"https://www.tanti.{TF_DOMAIN}/public/upload/channel/sky-sport-24.webp",
+                "url": "https://07-24.mizhls.ru/fls/cdn/calcioXskysport24/playlist.m3u8",
+                "behaviorHints": {
+                    "notWebReady": True,
+                    "proxyHeaders": {
+                        "request": {
+                            "Referer": "https://claplivehdplay.ru/",
+                            "Origin": "https://claplivehdplay.ru",
+                            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+                        }
+                    }
+                }
+            }
+        ],
+        "Skyuno": [
+            {
+                "title": "Sky Uno",
+                "poster": f"https://www.tanti.{TF_DOMAIN}/public/upload/channel/sky-uno.webp",
+                "url": "https://07-24.mizhls.ru/fls/cdn/calcioXskyuno/playlist.m3u8",
+                "behaviorHints": {
+                    "notWebReady": True,
+                    "proxyHeaders": {
+                        "request": {
+                            "Referer": "https://claplivehdplay.ru/",
+                            "Origin": "https://claplivehdplay.ru",
+                            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+                        }
+                    }
+                }
+            }
+        ],
+        "skyserie": [
+            {
+                "title": "Sky Serie",
+                "poster": f"https://www.tanti.{TF_DOMAIN}/public/upload/channel/sky-serie.webp",
+                "url": "https://07-24.mizhls.ru/fls/cdn/calcioXskyserie/playlist.m3u8",
+                "behaviorHints": {
+                    "notWebReady": True,
+                    "proxyHeaders": {
+                        "request": {
+                            "Referer": "https://claplivehdplay.ru/",
+                            "Origin": "https://claplivehdplay.ru",
+                            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+                        }
+                    }
+                }
+            }
+        ],
+        "Sky Nature": [
+            {
+                "title": "Sky Nature",
+                "poster": f"https://www.tanti.{TF_DOMAIN}/public/upload/channel/sky-nature.webp",
+                "url": "https://07-24.mizhls.ru/fls/cdn/calcioXskynature/playlist.m3u8",
+                "behaviorHints": {
+                    "notWebReady": True,
+                    "proxyHeaders": {
+                        "request": {
+                            "Referer": "https://claplivehdplay.ru/",
+                            "Origin": "https://claplivehdplay.ru",
+                            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+                        }
+                    }
+                }
+            }
+        ],
+        "skyinvestigation": [
+            {
+                "title": "skyinvestigation",
+                "poster": f"https://www.tanti.{TF_DOMAIN}/public/upload/channel/sky-nature.webp",
+                "url": "https://07-24.mizhls.ru/fls/cdn/calcioXskyinvestigation/playlist.m3u8",
+                "behaviorHints": {
+                    "notWebReady": True,
+                    "proxyHeaders": {
+                        "request": {
+                            "Referer": "https://claplivehdplay.ru/",
+                            "Origin": "https://claplivehdplay.ru",
+                            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+                        }
+                    }
+                }
+            }
+        ]
+    }
+}
+
+def respond_with(data):
+    resp = jsonify(data)
+    resp.headers['Access-Control-Allow-Origin'] = '*'
+    resp.headers['Access-Control-Allow-Headers'] = '*'
+    return resp
+
+@app.route('/manifest.json')
+def addon_manifest():
+    return respond_with(MANIFEST)
+
+@app.route('/')
+def root():
+    return "Hello, this is a Stremio Addon providing HTTPS Stream for Italian Movies/Series, to install it add /manifest.json to the url and then add it into the Stremio search bar"
+
+@app.route('/catalog/<type>/<id>.json')
+def addon_catalog(type, id):
+    if type not in MANIFEST['types']:
+        abort(404)
+    catalog = {'metas': []}
+    if type in STREAMS:
+        for stream_id in STREAMS[type]:
+            for item in STREAMS[type][stream_id]:
+                meta_item = {
+                    "id": stream_id,
+                    "type": type,
+                    "name": item['title'],
+                    "poster": item.get('poster', "https://via.placeholder.com/150")
+                }
+                catalog['metas'].append(meta_item)
+    return respond_with(catalog)
+
+@app.route('/stream/<type>/<id>.json')
+def addon_stream(type, id):
+    if type not in MANIFEST['types']:
+        abort(404)
+    streams = {'streams': []}
+
+    if type in STREAMS and id in STREAMS[type]:
+        logging.debug(f"Found TV channel: {id}")
+        streams['streams'] = STREAMS[type][id]
+    else:
+        logging.debug(f"Handling movie or series: {id}")
+        if MYSTERIUS == "1":
+            results = cool(id)
+            if results:
+                for resolution, link in results.items():
+                    streams['streams'].append({'title': f'{HF}Mysterious {resolution}', 'url': link})
+        if STREAMINGCOMMUNITY == "1":
+            url_streaming_community = streaming_community(id)
+            if url_streaming_community is not None:
+                streams['streams'].append({'title': f'{HF}StreamingCommunity 1080p', 'url': f'{url_streaming_community}?rendition=1080p'})
+                streams['streams'].append({'title': f'{HF}StreamingCommunity 720p', 'url': f'{url_streaming_community}?rendition=720p'})
+        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)
+            if url_tuttifilm:
+                if not isinstance(url_tuttifilm, str):
+                    for title, url in url_tuttifilm.items():    
+                        streams['streams'].append({'title': f'{HF}Tantifilm {title}', 'url': url,  'behaviorHints': {'proxyHeaders': {"request": {"Referer": "https://d000d.com/"}}, 'notWebReady': True}})
+                else:
+                    streams['streams'].append({'title': f'{HF}Tantifilm', 'url': url_tuttifilm, 'behaviorHints': {'proxyHeaders': {"request": {"Referer": "https://d000d.com/"}}, 'notWebReady': True}})
+    if not streams['streams']:
+        abort(404)
+
+    return respond_with(streams)
+
+@app.route('/meta/<type>/<id>.json')
+def meta(type, id):
+    if type not in MANIFEST['types']:
+        abort(404)
+
+    meta = {}
+    for stream_id in STREAMS.get(type, {}):
+        if stream_id == id:
+            item = STREAMS[type][stream_id][0]  # Assuming there's at least one item
+            meta = {
+                "id": stream_id,
+                "type": type,
+                "name": item['title'],
+                "poster": item.get('poster', "https://icons.iconarchive.com/icons/designbolts/free-multimedia/256/TV-icon.png"),
+                "background": item.get('background', "https://icons.iconarchive.com/icons/designbolts/free-multimedia/256/TV-icon.png")
+            }
+            break
+
+    if not meta:
+        abort(404)
+
+    return respond_with({"meta": meta})
+if __name__ == '__main__':
+    app.run(host=HOST, port=PORT)

streamingcommunity.py

@@ -0,0 +1,180 @@
+from tmdbv3api import TMDb, Movie, TV
+import requests
+import logging 
+from bs4 import BeautifulSoup,SoupStrainer
+from datetime import datetime
+import dateparser
+from convert import get_TMDb_id_from_IMDb_id
+from info import get_info_tmdb, is_movie, get_info_imdb
+import config
+import json
+import re
+#Get domain
+SC_DOMAIN= config.SC_DOMAIN
+SC_FAST_SEARCH = config.SC_FAST_SEARCH
+
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.10; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+    'Accept-Language': 'en-US,en;q=0.5'
+}
+
+#GET VERSION OF STREAMING COMMUNITY:
+def get_version():
+    #Extract the version from the main page of the site
+
+
+    try:
+        base_url = f'https://streamingcommunity.{SC_DOMAIN}/richiedi-un-titolo'
+        response = requests.get(base_url, headers=headers)
+        #Soup the response
+        soup = BeautifulSoup(response.text, "lxml")
+
+        # Extract version
+        version = json.loads(soup.find("div", {"id": "app"}).get("data-page"))['version']
+        return version
+    except:
+        print("Couldn't find the version")
+        version = "65e52dcf34d64173542cd2dc6b8bb75b"
+        return version
+
+def search(query,date,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']
+        type = item['type']
+        if type == "tv":
+            type = 0
+        elif type == "movie":
+            type = 1
+        if type == ismovie: 
+            #Added a Check to see if the result is what it is supposed to be
+            if SC_FAST_SEARCH == "0":
+                if ismovie == 0:
+                    seasons_count = item['seasons_count']
+                    #Do not ask me why but somewhy streaming community call the first air date the last air date
+                    first_air_date = item['last_air_date']
+                    if first_air_date:
+                        first_air_year = first_air_date.split("-")[0]
+                        if first_air_year == date:
+                            return tid,slug
+                    else:
+                        response = requests.get ( f'https://streamingcommunity.boston/titles/{tid}-{slug}')
+                        pattern = r'<div[^>]*class="features"[^>]*>.*?<span[^>]*>(.*?)<\/span>'
+                        match = re.search(pattern, response.text)
+                        print(match.group(1).split("-")[0])
+                        first_air_year = match.group(1).split("-")[0]
+                        date = int(date)
+                        first_air_year = int(first_air_year)
+                        if first_air_year == date:
+                            return tid,slug
+                elif ismovie == 1:
+                    return tid,slug
+            elif SC_FAST_SEARCH == "1":
+                return tid,slug
+        else:
+            print("Couldn't find anything")
+
+        
+def get_film(tid):
+    #Access the iframe
+    url = f'https://streamingcommunity.{SC_DOMAIN}/iframe/{tid}'
+    response = requests.get(url, headers=headers)
+    iframe = BeautifulSoup(response.text, 'lxml')
+    #Get the link of iframe
+    iframe = iframe.find('iframe').get("src")
+    #Get the ID containted in the src of iframe
+    vixid = iframe.split("/embed/")[1].split("?")[0]
+    #Build the url with 1080p, to get the highest resolution
+    url = f'https://vixcloud.co/playlist/{vixid}'
+    return url
+
+def get_season_episode_id(tid,slug,season,episode,version):
+    #Set some basic headers for the request
+    headers = {
+            'user-agent': "Mozilla/5.0 (Windows NT 10.10; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
+            'x-inertia': 'true', 
+            #Version of streaming community
+            'x-inertia-version': version
+        }   
+      #Get episode ID 
+    response = requests.get(f'https://streamingcommunity.{SC_DOMAIN}/titles/{tid}-{slug}/stagione-{season}', headers=headers)
+    # Print the json got
+    json_response = response.json().get('props', {}).get('loadedSeason', {}).get('episodes', [])
+    for dict_episode in json_response:
+        if dict_episode['number'] == episode:
+            return dict_episode['id']
+
+def get_episode_link(episode_id,tid):
+    #The parameters for the request
+    params = {
+                'episode_id': episode_id, 
+                'next_episode': '1'
+            }
+    #Let's try to get the link from iframe source
+        # Make a request to get iframe source
+    response = requests.get(f"https://streamingcommunity.{SC_DOMAIN}/iframe/{tid}", params=params)
+
+    # Parse response with BeautifulSoup to get iframe source
+    soup = BeautifulSoup(response.text, "lxml")
+    iframe = soup.find("iframe").get("src")
+    vixid = iframe.split("/embed/")[1].split("?")[0]
+    url = f"https://vixcloud.co/playlist/{vixid}"
+    return url
+
+
+def streaming_community(imdb):
+    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)
+                    date = None
+                else:
+                    #I just set n season to None to avoid bugs, but it is not needed if Fast search is enabled
+                    date = 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,date = get_info_tmdb(tmdba,ismovie,type)  
+        #HERE THE CASE IF IT IS A MOVIE
+        else:
+            if "tt" in imdb:
+                #Get showname
+                date = 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
+                    #else just equals them
+                    date = 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,date,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,257 @@
+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,date):
+    url = f'https://www.tanti.{TF_DOMAIN}/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))
+            if release_date == date:
+                tid= url.split('-')[-1]
+                #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
+                return tid,url
+    elif ismovie == 0: 
+        all_link = soup.select('#series .col .list-media')
+        for link in all_link:
+            base_url = link['href']
+            url = f'{base_url}-1-season-1-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:
+                tid= url.split('-')[1]
+                soup = BeautifulSoup(response.text, 'lxml')
+                a_tag = soup.find('a', class_='dropdown-toggle btn-service selected')
+                embed_id = a_tag['data-embed']
+                #I try to get doodstream link inside this function so I do not have to get again the response
+                return url,embed_id
+            
+def fast_search(showname,ismovie):
+    url = f'https://www.tanti.{TF_DOMAIN}/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']
+        tid= url.split('-')[1]
+        return tid,url
+    elif ismovie == 0: 
+        first_link = soup.select_one('#series .col .list-media')
+        base_url = first_link['href']
+        url = f'{base_url}-1-season-1-episode'
+        response = requests.get(url)
+        soup = BeautifulSoup(response.text, 'lxml')
+        a_tag = soup.find('a', class_='dropdown-toggle btn-service selected')
+        embed_id = a_tag['data-embed']
+        return url,embed_id
+
+
+
+def get_protect_link(id,url):
+        #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'))
+        protect_link = soup.iframe['src'] 
+        if "protect" in protect_link:
+            return  protect_link
+        else:
+            #DO this in case the movie has  a 3D version etc
+            response = requests.get(url)
+            soup = BeautifulSoup(response.text, 'lxml')
+            a_tag = soup.find('a', class_='dropdown-toggle btn-service selected')
+            embed_id = a_tag['data-embed']
+            headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
+            'Referer': url
+            }
+            #Parameters needed is the embed ID
+            data = {
+            'id': embed_id
+            }
+            ajax_url = f"https://www.tanti.{TF_DOMAIN}/ajax/embed"
+            response = requests.post(ajax_url, headers=headers, data=data)
+            hdplayer = response.text[43:-27]
+            response = requests.get(hdplayer)
+            soup = BeautifulSoup(response.text, 'lxml')
+            links_dict = {}
+            li_tags = soup.select('ul.nav.navbar-nav li.dropdown')
+            for li_tag in li_tags:
+                a_tag = li_tag.find('a')
+                if a_tag:
+                    title = a_tag.text.strip() 
+                    #Since tantifilm player is broken I just skip it
+                    if title == "1" or "Tantifilm" in title:
+                        continue # Get the text of the <a> tag
+                    href = a_tag['href']  
+                    response = requests.get(href)
+                    soup = BeautifulSoup(response.text, "lxml", parse_only=SoupStrainer('iframe'))
+                    protect_link = soup.iframe['src'] 
+                    if "protect" in protect_link:
+                        url = true_url(protect_link)
+                        links_dict[title] = url
+            return  links_dict
+                         # Get the value of the href attribute
+                    
+
+def get_nuovo_indirizzo_and_protect_link(url,embed_id,season,episode):
+    headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
+    'Referer': url
+    }
+    #Parameters needed is the embed ID
+    data = {
+    'id': embed_id
+}
+    ajax_url = f"https://www.tanti.{TF_DOMAIN}/ajax/embed"
+    response = requests.post(ajax_url, headers=headers, data=data)
+    nuovo_indirizzo = response.text[43:-27]
+    response = requests.get(nuovo_indirizzo)
+    soup = BeautifulSoup(response.text, 'lxml')
+    #Get season
+    season = season - 1
+    li_tags = soup.select('ul.nav.navbar-nav > li.dropdown')
+    if len(li_tags) != 1:
+        link = li_tags[season].find('a')['href']
+        response = requests.get(link)
+        soup = BeautifulSoup(response.text, 'lxml')
+        option_tag = soup.select(f'select[name="ep_select"] > option:nth-of-type({episode})')[0]
+        link = option_tag['value']
+        #Let's find protect link now
+        response = requests.get(link)
+        soup = BeautifulSoup(response.text, "lxml", parse_only=SoupStrainer('iframe'))
+        protect_link = soup.iframe['src'] 
+        return  protect_link
+
+    else:
+        #If there is only one season than 
+        option_tag = soup.select('select.dynamic_select > option')[episode]
+        link = option_tag['value']
+        #Let's find protect link now
+        response = requests.get(link)
+        soup = BeautifulSoup(response.text, "lxml", parse_only=SoupStrainer('iframe'))
+        protect_link = soup.iframe['src'] 
+        return  protect_link
+
+
+def true_url(protect_link):
+    print(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):
+    urls = None
+    try:
+        general = is_movie(imdb)
+        ismovie = general[0]
+        imdb_id = general[1]
+        type = "Tuttifilm"
+        if ismovie == 0 : 
+            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)
+                    url,embed_id = search(showname,ismovie,date)
+                elif TF_FAST_SEARCH == "1":
+                    showname = get_info_imdb(imdb_id,ismovie,type)
+                    url,embed_id = fast_search(showname,ismovie)
+            else:
+                    #else just equals them
+                    tmdba = imdb_id.replace("tmdb:","")
+                    if TF_FAST_SEARCH == "0":
+                        showname,date = get_info_tmdb(tmdba,ismovie,type)
+                        url,embed_id = search(showname,ismovie,date)
+                    elif TF_FAST_SEARCH == "1":
+                        showname= get_info_tmdb(tmdba,ismovie,type)
+                        url,embed_id = fast_search(showname,ismovie)
+            protect_link = get_nuovo_indirizzo_and_protect_link(url,embed_id,season,episode)
+            url = true_url(protect_link)
+            return url
+        elif ismovie == 1:
+            if "tt" in imdb:
+                #Get showname
+                    if TF_FAST_SEARCH == "0":
+                        showname,date = get_info_imdb(imdb_id,ismovie,type)
+                        tid,url = search(showname,ismovie,date)
+                    elif TF_FAST_SEARCH == "1":
+                        showname = get_info_imdb(imdb_id,ismovie,type)
+                        date = None
+                        tid,url = fast_search(showname,ismovie)
+            else:
+            
+                #else just equals themtantifilm("tt2096673")
+
+                if TF_FAST_SEARCH == "0":
+                    showname,date = get_info_tmdb(imdb,ismovie,type)
+                    tid,url = search(showname,ismovie,date)
+                elif TF_FAST_SEARCH == "1":
+                    showname = get_info_tmdb(imdb,ismovie,type)
+                    tid,url = fast_search(showname,ismovie)
+            protect_link = get_protect_link(tid,url)
+            if not isinstance(protect_link, str):
+                urls = protect_link
+                if urls:
+                    return urls
+                else:
+                    print("Tantifilm Error v2")
+            else:
+                url = true_url(protect_link)
+                if url:
+                    return url
+
+    except Exception as e:
+        print("Tantifilm Error: ", e)
+        return None