Upload 20 files

Dockerfile

@@ -0,0 +1,15 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim-buster
+# Set the working directory in the container to /app
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app 
+# (including run.py, filmpertutti.py, and requirements.txt)
+ADD . /app
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+#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
+CMD ["python", "run.py"]

LICENSE

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

animeworld.py

@@ -0,0 +1,146 @@
+import httpx
+import asyncio
+
+from bs4 import BeautifulSoup
+import datetime
+import json
+from info import get_info_kitsu
+import config
+import re
+months = {
+        "Gennaio": "January", "Febbraio": "February", "Marzo": "March", 
+        "Aprile": "April", "Maggio": "May", "Giugno": "June", 
+        "Luglio": "July", "Agosto": "August", "Settembre": "September", 
+        "Ottobre": "October", "Novembre": "November", "Dicembre": "December"
+    }
+showname_replace = {
+    "Attack on Titan": "L'attacco dei Giganti"
+}
+
+AW_DOMAIN = config.AW_DOMAIN
+async def get_mp4(anime_url,ismovie,episode,client):
+   response = await client.get(anime_url,follow_redirects=True)
+   soup = BeautifulSoup(response.text,'lxml')
+   episode_page = soup.find('a', {'data-episode-num':episode })
+   episode_page = f'https://animeworld.{AW_DOMAIN}{episode_page["href"]}'
+   response = await client.get(episode_page,follow_redirects=True)
+   soup = BeautifulSoup(response.text,'lxml')
+   a_tag  = soup.find('a', {'id': 'alternativeDownloadLink', 'class': 'm-1 btn btn-sm btn-primary'}) 
+   url = a_tag['href']
+   response = await client.head(url)
+   if response.status_code == 404:
+        url = None
+   return url
+
+
+
+
+
+
+
+async def old_search(showname,date,ismovie,episode,client):
+    cookies = {
+    'sessionId': 's%3AtGSRfYcsIoaeV0nqFJgN69Zxixb_-uJU.fcNz%2FsJBiiP8v8TwthMN9%2FmynWFciI5gezZuz8CltyQ',
+    }
+
+    headers = {
+        'authority': f'www.animeworld.{AW_DOMAIN}',
+        'accept': 'application/json, text/javascript, */*; q=0.01',
+        'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+         # 'content-length': '0',
+         # 'cookie': 'sessionId=s%3AtGSRfYcsIoaeV0nqFJgN69Zxixb_-uJU.fcNz%2FsJBiiP8v8TwthMN9%2FmynWFciI5gezZuz8CltyQ',
+         'csrf-token': 'oKFK43s4-BzfqPX27RlAORUd-iyiAfXyfDAo',
+         'origin': f'https://www.animeworld.{AW_DOMAIN}',
+         'referer': f'https://www.animeworld.{AW_DOMAIN}/',
+         'sec-ch-ua': '"Not-A.Brand";v="99", "Chromium";v="124"',
+         'sec-ch-ua-mobile': '?0',
+         'sec-ch-ua-platform': '"Android"',
+         'sec-fetch-dest': 'empty',
+         'sec-fetch-mode': 'cors',
+         'sec-fetch-site': 'same-origin',
+         'user-agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+         'x-requested-with': 'XMLHttpRequest',
+    }
+
+    params = {
+        'keyword': showname,
+    }
+
+    response = await client.post(f'https://www.animeworld.{AW_DOMAIN}/api/search/v2', params=params, cookies=cookies, headers=headers,follow_redirects=True)
+
+    data = json.loads(response.text)
+    final_urls = []
+    for anime in data["animes"]:
+        release_date = anime["release"]
+        for ita, eng in months.items():
+            release_date = release_date.replace(ita, eng)
+        release_date = datetime.datetime.strptime(release_date, "%d %B %Y")
+        release_date = release_date.strftime("%Y-%m-%d")
+        if release_date == date:
+            identifier = anime["identifier"]
+            link = anime["link"]
+            anime_url = f'https://animeworld.{AW_DOMAIN}/play/{link}.{identifier}'
+            final_url = await get_mp4(anime_url,ismovie,episode,client)
+            final_urls.append(final_url)
+            break
+    showname = showname + " (ITA)"
+    params = {
+        'keyword': showname,
+    }
+    response = await client.post(f'https://www.animeworld.{AW_DOMAIN}/api/search/v2', params=params, cookies=cookies, headers=headers, follow_redirects=True)
+    data = json.loads(response.text)
+    for anime in data["animes"]:
+        release_date = anime["release"]
+        for ita, eng in months.items():
+            release_date = release_date.replace(ita, eng)
+        release_date = datetime.datetime.strptime(release_date, "%d %B %Y")
+        release_date = release_date.strftime("%Y-%m-%d")
+        if release_date == date:
+            identifier = anime["identifier"]
+            link = anime["link"]
+            anime_url = f'https://animeworld.{AW_DOMAIN}/play/{link}.{identifier}'
+            final_url = await get_mp4(anime_url,ismovie,episode,client)
+            final_urls.append(final_url)
+            break
+    return final_urls
+
+async def search(showname,date,ismovie,episode,client):
+    search_year = date[:4] 
+    response = await client.get(f'https://www.animeworld.so/filter?year={search_year}&sort=2&keyword={showname}',follow_redirects=True)
+    soup = BeautifulSoup(response.text,'lxml')
+    anime_list = soup.find_all('a', class_=['poster', 'tooltipstered'])
+    final_urls = []
+    for anime in anime_list:
+        anime_info_url = f'https://www.animeworld.{AW_DOMAIN}/{anime["data-tip"]}'
+        response = await client.get(anime_info_url,follow_redirects=True)
+        pattern = r'<label>Data di uscita:</label>\s*<span>\s*(.*?)\s*</span>'
+        match = re.search(pattern, response.text, re.S)
+        release_date = match.group(1).strip()
+        for ita, eng in months.items():
+            release_date = release_date.replace(ita, eng)
+        release_date = datetime.datetime.strptime(release_date, "%d %B %Y")
+        release_date = release_date.strftime("%Y-%m-%d")
+        print(release_date)
+        if release_date == date:
+            anime_url = f'https://www.animeworld.{AW_DOMAIN}{anime["href"]}'
+            final_url = await get_mp4(anime_url,ismovie,episode,client)
+            if final_url:
+                final_urls.append(final_url)
+
+    return final_urls
+
+async def animeworld(id,client):
+    try:
+        print(id)
+        kitsu_id = id.split(":")[1]
+        episode = id.split(":")[2]
+        ismovie = 1 if len(id.split(":")) == 2 else 0
+        showname,date = await get_info_kitsu(kitsu_id,client)
+        if showname in showname_replace:
+            showname = showname_replace[showname]
+        final_urls = await search(showname,date,ismovie,episode,client)
+        return final_urls
+    except:
+        print("Animeworld failed")
+        return None
+

config.json

@@ -0,0 +1,40 @@
+{
+    "Siti": {
+           "StreamingCommunity": {
+               "enabled": "1",    
+               "domain": "buzz",
+               "fast_search": "0"
+           },
+           "Filmpertutti": {
+               "enabled": "0",    
+               "domain": "diy"
+           },
+           "Tuttifilm":{
+               "enabled": "0",    
+               "domain": "bond",
+               "fast_search": "0"
+           },
+           "Mysterius":{
+               "enabled": "0"    
+           },
+          "LordChannel":{
+               "enabled":"1",
+               "domain":"com"
+          },
+          "StreamingWatch":{
+              "enabled":"1",
+              "domain":"org"
+          },
+          "AnimeWorld":{
+              "enabled":"1",
+              "domain":"so"
+          }
+   },
+   "General":{
+       "load_env": "0",
+       "HOST": "0.0.0.0",
+       "PORT": "8080",
+       "HF": "1"
+   }
+   }
+   

config.py

@@ -0,0 +1,31 @@
+#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"]['domain']
+LC_DOMAIN = SITE["LordChannel"]['domain']
+SW_DOMAIN = SITE["StreamingWatch"]['domain']
+AW_DOMAIN = SITE['AnimeWorld']['domain']
+FILMPERTUTTI = SITE["Filmpertutti"]['enabled']
+STREAMINGCOMMUNITY = SITE["StreamingCommunity"]['enabled']
+MYSTERIUS = SITE["Mysterius"]['enabled']
+TUTTIFILM = SITE["Tuttifilm"]['enabled']
+LORDCHANNEL = SITE["LordChannel"]['enabled']
+STREAMINGWATCH = SITE["StreamingWatch"]['enabled']
+ANIMEWORLD = SITE['AnimeWorld']['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,17 @@
+import requests 
+from tmdbv3api import TMDb, Movie, TV
+from loadenv import load_env
+import config
+env_vars = load_env()
+
+TMDB_KEY = env_vars.get('TMDB_KEY')
+async def get_TMDb_id_from_IMDb_id(imdb_id,client): 
+    response = await client.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

convert_date.py

@@ -0,0 +1,39 @@
+
+def convert_US_date(date):
+    us_data = next((country_data for country_data in date['results'] if country_data["iso_3166_1"] == "US"), None)
+    if us_data:
+        us_release_dates_type_3 = [rd for rd in us_data['release_dates'] if rd['type'] == 3]
+        # Sort the list of release dates and get the latest
+        us_release_dates_type_3.sort(key = lambda x: x['release_date'], reverse=True)
+        if len(us_release_dates_type_3) > 0:
+            latest_release_date = us_release_dates_type_3[0]['release_date']
+            date = latest_release_date.split('T')[0]
+            print('Latest US theatrical release date:', date)
+            return date
+        else:   
+            us_release_dates_type_4 = [rd for rd in us_data['release_dates'] if rd['type'] == 4]
+            us_release_dates_type_4.sort(key = lambda x: x['release_date'], reverse=True)
+            if len(us_release_dates_type_4) > 0:
+                latest_release_date = us_release_dates_type_4[0]['release_date']
+                date = latest_release_date.split('T')[0]
+                print('Latest US theatrical release date (type 4):', date)
+                return date
+def convert_IT_date(date):
+    it_data = next((country_data for country_data in date['results'] if country_data["iso_3166_1"] == "IT"), None)
+    if it_data:
+        it_release_dates_type_3 = [rd for rd in it_data['release_dates'] if rd['type'] == 3]
+        # Sort the list of release dates and get the latest
+        it_release_dates_type_3.sort(key = lambda x: x['release_date'], reverse=True)
+        if len(it_release_dates_type_3) > 0:
+            latest_release_date = it_release_dates_type_3[0]['release_date']
+            date = latest_release_date.split('T')[0]
+            print('Latest IT theatrical release date:', date)
+            return date
+        else:   
+            it_release_dates_type_4 = [rd for rd in it_data['release_dates'] if rd['type'] == 4]
+            it_release_dates_type_4.sort(key = lambda x: x['release_date'], reverse=True)
+            if len(it_release_dates_type_4) > 0:
+                latest_release_date = it_release_dates_type_4[0]['release_date']
+                date = latest_release_date.split('T')[0]
+                print('Latest IT theatrical release date (type 4):', date)
+                return date

cool.py

@@ -0,0 +1,145 @@
+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
+env_vars = load_env()
+MYSTERIUS_KEY = env_vars.get('MYSTERIUS_KEY')
+async def get_links(slug,season,episode,ismovie,client):
+    try:
+        headers = {
+            "x-api-key": MYSTERIUS_KEY
+        }
+        response = await client.get("https://mammamia-urlo-ulala12431.hf.space/api/cookie", headers=headers)
+        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 = await client.get(f'https://altadefinizione-originale.com/api/post/urls/stream/{slug}',cookies=cookies,headers=headers)
+        elif ismovie == 0:
+            print("HERE SEASON",season)
+            print("HERE EPISODE",episode)
+            request_url =f'https://altadefinizione-originale.com/api/post/urls/stream/{slug}/{season}/{episode}'
+            print(request_url)
+            response = await client.get(request_url,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
+
+
+
+
+
+async def search_imdb(showname,tmdba,client):
+        tmdba = str(tmdba)
+        query = f'https://altadefinizione-originale.com/api/search?search={showname}&page=1'
+        response = await client.get(query,follow_redirects=True)
+        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():
+            if "cdn.altadefinizione-originale.com" in link:
+                link = link.replace("cdn.altadefinizione-originale.com","protectlinknt.b-cdn.net")
+            print(f"{resolution}: {link}")
+            results[resolution] = link
+        return results    
+    else:
+        print("Failed to fetch video links")
+
+
+async def cool(imdb,client):
+    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 = await get_TMDb_id_from_IMDb_id(imdb_id,client)
+        else:
+            tmdba = imdb_id.replace("tmdb:","")
+
+        showname = get_info_tmdb(tmdba,ismovie,type)
+        
+
+        slug = await search_imdb(showname,tmdba,client)
+        print(ismovie)
+        if ismovie == 1:
+            season = None
+            episode = None
+            resolution_links = await get_links(slug,episode,season,ismovie,client)
+            results = parse_links(resolution_links)
+            return results
+        elif ismovie == 0:
+            season = season -1
+            episode = episode - 1
+            resolution_links = get_links(slug,season,episode,ismovie)
+            results = parse_links(resolution_links)
+            return results
+    except Exception as e:
+        print("Cool Error",e)
+        return None

dictionaries.py

@@ -0,0 +1,30 @@
+okru = {
+    "rai1": "https://ok.ru/videoembed/7703488765552?nochat=1",
+    "rai2": "https://ok.ru/videoembed/7805618364016?nochat=1"
+}
+
+STREAM = {
+    "channels": [
+        {
+            "id": "la7",
+            "title": "LA7",
+            "name": "LA7",
+            "poster": "https://static.wikia.nocookie.net/logopedia/images/0/02/LA7_-_Logo_2011.svg/revision/latest?cb=20190728152519",
+            "url": "https://d3749synfikwkv.cloudfront.net/v1/master/3722c60a815c199d9c0ef36c5b73da68a62b09d1/cc-74ylxpgd78bpb/Live.m3u8"
+        },
+        {
+            "id": "rai1",
+            "title": "Rai 1",
+            "name": "Full HD",
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Rai_1_-_Logo_2016.svg/1280px-Rai_1_-_Logo_2016.svg.png",
+            "url": "http://173.208.52.200/rai1/index.m3u8"
+        },
+        {
+            "id": "rai2",
+            "title": "Rai 2",
+            "name": "Full HD",
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/99/Rai_2_-_Logo_2016.svg/1280px-Rai_2_-_Logo_2016.svg.png",
+            "url": "http://173.208.52.200/rai2/index.m3u8"
+        }
+    ]
+}

example.env

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

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'
+}
+
+async def search(query,date,client):
+    response = await client.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 = await client.get(link, headers=headers, follow_redirects=True)
+        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
+
+async def get_real_link(tlink,client):
+    #Some basic code to get the mixdrop link
+    page = await client.get(tlink, headers=headers, follow_redirects=True)
+    soup = BeautifulSoup(page.content(), features="lxml",parse_only=SoupStrainer('iframe'))
+    iframe_src = soup.find('iframe')['src']
+
+    iframe_page = await client.get(iframe_src, headers=headers, follow_redirects=True)
+    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
+    
+async def get_true_link(real_link,client):
+    response = await client.get(real_link, headers=headers, follow_redirects=True)
+    [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
+
+async def filmpertutti(imdb,client):
+    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 = await get_info_imdb(imdb_id,ismovie,type,client)
+        else:
+            #THIS IS needed cause the only way to get all releases dates is by giving a tmdb ID not a IMDB
+            tmdba = await get_TMDb_id_from_IMDb_id(imdb_id,client)
+            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 = await search(query,date,client)
+    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 = await get_real_link(episode_link,client)
+        #let's get delivery link, streaming link
+        streaming_link = await get_true_link(real_link,client)
+        print(streaming_link)
+        return streaming_link
+    elif ismovie == 1:
+        film_link = get_film(url)
+        #Let's get mixdrop link
+        real_link = await get_real_link(film_link,client)
+        #let's get delivery link, streaming link
+        streaming_link = await get_true_link(real_link,client)
+        print(streaming_link)
+        return streaming_link

info.py

@@ -0,0 +1,145 @@
+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
+import json
+SC_FAST_SEARCH = config.SC_FAST_SEARCH
+TF_FAST_SEARCH = config.TF_FAST_SEARCH
+env_vars = load_env()
+TMDB_KEY = env_vars.get('TMDB_KEY')
+
+
+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 type == "LordChannel":
+            date = show.first_air_date
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+        elif type == "StreamingWatch":
+            date = show.first_air_date
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+    
+    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
+        elif type == "LordChannel":
+            date = show.release_date
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+        elif type == "StreamingWatch":
+            date = show.release_date
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+
+async def get_info_imdb(imdb_id, ismovie, type,client):
+
+    resp = await client.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
+
+async def get_info_kitsu(kitsu_id,client):
+    api_url = f'https://kitsu.io/api/edge/anime/{kitsu_id}'
+    response = await client.get(api_url)
+    data = json.loads(response.text)
+    showname = data['data']['attributes']['canonicalTitle']
+    date = data['data']['attributes']['startDate']
+    return showname,date           
+
+
+
+
+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

loadenv.py

@@ -0,0 +1,22 @@
+import os
+import config
+import config
+MYSTERIUS = config.MYSTERIUS  
+dotenv = config.dotenv
+TUTTIFILM = config.TUTTIFILM
+HF = config.HF
+#You need to keep dotenv disabled on remote servers
+if dotenv == "1":
+    from dotenv import load_dotenv
+    load_dotenv(".env")
+
+
+def load_env():
+    env_vars = {}
+    env_vars['TMDB_KEY'] = os.getenv('TMDB_KEY')
+    if MYSTERIUS == "1":
+        env_vars['MYSTERIUS_KEY'] = os.getenv('MYSTERIUS_KEY')
+    if TUTTIFILM == "1":
+        if HF == "1":
+            env_vars['PROXY_CREDENTIALS'] = os.getenv('PROXY')
+    return env_vars

lordchannel.py

@@ -0,0 +1,104 @@
+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 re
+import json
+LC_DOMAIN = config.LC_DOMAIN
+async def search(showname,date,season,episode,ismovie,client):
+    cookies = {
+        'csrftoken': '7lvc502CZe8Zbx7iSX1xkZOBA1NbDxJZ',
+    }
+
+    headers = {
+        'authority': f'lordchannel.{LC_DOMAIN}',
+        'accept': '*/*',
+        'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+        # 'cookie': 'csrftoken=7lvc502CZe8Zbx7iSX1xkZOBA1NbDxJZ',
+        'referer': f'https://lordchannel.{LC_DOMAIN}/anime/anime-ita/',
+        'sec-ch-ua': '"Not-A.Brand";v="99", "Chromium";v="124"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"Android"',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        'sec-fetch-site': 'same-origin',
+        'user-agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+        'x-requested-with': 'XMLHttpRequest',
+    }
+
+    params = {
+        'media': showname,
+        '_': '1724421723999',
+    }
+
+    response = await client.get(f'https://lordchannel.{LC_DOMAIN}/live_search/', params=params, cookies=cookies, headers=headers, follow_redirects=True)
+    data = json.loads(response.text)
+    for entry in data['data']:
+        if entry is not None:  # check if the a_tag exists
+            href = entry['url']
+            quality = entry['qualit\u00e0_video']
+            link = f'https://lordchannel.{LC_DOMAIN}{href}'
+            response = await client.get(link, follow_redirects=True)
+            soup2 = BeautifulSoup(response.text,'lxml')
+            li_tag = soup2.select_one("ul.card__meta li:nth-of-type(2)")
+            if li_tag is not None:  # check if the li_tag exists
+                card_date = li_tag.text[-4:]
+                if card_date == date:
+                    if ismovie == 1:
+                        video_url = soup2.find('a', class_="btn-streaming streaming_btn")  
+                        video_url = video_url['href']
+                        return video_url,quality
+                    elif ismovie == 0:
+                         div = soup2.find('div', id=f'collapse{season}')
+                         episode = episode -1 #Index start from 0 so I need to subtract 1
+                         episode = div.select('tr')[2]  # index is 2 because we want the correct  element
+                         video_url = href = episode.find('a').get('href')
+                         return video_url,quality
+                else:
+                    print("Sadly date are not equals")
+                    continue
+
+async def get_m3u8(video_url,client):
+    response = await client.get(video_url, follow_redirects=True)
+    pattern = r'const videoData = \[(.*?)\];'
+    match = re.search(pattern, response.text)
+
+    if match:
+       video_data = match.group(1).strip().split(', ')
+       url = video_data[0]
+       return url
+
+async def lordchannel(imdb,client):
+    try:
+        general = is_movie(imdb)
+        ismovie = general[0]
+        imdb_id = general[1]
+        type = "LordChannel"
+        if ismovie == 0:
+            season  = int(general[2])
+            episode = int(general[3])
+            if "tt" in imdb:
+                tmdba =  await get_TMDb_id_from_IMDb_id(imdb_id,client)
+            else:
+                tmdba = imdb_id
+        else:
+            season = None
+            episode = None
+            if "tt" in imdb:
+                tmdba = await get_TMDb_id_from_IMDb_id(imdb_id,client)
+            else:
+                tmdba = imdb_id
+        showname,date = get_info_tmdb(tmdba,ismovie,type)
+        video_url,quality = await search(showname,date,season,episode,ismovie,client)
+        url = await get_m3u8(video_url,client)
+        url = url.replace('"','')
+        print(url)
+        return url,quality
+    except:
+        print("Lordchannel Failed")
+        return None,None

okru.py

@@ -0,0 +1,19 @@
+import requests
+from bs4 import BeautifulSoup
+import json
+from dictionaries import okru
+
+
+
+async def okru_get_url(id,client):
+    embed_link = okru[id]
+    print(embed_link)
+    response = await client.get(embed_link, follow_redirects=True)
+    soup = BeautifulSoup(response.text, 'lxml')
+    div = soup.find('div', {'data-module': 'OKVideo'})
+    data_options = div.get('data-options')
+    data = json.loads(data_options)
+    metadata = json.loads(data['flashvars']['metadata'])
+    m3u8_link = metadata['hlsMasterPlaylistUrl']
+    print(m3u8_link)
+    return m3u8_link

requirements.txt

@@ -0,0 +1,9 @@
+bs4
+tmdbv3api
+dateparser
+python-dotenv
+fastapi
+uvicorn
+tzdata
+lxml
+httpx

run.py

@@ -0,0 +1,190 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from filmpertutti import filmpertutti
+from streamingcommunity import streaming_community
+from tantifilm import tantifilm
+from lordchannel import lordchannel
+from streamingwatch import streamingwatch
+import json
+import config
+import logging
+from okru import okru_get_url
+from animeworld import animeworld
+from dictionaries import okru,STREAM
+import httpx
+# Configure logging
+FILMPERTUTTI = config.FILMPERTUTTI
+STREAMINGCOMMUNITY = config.STREAMINGCOMMUNITY
+MYSTERIUS = config.MYSTERIUS
+TUTTIFILM = config.TUTTIFILM
+TF_DOMAIN = config.TF_DOMAIN
+LORDCHANNEL = config.LORDCHANNEL
+STREAMINGWATCH= config.STREAMINGWATCH
+ANIMEWORLD = config.ANIMEWORLD
+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 = FastAPI()
+MANIFEST = {
+    "id": "org.stremio.mammamia",
+    "version": "1.0.5",
+    "catalogs": [
+        {"type": "tv", "id": "tv_channels", "name": "TV Channels"}
+    ],
+    "resources": ["stream", "catalog","meta"],
+    "types": ["movie", "series", "tv"],
+    "name": "Mamma Mia",
+    "description": "Addon providing HTTPS Streams for Italian Movies,Series and Live TV! Note that you need to have Kitsu Addon installed in order to watch Anime",
+    "logo": "https://creazilla-store.fra1.digitaloceanspaces.com/emojis/49647/pizza-emoji-clipart-md.png"
+}
+
+
+
+def respond_with(data):
+    resp = JSONResponse(data)
+    resp.headers['Access-Control-Allow-Origin'] = '*'
+    resp.headers['Access-Control-Allow-Headers'] = '*'
+    return resp
+
+@app.get('/manifest.json')
+def addon_manifest():
+    return respond_with(MANIFEST)
+
+@app.get('/')
+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.get('/catalog/<type>/<id>.json')
+def addon_catalog(type, id):
+    if type != "tv":
+        raise HTTPException(status_code=404)
+
+    catalogs = {"metas": []}
+    for channel in STREAM["channels"]:
+        catalogs["metas"].append({
+            "id": channel["id"],
+            "type": "tv",
+            "name": channel["title"],
+            "poster": channel["poster"],  # Add poster URL if available
+            "description": f"Watch {channel['title']}"
+        })
+
+    return respond_with(catalogs)
+
+@app.get('/meta/<type>/<id>.json')
+def addon_meta(type, id):
+    if type != "tv":
+        raise HTTPException(status_code=404)
+
+    for channel in STREAM["channels"]:
+        if channel["id"] == id:
+            meta = {
+                "id": id,
+                "type": "tv",
+                "name": channel["title"],
+                "poster": channel["poster"],  # Add poster URL if available
+                "description": f"Watch {channel['title']}",
+                "background": "",  # Add background image URL if available
+                "logo": "",  # Add logo URL if available
+                "videos": [{
+                    "title": channel["title"],
+                    "streams": [{
+                        "title": channel["title"],
+                        "url": channel["url"]
+                    }]
+                }]
+            }
+            return respond_with({"meta": meta})
+
+    raise HTTPException(status_code=404)
+
+
+@app.get('/stream/{type}/{id}.json')
+async def addon_stream(type, id):
+    if type not in MANIFEST['types']:
+        raise HTTPException(status_code=404)
+    streams = {'streams': []}
+    async with httpx.AsyncClient() as client:
+        if type == "tv":
+            for channel in STREAM["channels"]:
+                if channel["id"] == id:
+                    streams['streams'].append({
+                        'title': channel['name'],
+                        'url': channel['url']
+                        })
+                    if id in okru:
+                        channel_url = await okru_get_url(id,client)
+                        streams['streams'].append({
+                            'title': channel['name'] + "OKRU",
+                            'url': channel_url
+                        })
+            if not streams['streams']:
+                raise HTTPException(status_code=404)
+            return respond_with(streams)
+        else:
+            logging.debug(f"Handling movie or series: {id}")
+            if "kitsu" in id:
+                if ANIMEWORLD == "1":
+                    animeworld_urls = await animeworld(id,client)
+                    print(animeworld_urls)
+                    if animeworld_urls:
+                        i = 0
+                        for url in animeworld_urls:
+                            if url:
+                                if i == 0:
+                                    title = "Original"
+                                elif i == 1:
+                                     title = "Italian"
+                                streams['streams'].append({'title': f'{HF}Animeworld {title}', 'url': url})
+                                i+=1
+            else:
+                if MYSTERIUS == "1":
+                    results = await cool(id,client)
+                    if results:
+                        for resolution, link in results.items():
+                            streams['streams'].append({'title': f'{HF}Mysterious {resolution}', 'url': link})
+                if STREAMINGCOMMUNITY == "1":
+                    url_streaming_community,url_720_streaming_community,quality_sc = await streaming_community(id,client)
+                    if url_streaming_community is not None:
+                        if quality_sc == "1080":
+                            streams['streams'].append({'title': f'{HF}StreamingCommunity 1080p Max', 'url': url_streaming_community})
+                            streams['streams'].append({'title': f'{HF}StreamingCommunity 720p Max', 'url': url_720_streaming_community})
+                        else:
+                            streams['streams'].append({'title': f'{HF}StreamingCommunity 720p Max', 'url': url_streaming_community})
+                if LORDCHANNEL == "1":
+                    url_lordchannel,quality_lordchannel = await lordchannel(id,client)
+                    if quality_lordchannel == "FULL HD" and url_lordchannel !=  None:
+                        streams['streams'].append({'title': f'{HF}LordChannel 1080p', 'url': url_lordchannel})
+                    elif url_lordchannel !=  None:
+                        streams['streams'].append({'title': f'{HF}LordChannel 720p', 'url': url_lordchannel})            
+                if FILMPERTUTTI == "1":
+                    url_filmpertutti = await filmpertutti(id,client)
+                    if url_filmpertutti is not None:
+                        streams['streams'].append({'title': 'Filmpertutti', 'url': url_filmpertutti})
+                if TUTTIFILM == "1":
+                    url_tuttifilm = await tantifilm(id,client)
+                    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}})
+                if STREAMINGWATCH == "1":
+                    url_streamingwatch = await streamingwatch(id,client)
+                    if url_streamingwatch:
+                        streams['streams'].append({'title': f'{HF}StreamingWatch 720p', 'url': url_streamingwatch})
+        if not streams['streams']:
+            raise HTTPException(status_code=404)
+
+    return respond_with(streams)
+
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run("run:app", host=HOST, port=PORT, log_level="info")

streamingcommunity.py

@@ -0,0 +1,219 @@
+from tmdbv3api import TMDb, Movie, TV
+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
+from urllib.parse import urlparse, parse_qs
+
+#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:
+async def get_version(client):
+    #Extract the version from the main page of the site
+
+
+    try:
+        base_url = f'https://streamingcommunity.{SC_DOMAIN}/richiedi-un-titolo'
+        response = await client.get(base_url, headers=headers, follow_redirects=True)
+        #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
+
+async def search(query,date,ismovie, client):
+    #Do a request to get the ID of serie/move and it's slug in the URL
+    response = await client.get(query, follow_redirects=True)
+    response = response.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:
+                    response = await client.get ( f'https://streamingcommunity.{SC_DOMAIN}/titles/{tid}-{slug}', follow_redirects=True)
+                    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")
+
+        
+async def get_film(tid,version,client):  
+    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",
+            'x-inertia': 'true',
+            #Version of streaming community
+            'x-inertia-version': version
+        }
+    #Access the iframe
+    url = f'https://streamingcommunity.{SC_DOMAIN}/iframe/{tid}'
+    response = await client.get(url, headers=headers, follow_redirects=True)
+    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]
+    parsed_url = urlparse(iframe)
+    query_params = parse_qs(parsed_url.query)
+    #Get real token and expires by looking at the page in the iframe, vixcloud/embed
+    resp = await client.get(iframe, headers = headers, follow_redirects=True)
+    soup=  BeautifulSoup(resp.text, "lxml")
+    script = soup.find("body").find("script").text
+    token = re.search(r"'token':\s*'(\w+)'", script).group(1)
+    expires = re.search(r"'expires':\s*'(\d+)'", script).group(1)
+    quality = re.search(r'"quality":(\d+)', script).group(1)
+    #Example url  https://vixcloud.co/playlist/231315?b=1&token=bce060eec3dc9d1965a5d258dc78c964&expires=1728995040&rendition=1080p
+    url = f'https://vixcloud.co/playlist/{vixid}?token={token}&expires={expires}'
+    if 'canPlayFHD' in query_params:
+       canPlayFHD = 'h=1'
+       url += "&h=1"
+    if 'b' in query_params:
+       b = 'b=1'
+       url += "&b=1"
+    url720 = f'https://vixcloud.co/playlist/{vixid}'
+    return url,url720,quality,
+
+async def get_season_episode_id(tid,slug,season,episode,version,client):
+    #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 = await client.get(f'https://streamingcommunity.{SC_DOMAIN}/titles/{tid}-{slug}/stagione-{season}', headers=headers, follow_redirects=True)
+    # 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']
+
+async def get_episode_link(episode_id,tid,version,client):
+    #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 = await client.get(f"https://streamingcommunity.{SC_DOMAIN}/iframe/{tid}", params=params, follow_redirects=True)
+
+    # 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]
+    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",
+            'x-inertia': 'true',
+            #Version of streaming community
+            'x-inertia-version': version
+         }
+    parsed_url = urlparse(iframe)
+    query_params = parse_qs(parsed_url.query)
+    #Get real token and expires by looking at the page in the iframe, vixcloud/embed
+    resp = await client.get(iframe, headers = headers, follow_redirects=True)
+    soup=  BeautifulSoup(resp.text, "lxml")
+    script = soup.find("body").find("script").text
+    token = re.search(r"'token':\s*'(\w+)'", script).group(1)
+    expires = re.search(r"'expires':\s*'(\d+)'", script).group(1)
+    quality = re.search(r'"quality":(\d+)', script).group(1)
+    #Example url  https://vixcloud.co/playlist/231315?b=1&token=bce060eec3dc9d1965a5d258dc78c964&expires=1728995040&rendition=1080p
+    url = f'https://vixcloud.co/playlist/{vixid}?token={token}&expires={expires}'
+    if 'canPlayFHD' in query_params:
+       canPlayFHD = 'h=1'
+       url += "&h=1"
+    if 'b' in query_params:
+       b = 'b=1'
+       url += "&b=1"
+    url720 = f'https://vixcloud.co/playlist/{vixid}'
+    return url,url720,quality
+
+
+async def streaming_community(imdb,client):
+    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 = await get_info_imdb(imdb_id,ismovie,type,client)
+                    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 = await get_TMDb_id_from_IMDb_id(imdb_id,client)
+                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 = await get_info_imdb(imdb_id,ismovie,type,client)
+            else:
+                    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 = await search(query,date,ismovie,client)
+        version = await get_version(client)
+        if ismovie == 1:
+            #TID means temporaly ID
+            url,url720,quality = await get_film(tid,version,client)
+            print(url)
+            return url,url720,quality
+        if ismovie == 0:
+            #Uid = URL ID
+            episode_id = await get_season_episode_id(tid,slug,season,episode,version,client)
+            url,url720,quality = await get_episode_link(episode_id,tid,version,client)
+            print(url)
+            return url,url720,quality
+    except Exception as e:
+        print("StreamingCommunity failed")
+        return None,None,None

streamingwatch.py

@@ -0,0 +1,103 @@
+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 re
+import json
+SW_DOMAIN = config.SW_DOMAIN
+async def search(showname,season,episode,date,ismovie,client):
+    if ismovie == 1:
+        query = f'https://www.streamingwatch.{SW_DOMAIN}/wp-admin/admin-ajax.php'
+        headers = {
+            'authority': f'www.streamingwatch.{SW_DOMAIN}',
+            'accept': '*/*',
+            'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            # 'cookie': 'wordpress_test_cookie=WP%20Cookie%20check',
+            'origin': f'https://www.streamingwatch.{SW_DOMAIN}',
+            'referer': f'https://www.streamingwatch.{SW_DOMAIN}',
+            'sec-ch-ua': '"Not-A.Brand";v="99", "Chromium";v="124"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Android"',
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-origin',
+            'user-agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+            'x-requested-with': 'XMLHttpRequest',
+        }
+        data = {
+            'action': 'data_fetch',
+            'keyword': showname,
+            '_wpnonce': '648328b831',
+        }
+        cookies = {
+             'wordpress_test_cookie': 'WP%20Cookie%20check',
+        }
+        response = await client.post(query,cookies=cookies, headers=headers, data=data)
+        soup = BeautifulSoup(response.content,'lxml')
+        page_date = soup.find(id = 'search-cat-year').text.strip()
+        if page_date == date:
+           href = soup.find('a')['href']
+           response = await client.get(href, follow_redirects=True)
+           soup = BeautifulSoup(response.text,'lxml',parse_only=SoupStrainer('iframe'))
+           iframe = soup.find('iframe')
+           hdplayer = iframe.get('data-lazy-src')
+
+           return hdplayer
+    elif ismovie == 0:
+        #Some series have the name in english so we first search with the categories option and then we use the obtained ID to get all the episodes
+        id_response = await client.get(f'https://streamingwatch.{SW_DOMAIN}/wp-json/wp/v2/categories?search={showname}&_fields=id', follow_redirects=True)
+        data = json.loads(id_response.text)
+        category_id = data[0]['id']
+        query = f'https://streamingwatch.{SW_DOMAIN}/wp-json/wp/v2/posts?categories={category_id}&per_page=100'
+        response = await client.get(query, follow_redirects=True)
+        data_json = response.text
+        data = json.loads(data_json)
+        for entry in data:
+            if f"stagione-{season}-episodio-{episode}" in entry["slug"]:
+                content = entry["content"]["rendered"]
+                #"content":{
+#    "rendered":"<p><!--baslik:PRO--><iframe loading=\"lazy\" src=\"https:\/\/hdplayer.gives\/embed\/YErLVq64uNTZRNz\" frameborder=\"0\" width=\"700\" height=\"400\" allowfullscreen><\/iframe><\/p>\n","protected":false}
+                start = content.find('src="') + len('src="') #start of url
+                end = content.find('"', start) #end of url
+                hdplayer = content[start:end]
+                return hdplayer
+async def hls_url(hdplayer,client):
+    response = await client.get(hdplayer, follow_redirects=True)
+    match = re.search(r'sources:\s*\[\s*\{\s*file\s*:\s*"([^"]*)"', response.text)
+    url = match.group(1)
+    print(url)
+    return url
+async def streamingwatch(imdb,client):
+    try:
+       general = is_movie(imdb)
+       ismovie = general[0]
+       imdb_id = general[1]
+       type = "StreamingWatch"
+       if ismovie == 0:
+           season  = int(general[2])
+           episode = int(general[3])
+           if "tt" in imdb:
+               tmdba = await get_TMDb_id_from_IMDb_id(imdb_id,client)
+           else:
+               tmdba = imdb_id
+       else:
+           season = None
+           episode = None
+           if "tt" in imdb:
+               tmdba = await get_TMDb_id_from_IMDb_id(imdb_id,client)
+           else:
+               tmdba = imdb_id
+       showname,date = get_info_tmdb(tmdba,ismovie,type)
+       showname = showname.replace(" ", "+").replace("–", "+").replace("—","+")
+       hdplayer = await search(showname,season,episode,date,ismovie,client)
+       url = await hls_url(hdplayer,client)
+       return url
+    except:
+          print("StreamingWatch Failed")
+          return None

tantifilm.py

@@ -0,0 +1,267 @@
+import requests
+from bs4 import BeautifulSoup,SoupStrainer
+import re
+import time
+from info import is_movie,get_info_imdb,get_info_tmdb
+import config
+from loadenv import load_env
+TF_FAST_SEARCH = config.TF_FAST_SEARCH
+TF_DOMAIN = config.TF_DOMAIN
+HF = config.HF
+env_vars = load_env()
+PROXY_CREDENTIALS = env_vars.get('PROXY_CREDENTIALS')
+
+
+async def search(showname,ismovie,date,client):
+    url = f'https://www.tanti.{TF_DOMAIN}/search/{showname}'
+    response =  await client.get(url, follow_redirects=True)
+    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 = client.get(url, follow_redirects=True)
+            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 = await client.get(url, follow_redirects=True)
+            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
+            
+async def fast_search(showname,ismovie,client):
+    url = f'https://www.tanti.{TF_DOMAIN}/search/{showname}'
+    response = await client.get(url, follow_redirects=True)
+    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 = await client.get(url, follow_redirects=True)
+        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
+
+
+
+async def get_protect_link(id,url,client):
+        #Get the link where the Iframe is located, which contains the doodstream url kind of. 
+        response = await client.get(f"https://p.hdplayer.casa/myadmin/play.php?id={id}", follow_redirects=True)
+        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 = await client.get(url, follow_redirects=True)
+            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 = await client.post(ajax_url, headers=headers, data=data)
+            hdplayer = response.text[43:-27]
+            response = await client.get(hdplayer, follow_redirects=True)
+            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 = await client.get(href, follow_redirects=True)
+                    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
+                    
+
+async def get_nuovo_indirizzo_and_protect_link(url,embed_id,season,episode,client):
+    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 = await client.post(ajax_url, headers=headers, data=data)
+    nuovo_indirizzo = response.text[43:-27]
+    response = await client.get(nuovo_indirizzo, follow_redirects=True)
+    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 = await client.get(link, follow_redirects=True)
+        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 = await client.get(link, follow_redirects=True)
+        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 = await client.get(link, follow_redirects=True)
+        soup = BeautifulSoup(response.text, "lxml", parse_only=SoupStrainer('iframe'))
+        protect_link = soup.iframe['src'] 
+        return  protect_link
+
+
+async def true_url(protect_link,client):
+    print(protect_link)
+    # Define headers
+    headers = {
+        "Range": "bytes=0-",
+        "Referer": "https://d000d.com/",
+    }
+    if HF == "1":
+        proxy = PROXY_CREDENTIALS
+        proxies = {
+            "http": proxy,
+            "https": proxy
+        }
+        response = await client.get(protect_link, proxies=proxies, follow_redirects=True)
+    else:
+        response = await client.get(protect_link, follow_redirects=True)
+    link = response.url
+ 
+    
+    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]}'
+            print("MD5: ", url)
+            rebobo = await client.get(url, headers=headers, follow_redirects=True)
+            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
+async def tantifilm(imdb,client):
+    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 = await get_info_imdb(imdb_id,ismovie,type,client)
+                    url,embed_id = await search(showname,ismovie,date,client)
+                elif TF_FAST_SEARCH == "1":
+                    showname = await get_info_imdb(imdb_id,ismovie,type,client)
+                    url,embed_id = await fast_search(showname,ismovie,client)
+            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 = await search(showname,ismovie,date,client)
+                    elif TF_FAST_SEARCH == "1":
+                        showname= get_info_tmdb(tmdba,ismovie,type)
+                        url,embed_id = await fast_search(showname,ismovie,client)
+            protect_link = await get_nuovo_indirizzo_and_protect_link(url,embed_id,season,episode,client)
+            url = await true_url(protect_link,client)
+            return url
+        elif ismovie == 1:
+            if "tt" in imdb:
+                #Get showname
+                    if TF_FAST_SEARCH == "0":
+                        showname,date = await get_info_imdb(imdb_id,ismovie,type,client)
+                        tid,url = await search(showname,ismovie,date,client)
+                    elif TF_FAST_SEARCH == "1":
+                        showname = await get_info_imdb(imdb_id,ismovie,type,client)
+                        date = None
+                        tid,url = await fast_search(showname,ismovie,client)
+            else:
+            
+                #else just equals themtantifilm("tt2096673")
+
+                if TF_FAST_SEARCH == "0":
+                    showname,date = get_info_tmdb(imdb,ismovie,type)
+                    tid,url = await search(showname,ismovie,date,client)
+                elif TF_FAST_SEARCH == "1":
+                    showname = get_info_tmdb(imdb,ismovie,type)
+                    tid,url = await fast_search(showname,ismovie,client)
+            protect_link = await get_protect_link(tid,url,client)
+            if not isinstance(protect_link, str):
+                urls = protect_link
+                if urls:
+                    return urls
+                else:
+                    print("Tantifilm Error v2")
+            else:
+                url = await true_url(protect_link,client)
+                if url:
+                    return url
+
+    except Exception as e:
+        print("Tantifilm Error: ", e)
+        return None