Fixed LordChannel Series

Animeworld support

.gitignore

@@ -1,2 +1,2 @@
 .env
-streamingcommunity.py
+__pycache__/

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"]

Dockerfiles/Dockerfile-auto-update

@@ -0,0 +1,23 @@
+ 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
+
+# Install git
+RUN apt-get update && apt-get install -y git
+
+# Clone the repository
+RUN git clone https://github.com/UrloMythus/MammaMia.git .
+
+# Copy the local config.json file to the container
+COPY config.json /app/config.json
+
+# 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"]

Dockerfiles/Dockerfile-auto-update-no-config

@@ -0,0 +1,21 @@
+ 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
+
+# Install git
+RUN apt-get update && apt-get install -y git
+
+# Clone the repository
+RUN git clone https://github.com/UrloMythus/MammaMia.git .
+
+
+# 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.

README.md

@@ -1,35 +1,368 @@
+
+  
+
+  
+
 # MammaMia
 
-A Stremio Addon for high quality HTTPS Stream in Italian
   
-While hosting, this project, remember that Filmpertutti uses Mixdrop. Mixdrop only allows seeing the videos only from the same IP where they were generated so, if you want to scrape filmpertutti, you have to host this project locally. Else, you can only scrape streamingcommunity.  
+
+  
+
+  
+
+  
+
+A Stremio Addon for high quality HTTPS Streams in Italian
+
+Movies, Series, Anime and Live TV are supported.
+
+  
+
+  
+
+  
+
+  
+
+While hosting, this project, remember that Filmpertutti uses Mixdrop. Mixdrop only allows seeing the videos from the same IP where they were generated so, if you want to scrape filmpertutti, you will have to host this project locally. Else, you can only scrape other providers.
+
+  
+
+  
+
+  
+
+Hosting your own instance is suggested, but you can use the public instance [linked](https://mammamia-urlo-mammamia.hf.space/) in the About Page of the repo.
+
+  
+
+  
+
+  
 
   
 
 # Installation
 
-Install required packages
   
-``
-pip install -r requirements.txt
-``
 
-Then to start the Flask server just execute:
+  
-``
+
-python3 run.py
+  
-``
+
+## Local
+
+  
+
+  
+
+  
+
+1. Install required packages
+
+  
+
+  
+
+  
+
+``pip install -r requirements.txt ``
+
+  2. Create a .env file and fill it (look at example.env)
+
+    
+
+  
+
+3. Then to start the Fast API app server just execute:
+
+  
+
+  
+
+``python3 run.py``
+
+  
+
+
+
+  
+
+## Hugging Face
+
+  
+
+  
+
+  
+
+To host this project with Hugging Face, go to the [linked](https://huggingface.co/spaces/MammaMia-Urlo/CloneThisSpace/) page and follow these steps:
+
+  
+
+  
+
+  
+
+  
+
+1. Create an Hugging Face Account [here](https://huggingface.co/join)
+
+  
+
+  
+
+  
+
+2. Go to [linked](https://huggingface.co/spaces/MammaMia-Urlo/CloneThisSpace) page and click on three dots on the top (right) part of the screen
+
+  
+
+  
+
+  
+
+3. Click Duplicate this Space
+
+  
+
+  
+
+  
+
+4. Insert TMDB Key and set visibility to Public
+
+  
+
+  
+
+  
+
+5. Clone the Project
+
+  
+6. Go into settings and click on Factory Rebuild.
+  
+
+  
+
+7. You are done!
+
+  
+
+  
+
+  
+
+8. To install it on Stremio altought, you will need the Direct URL. It can be found on three dots --> Embed This Space --> Direct URL      
+   If you do not find it it means your space is Private. To fix so go to Settings and click Set Visibility to Public. 
+
+  
+
+  
+
+  
+
+9. How do I handle updates? To update the addon you will have to Factory Rebuild your space (in Settings) and, if there are any changes to config.json, copy them from [here](https://github.com/UrloMythus/MammaMia/blob/main/config.json) to the config.json in your Space, under Files.
+  
+
+10. How can I use Live TV? For now it won't work on public instances. Wait until next update.
+
+
+  
+
+  
+Technical Details:
+On Hugging Face you are forced to use the 8080 port because it is the only one allowed to send/get network requests. Moreover, remember that load_env and Public Instance need to be disabled in the config.json (it should be by default if you clone the project from HF)
+
+  
+
+  
+
+  
+
+## Render
+
+  
+
+  
+
+  
+
+To install this project on [Render](https://render.com/) follow these steps:
+
+  
+
+  
+
+  
+
+1. Create an Account
+
+  
+
+  
+
+  
+
+2. Create a Web Service
+
+  
+
+  
+
+  
+
+3. Fork the repo and then connect it to Render
+
+  
+
+  
+
+  
+
+4. Among the other environment variables, put PORT = 8080. This is needed because Render needs the Port given as an environment variable. Remember to put TMDB_KEY as an enviroment variable.
+
+  
+
+  
+
+  
+
+5. As build command put `` pip install -r requirements `` and as run command put ``python3 run.py ``
+
+  
+
+  
+
+  
+
+6. Then just finish Render Setup and you are done :)
+
+  
+
+  
+
+Remember, load_env and Public Instance needs to be disabled in the config.json
+
+  
+
+  
+
+  
+
+  
+
+  
+
 # How to add to Stremio
-Just paste the URL/manifest.json in your search bar.
+
+  
+
+  
+
+  
+
+Open your instance URL and configure MammaMia. Once you are done you can click on INSTALL Button. If it doesn't work click on Generate Manifest and copy it. Then paste it  in Stremio Search Bar. If you are on Mac or on Web go to addons, click Add an Addon, and paste it there.
+
+  
+
+  
+
+  
+
 # Enviroment Variables
 
+  
+
+  
+
+  
+
+  
+
 | Enviroment Variable | Value |
 |-------------------------|---|
 |TMDB_KEY|INSERT YOUR API KEY HERE|
-| FT_DOMAIN | INSERT FILMPERTUTTI DOMAIN |
-|SC_DOMAIN |  INSERT STREAMINGCOMMUNITY DOMAIN|
-|FILMPERTUTTI|Put "1" if you want Filmpertutti to be enabled, "0" if disabled Altought keep in mind that you will only be able to use it if you get the link from the same IP of your streaming server.|
-|STREAMINGCOMMUNITY|Put "1" if enabled, "0" if disabled|
 
   
 
-Here is [linked](https://developer.themoviedb.org/docs/getting-started) a tutorial about how to get a TMDB KEY
+  
+
+  
+
+Here is [linked](https://www.themoviedb.org/settings/api) a tutorial about how to get a TMDB KEY
+
+  
+
+  
+
+  
+
+# Config
+
+  
+
+  
+
+In the repo there is a config.json that you can modify to change some aspects of the addon like the domains of the sites. Down here all explained:
+
+  
+
+  
+
+| Config | Value |
+|-------------------------|---|
+| Domain | The domain of the site, must be a string |
+|enabled | If the site is enabled or not. "1" means true. "0" means false. Remember, there is no point in enabling filmpertutti on a remote server since it's IP-LOCKED|
+|fast_search|"1" for enabled, "0" for disabled. It enables a faster search for supported providers but it is less accurate|
+|load_env|Put "1" if enabled, "0" if disabled. It needs to be enabled if you need to load a .env file. On remote hosting services, like Hugging Face or Render, it needs to be disabled. |
+|HOST| The host for the Fast API APP|
+|PORT| The port for the Fast API APP. Default: 8080 |
+
+  
+
+For now Mysterius must be kept disabled if you do not know what you are doing.
+
+For now Tantifilm, even if its player is not IP-Locked, does not work on Hugging Face.
+
+  
+
+Check those links to get the new Domain for the providers.
+
+  
+
+[FILMPERTUTTI](https://filmpertuttiiii.nuovo.live/)
+
+  
+
+[STREAMINGCOMMUNITY](https://t.me/+jlXmmprhtakxYWJh)
+
+  
+
+[TANTIFILM](https://tantinuovo.com/tantifilm-nuovo-indirizzo/)
+
+  
+
+[STREAMINGWATCH](https://t.me/streamingwatch)
+
+  
+
+[LORDCHANNEL](https://t.me/+5MQwrb3eqb81NGI0)
+
+  
+
+[ANIMEWORLD](https://t.me/AnimeWorldITA2)
+
+
+## Credits
+
+ - Big thanks to [Lovi0](https://github.com/Lovi-0), the creator of StreamingCommunity downloader, for helping me with some aspects of this project.
+ - This project uses [MediaFlowProxy](https://github.com/mhdzumair/mediaflow-proxy/) in order to be able to play some Live TV channels. Big thanks to his creator, [mhdzumair](https://github.com/mhdzumair)
+
+## Disclaimer
+This project does not host any  illegal content on his servers, if you want any content  to be taken down, please contact the actual owners of those sites.  
+The Live TV sources are taken from online sites, avaiable on the web and indixed by Google. 
+
+

Src/API/animeworld.py

@@ -0,0 +1,169 @@
+
+from bs4 import BeautifulSoup
+import datetime
+import json
+from Src.Utilities.info import get_info_kitsu
+import Src.Utilities.config as config
+import re
+AW_DOMAIN = config.AW_DOMAIN
+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",
+    "Season": "",
+    "  ": " ",
+    "Shippuuden": "Shippuden",
+    " ": "+",
+}
+
+async def get_mp4(anime_url,ismovie,episode,client):
+    response = await client.get(anime_url,allow_redirects=True, impersonate = "chrome120")
+    soup = BeautifulSoup(response.text,'lxml')
+    if ismovie == 0:
+        episode_page = soup.find('a', {'data-episode-num':episode })
+        if episode_page is None:
+            return None
+        episode_page = f'https://animeworld.{AW_DOMAIN}{episode_page["href"]}'
+        response = await client.get(episode_page,allow_redirects=True, impersonate = "chrome120")
+        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,allow_redirects=True, impersonate = "chrome120")
+
+    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, allow_redirects=True, impersonate = "chrome120")
+    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}',allow_redirects=True, impersonate = "chrome120")
+    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,allow_redirects=True, impersonate = "chrome120")
+        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")
+        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]
+        ismovie = 1 if len(id.split(":")) == 2 else 0
+        if ismovie == 1:
+            episode = None
+        else:
+            episode = id.split(":")[2]
+        showname,date = await get_info_kitsu(kitsu_id,client)
+        for key in showname_replace:
+            if key in showname:  # Check if the key is a substring of showname
+                showname = showname.replace(key, showname_replace[key])
+                if "Naruto:" in showname:
+                    showname = showname.replace(":", "")
+        final_urls = await search(showname,date,ismovie,episode,client)
+        return final_urls
+    except:
+        print("Animeworld failed")
+        return None
+'''
+async def test_animeworld():
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "kitsu:11407"  # This is an example ID format
+        results = await animeworld(test_id, client)
+        print(results)
+
+if __name__ == "__main__":
+    from curl_cffi.requests import AsyncSession
+    import asyncio
+    asyncio.run(test_animeworld())
+    '''

Src/API/cb01.py

@@ -0,0 +1,265 @@
+import re
+from bs4 import BeautifulSoup,SoupStrainer
+from Src.Utilities.info import is_movie,get_info_tmdb,get_info_imdb
+from Src.Utilities.convert import get_TMDb_id_from_IMDb_id
+from fake_headers import Headers
+import Src.Utilities.config as config
+ForwardProxy_list = config.ForwardProxy
+ForwardProxy = ForwardProxy_list[0]
+fake_headers = Headers()
+
+async def get_stayonline(link,client):
+    headers = {
+                    'origin': 'https://stayonline.pro',
+                    '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',
+                }
+    data = {'id': link.split("/")[-2], 'ref': ''}
+    response = await client.post('https://stayonline.pro/ajax/linkEmbedView.php', headers=headers, data=data)
+    real_url = response.json()['data']['value']
+    print(real_url)
+    return real_url
+
+
+async def get_uprot(link,client):
+        if "msf" in link:
+             link = link.replace("msf","mse")
+
+        headers = fake_headers.generate()
+        response = await client.get(link, headers=headers, allow_redirects=True, timeout=10)
+        soup = BeautifulSoup(response.text, "lxml")
+        maxstream_url = soup.find("a")
+        maxstream_url = maxstream_url.get("href")
+        return maxstream_url
+
+async def get_true_link_mixdrop(real_link,client):
+    try:
+        import string
+        headers = fake_headers.generate()
+        response = await client.get(real_link, headers=headers, allow_redirects=True,timeout = 30)
+        [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
+        print(s)    
+        return s
+    except Exception as e:
+        return None
+async def get_true_link_maxstream(maxstream_url,client):
+        headers = fake_headers.generate()
+        # Send a GET request to the Maxstream URL
+        response = await client.get(maxstream_url, headers=headers, allow_redirects=True, timeout=10)
+        [s1, s2] = re.search(r"\}\('(.+)',.+,'(.+)'\.split", response.text).group(1, 2)
+        terms = s2.split("|")
+        urlset_index = terms.index('urlset')
+        hls_index = terms.index('hls')
+        sources_index =  terms.index('sources')
+        result = terms[urlset_index + 1 : hls_index]
+        reversed_elements = result[::-1]
+        first_part = terms[hls_index +1 : sources_index]
+        reversed_first_part = first_part[::-1]
+        first_url_part = ""
+        for first_part in reversed_first_part:
+                if "0" in first_part:
+                        first_url_part += first_part
+                else:
+                        first_url_part += first_part + "-"  
+        
+
+
+        base_url = f"https://{first_url_part}.host-cdn.net/hls/" 
+        if len(reversed_elements) == 1:
+                final_url = base_url + "," + reversed_elements[0] + ".urlset/master.m3u8"
+        lenght = len(reversed_elements)
+        i = 1    
+        for element in reversed_elements:
+                base_url += element + ","
+                if lenght == i:
+                        base_url += ".urlset/master.m3u8"
+                else:
+                        i += 1
+        final_url = base_url
+        return final_url
+
+async def search_movie(showname,date,client):
+    try:
+        showname = showname.replace(" ","+")
+        headers = fake_headers.generate()
+        headers['Referer'] = 'https://cb01.technology/'
+        query = f'https://cb01.technology/?s={showname}'
+        response = await client.get(query,headers=headers)
+        soup = BeautifulSoup(response.text, 'lxml',parse_only=SoupStrainer('div', class_='card-content'))
+        cards = soup.find_all('div', class_='card-content')
+        year_pattern = re.compile(r'(19|20)\d{2}')
+        for card in cards:
+    # Find the link inside the current card
+            link_tag = card.find('h3', class_='card-title').find('a')
+            href = link_tag['href']
+    
+    # Find the date span and extract possible years
+            date_span = card.find('span', style=re.compile('color'))
+            if date_span:
+                date_text = date_span.text
+                # Search for the first occurrence of a year (starting with 19 or 20)
+                match = year_pattern.search(date_text)
+                if match:
+                    year = match.group(0)
+                    if year == date :  # Check if the year is 2011
+                        print(f"Link: {href}")
+                        return href
+    except Exception as e:
+        print(f'MammaMia: Error in search_series cb01: {e}')
+
+
+async def search_series(showname,date,client):
+    try:
+        showname = showname.replace(" ","+")
+        headers = fake_headers.generate()
+        headers['Referer'] = 'https://cb01.technology/serietv/'
+        query = f'https://cb01.technology/serietv/?s={showname}'
+        response = await client.get(query,headers=headers)
+        soup = BeautifulSoup(response.text, 'lxml',parse_only=SoupStrainer('div', class_='card-content'))
+        cards = soup.find_all('div', class_='card-content')
+        year_pattern = re.compile(r'(19|20)\d{2}')
+        for card in cards:
+    # Find the link inside the current card
+            link_tag = card.find('h3', class_='card-title').find('a')
+            href = link_tag['href']
+    
+    # Find the date span and extract possible years
+            date_span = card.find('span', style=re.compile('color'))
+            if date_span:
+                date_text = date_span.text
+                # Search for the first occurrence of a year (starting with 19 or 20)
+                match = year_pattern.search(date_text)
+                if match:
+                    year = match.group(0)
+                    if year == date :  # Check if the year is 2011
+                        print(f"Link: {href}")
+                        return href
+    except Exception as e:
+        print(f'MammaMia: Error in search_series cb01: {e}')
+
+async def movie_redirect_url(link,client):
+        headers = fake_headers.generate()
+        response = client.get(link, headers=headers, allow_redirects=True, timeout=10)
+        # Extract the redirect URL from the HTML
+        soup = BeautifulSoup(response.text, "lxml",parse_only=SoupStrainer('div', id='iframen1'))
+        redirect_url = soup.find("div", id="iframen1").get("data-src")
+        return redirect_url
+async def series_redirect_url(link,season,episode,client):
+        if len(episode) == 1:
+                        episode = f'0{episode}'
+        headers = fake_headers.generate()
+        response = await client.get(link, headers=headers, allow_redirects=True, timeout=10)
+        soup = BeautifulSoup(response.text, "lxml")     
+        seasons_text = soup.find_all('div', class_='sp-head')
+        for season_text in seasons_text:
+            text = season_text.text
+            if f'STAGIONE' in text and f'{season}' in text:
+                text = text.replace("STAGIONE","").replace("ITA", "")
+                if "A" in text:
+                    if len(season) == 1:
+                        season = f'0{season}'
+                    sp_body = season_text.find_next('div', class_='sp-body')
+                    link_tag = sp_body.find('a')
+                    uprot_long = link_tag.get('href')
+                    response = await client.get(uprot_long, headers=headers, allow_redirects=True, timeout=10)
+                    season = "01"
+                    episode = "04"
+                    pattern1 = rf"(?i)\S*?\.{season}x{episode}\S*?\.mkv.*?href=['\"](.*?)['\"]"
+                    pattern2 = rf"\S*\.S{season}E{episode}\S*?\.mkv.*?href=['\"](.*?)['\"]"
+                    match = re.search(pattern1, response.text)
+                    if match:
+                            maxstream_link = match.group(1)
+                    else:
+                         match = re.search(pattern2, response.text)
+                         if match:
+                              maxstream_link = match.group(1)
+                    print(maxstream_link)
+                    if "stayonline" in maxstream_link:
+                            maxstream_link =await get_stayonline(maxstream_link,client)
+                    maxstream_real_link = await get_uprot(maxstream_link,client)
+                    final_url = await get_true_link_maxstream(maxstream_real_link,client)
+                    print(final_url)
+
+                else:
+                    pattern = re.compile(r'4&#215;03\s*&#8211;.*?<a href="(.*?)".*?>Maxstream</a>\s*&#8211;.*?<a href="(.*?)".*?>Mixdrop</a>', re.DOTALL)
+                    match = pattern.search(response.text)
+                    maxstream_link = match.group(1)
+                    mixdrop_link = match.group(2)
+                    print(f"Maxstream: {maxstream_link}")
+                    print(f"Mixdrop: {mixdrop_link}")
+                    mixdrop_real_link = await get_stayonline(mixdrop_link,client)
+                    final_url = await get_true_link_mixdrop(mixdrop_real_link,client)
+                    if final_url == None:
+                        if "stayonline" in maxstream_link:
+                            maxstream_link =await get_stayonline(maxstream_link,client)
+                        maxstream_real_link = await get_uprot(maxstream_link,client)
+                        final_url = await get_true_link_maxstream(maxstream_real_link,client)
+                        print(final_url)
+                        
+
+
+
+
+async def cb01(id,client):
+    try:
+        general = is_movie(id)
+        ismovie = general[0]
+        real_id = general[1]
+        type = "Cb01"
+        if "tt" in id:
+            showname, date = await get_info_imdb(real_id,ismovie,type,client)
+        elif  "tmdb" in real_id:
+            showname, date = get_info_tmdb(real_id,ismovie,type)
+        if ismovie == 0:
+            season = general[2]
+            episode = general[3]
+            link = await search_series(showname,date,client)
+            redirect_url = await series_redirect_url(link,season,episode,client)
+        elif ismovie == 1:
+            season = None
+            episode = None
+            link = await search_movie(showname,date,client)
+            redirect_url = await movie_redirect_url(link,client)
+    except Exception as e:
+        print(f'MammaMia: Error in cb01: {e}')
+        return None
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "tt0158552:1:1"  # This is an example ID format
+        results = await cb01(test_id, client)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+'''
+

Src/API/cool.py

@@ -0,0 +1,160 @@
+import json
+from Src.Utilities.info import get_info_tmdb,is_movie
+from Src.Utilities.convert import get_TMDb_id_from_IMDb_id
+from Src.Utilities.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)
+            print(response.text)
+        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 Exception as e:
+        print(f"Request error: {e}")
+        return None
+    
+
+# Example usage: Fetch video links
+
+
+# Print the dictionary
+
+
+
+
+
+async def search_imdb(showname,tmdba,client):
+        showname = showname.replace(" ","%20")
+        tmdba = str(tmdba)
+        query = f'https://altadefinizione-originale.com/api/search?search={showname}&page=1'
+        response = await client.get(query,allow_redirects=True, impersonate = "chrome120")
+        if response.status_code == 200:
+            data = response.json()
+            if 'data' in data:
+                for item in data['data']:
+                    tmdb_id = item.get('tmdb_id')
+                    tmdb_id = ''.join(char for char in tmdb_id if char.isdigit())
+                    if 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)
+        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 = await get_links(slug,season,episode,ismovie,client)
+            results = parse_links(resolution_links)
+            return results
+    except Exception as e:
+        print("Cool Error",e)
+        return None
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "tt1839578:1:1"  # This is an example ID format
+        results = await cool(test_id, client)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+'''

Src/API/ddlstream.py

@@ -0,0 +1,161 @@
+import requests
+import re
+from bs4 import BeautifulSoup, SoupStrainer
+from Src.Utilities.info import get_info_imdb, is_movie, get_info_tmdb
+import urllib.parse
+cookies = {
+    'ips4_device_key': 'b6f084be79c28bb53ecfc556fd7a2a70',
+    'ips4_IPSSessionFront': 'f2b9db91793e084cf2003a07c563e6aa',
+    'ips4_member_id': '4029711',
+    'ips4_login_key': '41b6a70b16cce2fd39482f5b21a9c35f',
+    }
+
+async def search_series(client,id,season,episode,showname):
+    showname = showname.replace(" ", "%20").replace("–", "+").replace("—","+")
+    response = await client.get(f"https://ddlstreamitaly.co/search/?&q={showname}%20{season}%20Streaming&type=videobox_video&quick=1&nodes=11&search_and_or=and&search_in=titles&sortby=relevancy")
+    soup = BeautifulSoup(response.text, 'lxml',parse_only=SoupStrainer('a'))
+    a_tags = soup.find_all('a', {'data-linktype': 'link'})
+    for a in a_tags:
+        href = a['href']
+        response = await client.get(href, cookies = cookies)
+        soup = BeautifulSoup(response.text, 'lxml')
+        movie_ids = soup.find_all('a',{'rel':'external nofollow'})
+        for database in movie_ids:
+            link = database['href']
+            real_id = link.split('/')[4]
+            if real_id == id:
+                meta_description = soup.find('meta',{'name':'description'})
+                content = meta_description['content']
+                if f"Stagione {season}" in content:
+                    return href
+                else:
+                    continue
+            else:
+                continue
+
+async def get_episode(client,link,episode):
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        # 'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Referer': link,
+        'DNT': '1',
+        'Sec-GPC': '1',
+        'Upgrade-Insecure-Requests': '1',
+        'Sec-Fetch-Dest': 'document',
+        'Sec-Fetch-Mode': 'navigate',
+        'Sec-Fetch-Site': 'same-origin',
+        'Sec-Fetch-User': '?1',
+        'Connection': 'keep-alive',
+    #   'Cookie': 'ips4_device_key=b6f084be79c28bb53ecfc556fd7a2a70; ips4_IPSSessionFront=f2b9db91793e084cf2003a07c563e6aa; ips4_ipsTimezone=Europe/Rome; ips4_hasJS=true; ips4_noCache=1; ips4_announcement_3=true; ips4_member_id=4029711; ips4_login_key=41b6a70b16cce2fd39482f5b21a9c35f; ips4_loggedIn=1725985598',
+        'Priority': 'u=1',
+        'Pragma': 'no-cache',
+        'Cache-Control': 'no-cache',
+    }
+    params = {
+        'area': 'online',
+    }
+
+
+
+    episode = "6"
+    response = await client.get(link, cookies = cookies, headers = headers, params = params, impersonate="chrome120")
+    print(link)
+
+    pattern = rf'<a\s+href="([^"]+)"[^>]*>\s*Part {episode}\s*</a>'
+    match = re.search(pattern, response.text)
+    mp4_link = match.group(1)
+    mp4_link = mp4_link.replace("&amp","")
+    mp4_link = mp4_link.replace(";","&")
+    return mp4_link
+
+async def search_movie(client,showname,id):
+    showname = showname.replace(" ", "%20").replace("–", "+").replace("—","+")
+    showname = urllib.parse.quote_plus(showname)
+    link = f"https://ddlstreamitaly.co/search/?&q={showname}%20Streaming&quick=1&nodes=11&search_and_or=and&search_in=titles&sortby=relevancy"
+    response = await client.get(link,impersonate = "chrome120")
+    soup = BeautifulSoup(response.text, 'lxml',parse_only=SoupStrainer('a'))
+    a_tags = soup.find_all('a', {'data-linktype': 'link'})
+    for a in a_tags:
+        href = a['href']
+        response = requests.get(href, cookies = cookies)
+        soup = BeautifulSoup(response.text, 'lxml', parse_only=SoupStrainer('a'))
+        movie_ids = soup.find_all('a',{'rel':'external nofollow'})
+        for database in movie_ids:
+            link = database['href']
+            real_id = link.split('/')[4]
+            if real_id == id:
+                return href
+            else:
+                continue
+    return
+
+
+
+async def get_mp4(client,link):
+    response = await client.get(link, cookies = cookies)   
+    soup = BeautifulSoup(response.text,'lxml',parse_only=SoupStrainer('source'))
+    source_tag = soup.find('source')
+    final_url = source_tag['src']
+    res = source_tag.get('res')
+    return final_url,res
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async def ddlstream(imdb,client):
+    try:
+        general = is_movie(imdb)
+        ismovie = general[0]
+        id = general[1]
+        type = "DDLStream"
+        if "tt" in imdb:
+                showname = await get_info_imdb(id,ismovie,type,client)
+                print(showname)
+        else:
+            showname = get_info_tmdb(id,ismovie,type)
+        if ismovie == 0:
+            season  = general[2]
+            episode = general[3]
+            page_link = await search_series(client,id,season,episode,showname)
+            mp4_link = await get_episode(client,page_link,episode)
+            final_url = await get_mp4(client,mp4_link)
+            print(final_url)
+            return final_url
+        else:
+             page_link = await search_movie(client,showname,id)
+             mp4_link = page_link + "?area=online"
+             final_url = await get_mp4(client,mp4_link)
+             print(final_url) 
+             return final_url
+            
+    except Exception as e:
+        print(f"MammaMia: DDLStream Failed {e}")
+        return None,None
+    
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        test_id = "tt6263850"  # This is an example ID format
+        results = await ddlstream(test_id, client)
+        print(results)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+
+
+    #python3 -m Src.API.ddlstream
+'''

Src/API/epg.py

@@ -0,0 +1,222 @@
+from bs4 import BeautifulSoup
+
+tivu = {
+    "dazn-zona-a": "801",
+}
+"""
+    "rai-1": "3401",
+    "rai-2": "3402",
+    "rai-3": "3403",
+    "rete-4": "123",
+    "canale-5": "122",
+    "italia-1": "121",
+    "la7": "79",
+    "tv8": "7260",
+    "nove": "4323",
+    "rai-4": "3405",
+    "rai-movie": "3406",
+    "rai-premium": "8522",
+    "mediaset-extra": "129",
+    "cielo": "4120",
+    "rai-sport": "17714",
+    "rai-news": "17711",
+    "dmax": "15202",
+    "real-time": "15201",
+    "focus": "134",
+    "giallo": "4322",
+    "topcrime": "132",
+    "boing": "126",
+    "cartoonito": "133",
+    "k2": "15204",
+    "foodnetwork": "15203",
+    "hgtv": "4334",
+    "solocalcio": "4996" ,
+    "euronews": "2017",
+    "rai-4k": "3407",
+"""
+convert_bho_1 = {
+    "euronews": "PlutoEuronews.it",
+    "cartoonito": "cartoonito",
+    "sky-tg-24": "skytg24",
+    "frisbee": "frisbee",
+    "hgtv": "hgtv",
+    "k2": "k2",
+    "supertennis": "supertennis",
+    "solocalcio": "sportitaliasolocalcio",
+    "sportitalia": "sportitalia",
+    "sportitalia24": "RakutenSportItalia.it",
+    "rsi-la-2": "rsila2",
+    "baby-shark-tv": "RakutenBabySharkTv.it",
+    "adrenaline-movies": "RakutenFullMoon.it",
+    "adrenaline-movies": "RakutenBizzarroMovies.it",
+    "cinema-italiano": "RakutenCinemaItalianoRakutenTv.it",
+    "le-vite-degli-altri": "RakutenLeViteDegliAltri.it",
+    "dark-matter": "RakutenDarkMatterItNew.it",
+    "cine-western": "RakutenWesternEPeplum.it",
+    "serie-crime": "RakutenCrimeSeriesItRakutenTv.it",
+    "filmrise-sci-fi": "RakutenFuelTvNew.it",
+    "doctor-who": "RakutenBbcDoctorWho.it",
+    "bbc-drama": "RakutenBbcDrama.it",
+    "documentari": "RakutenDocumentaries.it",
+    "house-of-docs": "RakutenHouseOfDocs.it",
+    "the-asylum": "PlutoTheAsylum.it",
+    "western": "PlutoTvWestern.it",
+    "consulenze-illegali": "PlutoConsulenzeIllegaliItPlus.it"
+    
+}
+
+
+convert_bho_2 = {
+    "rai-1": "Rai%201",
+    "rai-2": "Rai 2",
+    "rai-3": "Rai 3",
+    "rai-4": "Rai 4",
+    "rai-premium": "Rai Premium",
+    "rai-movie": "Rai Movie",
+    "rai-sport": "Rai Sport",
+    "rete-4": "Rete 4",
+    "canale-5": "Canale 5",
+    "italia-1": "Italia 1",
+    "topcrime": "Top Crime",
+    "mediaset-extra": "Mediaset Extra",
+    "focus": "Focus",
+    "boing": "Boing",
+    "history": "History",
+    "comedy-central": "Comedy Central",
+    "tv8": "TV 8",
+    "cielo": "Cielo",
+    "sky-cinema-action": "Sky Cinema Action",
+    "sky-arte": "Sky Arte FHD",
+    "sky-atlantic": "Sky Atlantic",
+    "sky-cinema-collection": "Sky Cinema Collection",
+    "sky-cinema-comedy": "Sky Cinema Comedy",
+    "sky-cinema-drama": "Sky Cinema Drama",
+    "sky-cinema-due": "Sky Cinema Due",
+    "sky-cinema-family": "Sky Cinema Family",
+    "sky-cinema-romance": "Sky Cinema Romance",
+    "sky-cinema-suspence": "Sky Cinema Suspence",
+    "sky-cinema-uno": "Sky Cinema Uno",
+    "sky-uno": "Sky Uno",
+    "sky-sport-24": "Sky Sport",
+    "sky-sport-uno": "Sky Sport Uno",
+    "sky-sport-f1": "Sky Sport F1",
+    "sky-sport-motogp": "Sky Sport MotoGP",
+    "sky-sport-arena": "Sky Sport Arena",
+    "sky-sport-nba": "Sky Sport NBA",
+    "eurosport-1": "Eurosport 1",
+    "eurosport-2": "Eurosport 2",
+    "dmax": "Dmax",
+    "foodnetwork": "Food Network",
+    "giallo": "Giallo",
+    "nove": "Nove",
+    "realtime": "Real Time",
+}
+convert_bho_3 = {
+    "la7": "La7",
+    "rai-news": "Rai News DTT",
+    "sky-crime": "Sky CrimeInvestigation",
+    "sky-documentaries": "Sky Documentaries HD",
+    "sky-investigation": "Sky Investigation HD",
+    "sky-nature": "Sky Nature HD",
+    "sky-serie": "Sky Serie HD",
+    "sky-sport-golf": "Sky Sport Golf",
+    "sky-sport-251": "Sky Sport 251 HD",
+    "sky-sport-252": "Sky Sport 252 HD",
+    "sky-sport-253": "Sky Sport 253 HD",
+    "sky-sport-254": "Sky Sport 254 HD",
+    "sky-sport-255": "Sky Sport 255 HD",
+    "sky-sport-256": "Sky Sport 256 HD",
+    "sky-sport-257": "Sky Sport 257 HD",
+    "sky-sport-258": "Sky Sport 258 HD",
+    "sky-sport-259": "Sky Sport 259 HD",
+    "sky-sport-260": "Sky Sport 260 HD",
+    "sky-sport-261": "Sky Sport 261 HD",
+    "sky-sport-max": "Sky Sport Max",
+    "sky-sport-calcio": "Sky Sport Calcio HD",
+    "sky-sport-tennis": "Sky Sport Tennis HD",
+}
+
+
+async def tivu_get(id,client):
+    try:
+        ik = tivu[id]
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0',
+            'Accept': '*/*',
+            'Accept-Language': 'en-US,en;q=0.5',
+            # 'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            'X-Requested-With': 'XMLHttpRequest',
+            'Origin': 'https://www.tivu.tv',
+            'DNT': '1',
+            'Sec-GPC': '1',
+            'Connection': 'keep-alive',
+            'Referer': 'https://www.tivu.tv/schedasat-rai1.html',
+            # 'Cookie': 'ASP.NET_SessionId=p2fk5silp5mjgtx0j5chjrh3',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Pragma': 'no-cache',
+            'Cache-Control': 'no-cache',
+        }
+        data = {
+            'ik': ik
+        }
+
+        response = await client.post('https://www.tivu.tv/getPrograms.ashx', headers=headers, data=data)
+        soup = BeautifulSoup(response.text,'lxml')
+        tr_element = soup.find('tr', class_='in_onda')
+        hour_range = tr_element.find_all('td')[0].text.strip()
+        program_name = tr_element.find_all('td')[1].text.strip()
+        description = hour_range + " " + program_name
+        return description
+    except Exception as e:
+        print(e)
+        description = f'Watch {id}'
+        return description
+
+
+
+async def epg_guide(id,client):
+    try:
+        if id in convert_bho_1:
+            new_id = convert_bho_1[id]
+            new_id = new_id.replace(" ","%20")
+            response = await client.get(f"https://lorempizza-boh.hf.space/{new_id}/now")
+        elif id in convert_bho_2:
+            new_id = convert_bho_2[id]
+            new_id = new_id.replace(" ","%20")
+            response = await client.get(f"https://mammamia-urlo-boh2.hf.space/{new_id}/now")
+        elif id in convert_bho_3:
+            new_id = convert_bho_3[id]
+            new_id = new_id.replace(" ","%20")
+            response =  await client.get(f"https://mammamia-urlo-boh3.hf.space/{new_id}/now")
+        data = response.json()
+        description = data['description'].replace("- EPG by epg-guide.com","").replace("No description","")
+        title = data['title']
+        print("MammaMia: EPG FOUND")
+        return description,title   
+    except Exception as e:
+        print(e)
+        description = f'Watch {id}'
+        title = ""
+        return description,title
+
+
+
+
+#async def test_animeworld():
+    async with httpx.AsyncClient() as client:
+        test_id = "rai-news"  # Replace with actual ID
+        try:
+            results = await epg_guide(test_id, client)
+            print(results)
+        except httpx.HTTPStatusError as e:
+            print(f"HTTP error occurred: {e}")
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+#if __name__ == "__main__":
+    import httpx
+    import asyncio
+    asyncio.run(test_animeworld())

Src/API/filmpertutti.py

@@ -0,0 +1,183 @@
+
+from tmdbv3api import TMDb, Movie, TV
+from bs4 import BeautifulSoup,SoupStrainer
+import string
+import re
+import dateparser
+from Src.Utilities.convert import get_TMDb_id_from_IMDb_id
+from Src.Utilities.info import get_info_tmdb, is_movie, get_info_imdb
+from Src.Utilities.convert_date import convert_US_date
+import Src.Utilities.config as config
+FT_DOMAIN = config.FT_DOMAIN
+import urllib.parse
+WOA = 0
+#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,season,ismovie):
+    response = await client.get(query)
+    response = response.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, allow_redirects=True, timeout = 30)
+        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
+                release_date = date_string[-4:]
+            if WOA:
+                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
+            if ismovie == 0:
+                Seasons = series_soup.find_all('span', class_="season-name")
+                i = 0
+                for item in Seasons:
+                    season_text = item.text.strip()
+                    if season in season_text and "SUB" not in season_text:
+                        actual_season = i
+                        return url, tid, actual_season
+                    else:
+                        i = i + 1 
+                        continue
+            else:        
+                actual_season = None
+                return url, tid, actual_season 
+        else:
+            print("")
+
+def get_episode_link(actual_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={actual_season}&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, allow_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, allow_redirects=True, timeout = 30)
+    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, allow_redirects=True,timeout = 30)
+    [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 = 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
+            showname,date = await get_info_imdb(imdb_id,ismovie,type, client)
+            season = None
+
+    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("—","+")
+    showname = urllib.parse.quote_plus(showname)
+    #Build the query
+    query = f'https://filmpertutti.{FT_DOMAIN}/wp-json/wp/v2/posts?search={showname}&page=1&_fields=link,id'
+    try:
+        url,tid,actual_season = await search(query,date,client,season,ismovie)
+    except:
+        print("MammaMia: No results found for Filmpertutti")
+        return None
+    if ismovie == 0:
+        episode_link =  get_episode_link(actual_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)
+        return streaming_link
+    
+
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "tt4655480:1:1"  # This is an example ID format
+        results = await filmpertutti(test_id, client)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+
+
+'''
+
+
+
+
+
+
+'''
+    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")
+'''

Src/API/lordchannel.py

@@ -0,0 +1,113 @@
+from tmdbv3api import TMDb, Movie, TV
+from bs4 import BeautifulSoup,SoupStrainer
+from Src.Utilities.convert import get_TMDb_id_from_IMDb_id
+from Src.Utilities.info import get_info_tmdb, is_movie, get_info_imdb
+import Src.Utilities.config as 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, allow_redirects=True, impersonate = "chrome120")
+    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, allow_redirects=True, impersonate = "chrome120")
+            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}')
+                        #Index start from 0 so I need to subtract 1
+
+                         episode_find = div.select('tr')[episode]
+     # index is 2 because we want the correct  element
+                         video_url = episode_find.find('a').get('href')
+                         return video_url,quality
+                else:
+                    print("")
+                    continue
+
+async def get_m3u8(video_url,client):
+    response = await client.get(video_url, allow_redirects=True, impersonate = "chrome120")
+    pattern = r'const\s+videoData\s*=\s*\[(.*?)\];'
+    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("MammaMia: Found results for LordChannel")
+        return url,quality
+    except Exception as e:
+        print("MammaMia: Lordchannel Failed",e)
+        return None,None
+    
+
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        results = await lordchannel("tt0920489:3:2",client)
+        print(results)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())  
+'''

Src/API/okru.py

@@ -0,0 +1,23 @@
+from bs4 import BeautifulSoup
+import json
+from Src.Utilities.dictionaries import okru
+
+
+
+async def okru_get_url(id,client):
+    try:
+        embed_link = okru[id]
+        print(embed_link)
+        response = await client.get(embed_link, allow_redirects=True, impersonate = "chrome120")
+        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("MammaMia: Found results for Okru")
+        print(m3u8_link)
+        return m3u8_link
+    except Exception as e:
+        print("MammaMia: No results found for Okru")
+        return None

Src/API/streamingcommunity.py

@@ -0,0 +1,264 @@
+from bs4 import BeautifulSoup
+from Src.Utilities.convert import get_TMDb_id_from_IMDb_id
+from Src.Utilities.info import get_info_tmdb, is_movie, get_info_imdb
+import Src.Utilities.config as config
+import json
+import random
+import re
+from urllib.parse import urlparse, parse_qs
+from fake_headers import Headers  
+from Src.Utilities.loadenv import load_env  
+import urllib.parse
+
+env_vars = load_env()
+#Get domain
+SC_DOMAIN = config.SC_DOMAIN
+Public_Instance = config.Public_Instance
+Alternative_Link = env_vars.get('ALTERNATIVE_LINK')
+
+headers = Headers()
+#GET VERSION OF STREAMING COMMUNITY:
+async def get_version(client):
+    #Extract the version from the main page of the site
+
+
+    try:
+        random_headers = headers.generate()
+        random_headers['Referer'] = f"https://streamingcommunity.{SC_DOMAIN}/"
+        random_headers['Origin'] = f"https://streamingcommunity.{SC_DOMAIN}"
+        base_url = f'https://streamingcommunity.{SC_DOMAIN}/richiedi-un-titolo' 
+        response = await client.get(base_url, headers=random_headers, allow_redirects = True, impersonate="chrome120")
+        #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 Exception as e:
+        print("Couldn't find the version",e)
+        version = "65e52dcf34d64173542cd2dc6b8bb75b"
+        return version
+
+async def search(query,date,ismovie, client,SC_FAST_SEARCH):
+    random_headers = headers.generate()
+    random_headers['Referer'] = "https://streamingcommunity.buzz/"
+    random_headers['Origin'] = "https://streamingcommunity.buzz"
+    random_headers['Accept'] = 'application/json'  # Assuming the API returns JSON
+    random_headers['Content-Type'] = 'application/json'
+    #Do a request to get the ID of serie/move and it's slug in the URL
+    response = await client.get(query, headers = random_headers, allow_redirects=True)
+    print(response)
+    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":
+                random_headers = headers.generate()
+                random_headers['Referer'] = "https://streamingcommunity.buzz/"
+                random_headers['Origin'] = "https://streamingcommunity.buzz"
+                response = await client.get ( f'https://streamingcommunity.{SC_DOMAIN}/titles/{tid}-{slug}', headers = random_headers, allow_redirects=True,impersonate = "chrome120")
+                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 SC_FAST_SEARCH == "1":
+                 return tid,slug
+        else:
+            print("Couldn't find anything")
+
+        
+async def get_film(tid,version,client):  
+    random_headers = headers.generate()
+    random_headers['Referer'] = "https://streamingcommunity.buzz/"
+    random_headers['Origin'] = "https://streamingcommunity.buzz"
+    random_headers['x-inertia'] = "true"
+    random_headers['x-inertia-version'] = version
+    #Access the iframe
+    url = f'https://streamingcommunity.{SC_DOMAIN}/iframe/{tid}'
+    response = await client.get(url, headers=random_headers, allow_redirects=True,impersonate = "chrome120")
+    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)
+    random_headers = headers.generate()
+    random_headers['Referer'] = "https://streamingcommunity.buzz/"
+    random_headers['Origin'] = "https://streamingcommunity.buzz"
+    random_headers['x-inertia'] = "true"
+    random_headers['x-inertia-version'] = version
+    #Get real token and expires by looking at the page in the iframe, vixcloud/embed
+    resp = await client.get(iframe, headers = random_headers, allow_redirects=True,impersonate= "chrome120")
+    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}.m3u8?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}.m3u8'
+    return url,url720,quality,
+
+async def get_season_episode_id(tid,slug,season,episode,version,client):
+    random_headers = headers.generate()
+    random_headers['Referer'] = "https://streamingcommunity.buzz/"
+    random_headers['Origin'] = "https://streamingcommunity.buzz"
+    random_headers['x-inertia'] = "true"
+    random_headers['x-inertia-version'] = version
+    #Set some basic headers for the request  
+      #Get episode ID 
+    response = await client.get(f'https://streamingcommunity.{SC_DOMAIN}/titles/{tid}-{slug}/stagione-{season}', headers=random_headers, allow_redirects=True, impersonate = "chrome120")
+    # 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
+    random_headers = headers.generate()
+    random_headers['Referer'] = "https://streamingcommunity.buzz/"
+    random_headers['Origin'] = "https://streamingcommunity.buzz"
+    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, headers = random_headers, allow_redirects=True, impersonate = "chrome120")
+
+    # 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]
+    random_headers = headers.generate()
+    random_headers['Referer'] = "https://streamingcommunity.buzz/"
+    random_headers['Origin'] = "https://streamingcommunity.buzz"
+    random_headers['x-inertia'] = "true"
+    random_headers['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 = random_headers, allow_redirects=True, impersonate = "chrome120")
+    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}.m3u8?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}.m3u8'
+    return url,url720,quality
+
+
+async def streaming_community(imdb,client,SC_FAST_SEARCH):
+    try:
+        if Public_Instance == "1":
+            Weird_Link = json.loads(Alternative_Link)
+            link_post = random.choice(Weird_Link)
+            response = await client.get(f"{link_post}fetch-data/{SC_FAST_SEARCH}/{SC_DOMAIN}/{imdb}")
+            url_streaming_community = response.headers.get('x-url-streaming-community')
+            url_720_streaming_community = response.headers.get('x-url-720-streaming-community')
+            quality_sc = response.headers.get('x-quality-sc')
+            print(quality_sc,url_streaming_community)
+            return url_streaming_community,url_720_streaming_community,quality_sc
+        general = is_movie(imdb)
+        ismovie = general[0]
+        imdb_id = general[1]
+        if ismovie == 0 : 
+            season = int(general[2])
+            episode = int(general[3])
+            #Check if fast search is enabled or disabled
+            if SC_FAST_SEARCH == "1":
+                type = "StreamingCommunityFS"
+                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":
+                type = "StreamingCommunity"
+                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 SC_FAST_SEARCH == "1":
+                type = "StreamingCommunityFS"
+                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) 
+            elif SC_FAST_SEARCH == "0":
+                type = "StreamingCommunity"
+                if "tt" in imdb:
+                    #Get showname
+                    showname,date = await get_info_imdb(imdb_id,ismovie,type,client)
+                else:
+                        tmdba = imdb_id.replace("tmdb:","")
+                        showname,date = get_info_tmdb(tmdba,ismovie,type) 
+        
+        showname = showname.replace(" ", "+").replace("–", "+").replace("—","+")
+        showname = urllib.parse.quote_plus(showname)
+        query = f'https://streamingcommunity.{SC_DOMAIN}/api/search?q={showname}'
+        version = await get_version(client)
+        tid,slug = await search(query,date,ismovie,client,SC_FAST_SEARCH)
+        if ismovie == 1:
+            #TID means temporaly ID
+            url,url720,quality = await get_film(tid,version,client)
+            print("MammaMia found results for StreamingCommunity")
+            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("MammaMia found results for StreamingCommunity")
+            return url,url720,quality
+    except Exception as e:
+        print("MammaMia: StreamingCommunity failed",e)
+        return None,None,None
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "tt12930350"  # This is an example ID format
+        results = await streaming_community(test_id, client,"0")
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+'''

Src/API/streamingwatch.py

@@ -0,0 +1,120 @@
+from bs4 import BeautifulSoup,SoupStrainer 
+from Src.Utilities.convert import get_TMDb_id_from_IMDb_id
+from Src.Utilities.info import get_info_tmdb, is_movie, get_info_imdb
+import Src.Utilities.config as config
+import re
+import json
+import urllib.parse
+SW_DOMAIN = config.SW_DOMAIN
+async def wponce_get(client):
+    response = await client.get(f"https://www.streamingwatch.{SW_DOMAIN}/contatto/")
+    pattern = r'"admin_ajax_nonce":"(\w+)"'
+    matches = re.findall(pattern, response.text)
+    wponce = matches[1]
+    return wponce
+
+async def search(showname,season,episode,date,ismovie,client):
+    if ismovie == 1:
+        wponce = await wponce_get(client)
+        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': wponce,
+        }
+        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, allow_redirects=True, impersonate = "chrome120")
+           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', allow_redirects=True, impersonate = "chrome120")
+        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, allow_redirects=True, impersonate = "chrome120")
+        data_json = response.text
+        data = json.loads(data_json)
+        for entry in data:
+            if f"stagione-{season}-episodio-{episode}" in entry["slug"] and f"stagione-{season}-episodio-{episode}0" not 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, allow_redirects=True, impersonate = "chrome120")
+    match = re.search(r'sources:\s*\[\s*\{\s*file\s*:\s*"([^"]*)"', response.text)
+    url = match.group(1)
+    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)
+       print(f"MammaMia: StreamingWatch found results for {showname}")
+       return url
+    except Exception as e:
+          print("MammaMia: StreamingWatch Failed",e)
+          return None
+    
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "tt16426418"  # This is an example ID format
+        results = await streamingwatch(test_id, client)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+'''

Src/API/tantifilm.py

@@ -0,0 +1,288 @@
+from bs4 import BeautifulSoup,SoupStrainer
+import re
+import time
+from Src.Utilities.info import is_movie,get_info_imdb,get_info_tmdb
+import Src.Utilities.config as config
+from Src.Utilities.loadenv import load_env
+HF = config.HF
+env_vars = load_env()
+PROXY_CREDENTIALS = env_vars.get('PROXY_CREDENTIALS')
+TF_DOMAIN = config.TF_DOMAIN
+import urllib.parse
+async def search(showname,ismovie,date,client):
+    showname = showname.replace(" ","%20")
+    showname = urllib.parse.quote_plus(showname)
+    url = f'https://www.tanti.bond/ajax/posts?q={showname}'
+    response =  await client.post(url, allow_redirects=True, impersonate = "chrome120")
+    response = response.json()['data']
+    if ismovie == 1:
+        for link in response:
+            url = link['url']
+            response = client.get(url, allow_redirects=True, impersonate = "chrome120")
+            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: 
+        for link in response:
+            base_url = link['url']
+            url = f'{base_url}-1-season-1-episode'
+            response = await client.get(url, allow_redirects=True, impersonate = "chrome120")
+            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):
+    showname = showname.replace(" ","%20")
+    url = f'https://www.tanti.{TF_DOMAIN}/search/{showname}'
+    response = await client.get(url, allow_redirects=True, impersonate = "chrome120")
+    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, allow_redirects=True, impersonate = "chrome120")
+        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}", allow_redirects=True, impersonate = "chrome120")
+        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, allow_redirects=True, impersonate = "chrome120")
+            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, allow_redirects=True, impersonate = "chrome120")
+            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, allow_redirects=True, impersonate = "chrome120")
+                    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, allow_redirects=True, impersonate = "chrome120")
+    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, allow_redirects=True, impersonate = "chrome120")
+        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, allow_redirects=True, impersonate = "chrome120")
+        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, allow_redirects=True, impersonate = "chrome120")
+        soup = BeautifulSoup(response.text, "lxml", parse_only=SoupStrainer('iframe'))
+        protect_link = soup.iframe['src'] 
+        return  protect_link
+
+
+async def true_url(protect_link,client):
+    # Define headers
+    headers = {
+        "Range": "bytes=0-",
+        "Referer": "https://d000d.com/",
+    }
+    if HF == "1":
+        import random
+        import json
+        proxy_list = json.loads(PROXY_CREDENTIALS)
+        proxy = random.choice(proxy_list)
+        proxies = {
+            "http": proxy,
+            "https": proxy
+        }
+        response = await client.get(protect_link, proxies=proxies, allow_redirects=True, impersonate = "chrome120")
+    else:
+        response = await client.get(protect_link, allow_redirects=True, impersonate = "chrome120")
+ 
+    
+    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]}'
+            if "HF" == "1" :
+                rebobo = await client.get(url, headers=headers, allow_redirects=True, impersonate = "chrome120",proxies= proxies)
+            else:
+                rebobo = await client.get(url, headers=headers, allow_redirects=True, impersonate = "chrome120")
+            real_url = f'{rebobo.text}123456789{match[2]}{real_time}'
+            print("MammaMia: Found results for Tantifilm")
+            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,TF_FAST_SEARCH):
+    urls = None
+    try:
+        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:
+                if TF_FAST_SEARCH == "0":
+                    type = "Tantifilm"
+                    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":
+                    type = "TantifilmFS"
+                    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":
+                        type = "Tantifilm" 
+                        showname,date = get_info_tmdb(tmdba,ismovie,type)
+                        url,embed_id = await search(showname,ismovie,date,client)
+                    elif TF_FAST_SEARCH == "1":
+                        type = "TantifilmFS"
+                        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":
+                        type = "Tantifilm"
+                        showname,date = await get_info_imdb(imdb_id,ismovie,type,client)
+                        tid,url = await search(showname,ismovie,date,client)
+                    elif TF_FAST_SEARCH == "1":
+                        type = "TantifilmFS"
+                        showname = await get_info_imdb(imdb_id,ismovie,type,client)
+                        date = None
+                        tid,url = await fast_search(showname,ismovie,client)
+            else:
+                if TF_FAST_SEARCH == "0":
+                    type = "Tantifilm"
+                    showname,date = get_info_tmdb(imdb,ismovie,type)
+                    tid,url = await search(showname,ismovie,date,client)
+                elif TF_FAST_SEARCH == "1":
+                    type = "TantifilmFS"
+                    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 
+    
+
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "tt6468322:1:1"  # This is an example ID format
+        results = await tantifilm(test_id, client,"0")
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+
+'''
+

Src/API/webru.py

@@ -0,0 +1,106 @@
+import random
+from bs4 import BeautifulSoup,SoupStrainer
+import Src.Utilities.config as config
+from Src.Utilities.dictionaries import webru_vary,webru_dlhd,skystreaming
+from Src.Utilities.loadenv import load_env
+env_vars = load_env()
+MEDIAFLOW_PASS = env_vars.get('MEDIAFLOW_PASS')
+Referer = "https://ilovetoplay.xyz/"
+Origin = "https://ilovetoplay.xyz"
+key_url = "https%3A%2F%2Fkey2.keylocking.ru%2F"  
+headers = {
+    "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0",
+    "Accept": "*/*",
+    "Accept-Language": "en-US,en;q=0.5",
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Origin": Origin,
+    "DNT": "1",
+    "Sec-GPC": "1",
+    "Connection": "keep-alive",
+    "Referer": Referer,
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "cross-site",
+    "Pragma": "no-cache",
+    "Cache-Control": "no-cache",
+}
+
+medialink = config.MediaProxy
+async def get_stream_link(id,site,client):
+    try:
+        if site == "dlhd":
+            stream_url = "https://xyzdddd.mizhls.ru/lb/" + webru_dlhd[id] + "/index.m3u8"
+        elif site == "vary":
+            stream_url = "https://webuit.mizhls.ru/lb/"+ webru_vary[id] + "/index.m3u8"
+        return stream_url,Referer,Origin
+    except Exception as e:
+        return None
+async def webru(id,site,client):
+    try:
+        stream_url, Referer,Origin = await get_stream_link(id,site,client)
+        mediaproxy = config.MediaProxy
+        medialink = random.choice(mediaproxy)
+        new_stream_url = f'{medialink}proxy/hls/manifest.m3u8?api_password={MEDIAFLOW_PASS}&d={stream_url}&h_Referer={Referer}&h_Origin={Origin}&h_User-Agent=Mozilla%2F5.0%20(Windows%20NT%2010.0%3B%20Win64%3B%20x64)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F58.0.3029.110%20Safari%2F537.3'
+        return new_stream_url
+    except Exception as e:
+        print("WebRu failed",e)
+        return None
+    
+
+
+async def get_skystreaming(id,client):
+    try:
+        skystreaming_link =  skystreaming[id]
+        m3u8_urls = {}
+        if type(skystreaming_link) == list:
+            
+            for link in skystreaming_link:
+                m3u8_url,Host = await get_skystreaming_url(link,client)
+                m3u8_urls[m3u8_url] = Host
+                print(m3u8_urls)
+        else:
+            m3u8_url,Host = await get_skystreaming_url(skystreaming_link,client)
+            m3u8_urls[m3u8_url] = Host
+        return m3u8_urls
+
+    except Exception as e:
+        print("SkyStreaming failed",e)
+        return None,None 
+                    
+    
+
+
+
+async def get_skystreaming_url(skystreaming_link,client):
+    try:
+        if "hls" in skystreaming_link:
+            m3u8_url = skystreaming_link
+            Host = m3u8_url.replace("https://","").split("/")[0]
+            return m3u8_url,Host
+        response =  await client.get(skystreaming_link, headers=headers, allow_redirects=True, impersonate = "chrome120")
+        soup = BeautifulSoup(response.text, 'lxml', parse_only=SoupStrainer('source'))
+        source_tag = soup.find('source')
+        m3u8_url = source_tag.get('src')
+        Host = m3u8_url.replace("https://","").split("/")[0]
+        print(Host)
+        return m3u8_url,Host
+    except Exception as e: 
+        print("SkyStreaming failed",e)
+        return None,None
+    
+
+
+
+
+    '''
+    async def webru(id,site,client):
+    try:
+        stream_url, Referer,Origin = await get_stream_link(id,site,client)
+        mediaproxy = config.MediaProxy
+        medialink = random.choice(mediaproxy)
+        new_stream_url = f'{medialink}proxy/hls/manifest.m3u8?api_password={MEDIAFLOW_PASS}&d={stream_url}&h_Referer={Referer}&h_Origin={Origin}&h_User-Agent=Mozilla%2F5.0%20(Windows%20NT%2010.0%3B%20Win64%3B%20x64)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F58.0.3029.110%20Safari%2F537.3'
+        return new_stream_url
+    except Exception as e:
+        print("WebRu failed",e)
+        return None
+    '''

Src/API/whvx.py

@@ -0,0 +1,126 @@
+from Src.Utilities.info import is_movie,get_info_imdb,get_info_tmdb
+import json
+import urllib.parse
+
+headers = {
+    'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0',
+    'Accept': '*/*',
+    'Accept-Language': 'en-US,en;q=0.5',
+    # 'Accept-Encoding': 'gzip, deflate, br, zstd',
+    'Origin': 'https://www.vidbinge.com',
+    'DNT': '1',
+    'Sec-GPC': '1',
+    'Sec-Fetch-Dest': 'empty',
+    'Sec-Fetch-Mode': 'cors',
+    'Sec-Fetch-Site': 'cross-site',
+    'Connection': 'keep-alive',
+    'Priority': 'u=4',
+    'Pragma': 'no-cache',
+    'Cache-Control': 'no-cache',
+    # Requests doesn't support trailers
+    # 'TE': 'trailers',
+}
+
+
+
+
+
+
+
+
+
+async def whvx(id,client):
+    general = is_movie(id)
+    ismovie = general[0]
+    imdb_id = general[1]
+   
+    type = "Whvx"    
+    if ismovie == 0:
+        ismovie2 = "tv"
+        season = general[2]
+        episode = general[3]
+    elif ismovie == 1:
+        ismovie2 = "movie"
+        season = ""
+        episode = ""
+    if "tt" in id:
+        showname,date = await get_info_imdb(imdb_id,ismovie,type,client)
+   
+        params = {
+            "query": {
+                "title": showname,
+                "releaseYear": date,
+                "imdbId": imdb_id,
+                "type": ismovie2,
+                "season": season,
+                "episode": episode
+            },
+            "provider": "nova"
+        }
+
+
+        
+    elif "tmdb" in id:
+        showname,date = get_info_tmdb(id,ismovie,type)
+        params = {
+            "query": {
+                "title": showname,
+                "releaseYear": date,
+                "tmdbId": imdb_id,
+                "type": ismovie2,
+                "season": season,
+                "episode": episode
+            },
+            "provider": "nova"
+        }
+    showname = urllib.parse.quote_plus(showname)
+    response = await client.get(f'https://api.whvx.net/search', params = params,  headers=headers, impersonate = "chrome120")
+    data = json.loads(response.text)
+    url = data['url']
+    print(data)
+    params = {
+        'resourceId': url,
+        'provider': 'nova',
+    }
+
+
+    headers2 = {
+        'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0',
+        'Accept': '*/*',
+        'Accept-Language': 'en-US,en;q=0.5',
+        # 'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Origin': 'https://www.vidbinge.com',
+        'DNT': '1',
+        'Sec-GPC': '1',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'cross-site',
+        'Connection': 'keep-alive',
+        'Priority': 'u=4',
+        'Pragma': 'no-cache',
+        'Cache-Control': 'no-cache',
+        # Requests doesn't support trailers
+        # 'TE': 'trailers',
+    }
+    response = await client.get('https://api.whvx.net/source', params=params, headers=headers2, impersonate = "chrome120")
+    data = json.loads(response.text)
+    resolution_links = {}
+    for quality, details in data['stream'][0]['qualities'].items():
+        resolution_links[quality] = details['url']
+    print(resolution_links)
+    return resolution_links
+
+'''
+async def test_animeworld():
+    from curl_cffi.requests import AsyncSession
+    async with AsyncSession() as client:
+        # Replace with actual id, for example 'anime_id:episode' format
+        test_id = "tt6263850"  # This is an example ID format
+        results = await whvx(test_id, client)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test_animeworld())
+
+
+'''

Src/Utilities/config.py

@@ -0,0 +1,28 @@
+#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["Tantifilm"]['domain']
+LC_DOMAIN = SITE["LordChannel"]['domain']
+SW_DOMAIN = SITE["StreamingWatch"]['domain']
+AW_DOMAIN = SITE['AnimeWorld']['domain']
+SKY_DOMAIN = SITE['SkyStreaming']['domain']
+MYSTERIUS = SITE['Mysterius']['enabled']
+DLHD = SITE['DaddyLiveHD']['enabled']
+#General
+GENERAL = config['General']
+dotenv = GENERAL["load_env"]
+HOST = GENERAL["HOST"]
+PORT = GENERAL["PORT"]
+HF = GENERAL["HF"]
+Public_Instance = GENERAL["Public_Instance"]
+MediaProxy = GENERAL["MediaProxy"]
+ForwardProxy = GENERAL["ForwardProxy"]

Src/Utilities/convert.py

@@ -1,15 +1,14 @@
-import requests
+from Src.Utilities.loadenv import load_env
-from tmdbv3api import TMDb, Movie, TV
+env_vars = load_env()
-from loadenv import load_env
+
-TMDB_KEY, _, _, _,_ = load_env()
+TMDB_KEY = env_vars.get('TMDB_KEY')
-def get_TMDb_id_from_IMDb_id(imdb_id):  
+async def get_TMDb_id_from_IMDb_id(imdb_id,client):
-    response = requests.get(f'https://api.themoviedb.org/3/find/{imdb_id}', 
+    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']:
-        print(tmbda['tv_results'][0]['id'])
         return tmbda['tv_results'][0]['id']
     else:
         return None

Src/Utilities/dictionaries.py

@@ -0,0 +1,898 @@
+okru = {
+    "rai-1": "https://ok.ru/videoembed/7868570672752?nochat=1", 
+    "rai-2": "https://ok.ru/videoembed/7805618364016?nochat=1",
+    "canale-5": "https://ok.ru/videoembed/7871149252208?nochat=1",
+    "italia-1": "https://ok.ru/videoembed/7393558339184?nochat=1",
+    "rai-premium": "https://ok.ru/videoembed/7363152715376?nochat=1",
+    "rai-movie": "https://ok.ru/videoembed/7384012693104?nochat=1",
+    "tv8": "https://ok.ru/videoembed/7681651777136?nochat=1",
+    "rsi-la-2": "https://ok.ru/videoembed/7681648107120?nochat=1",
+    "mediaset-extra": "https://ok.ru/videoembed/7363152715376?nochat=1",
+    "mediaset-infinity": "https://ok.ru/videoembed/6323249159792%3Fnochat=1"
+}
+
+STREAM = {
+    "channels": [
+        {
+            "id": "la7",
+            "title": "LA7",
+            "name": "HD/FHD",
+            "genres": ["La7"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/0/02/LA7_-_Logo_2011.svg/1280px-LA7_-_Logo_2011.svg.png",
+            "url": "https://d3749synfikwkv.cloudfront.net/v1/master/3722c60a815c199d9c0ef36c5b73da68a62b09d1/cc-74ylxpgd78bpb/Live.m3u8"
+        },
+        {
+            "id": "rai-1",
+            "title": "Rai 1",
+            "name": "Full HD Http",
+            "genres": ["Rai"],
+            "poster": "https://i.imgur.com/OPV9jJD.png",
+            "url": "http://173.208.52.200/rai1/index.m3u8"
+        },
+        {
+            "id": "rai-2",
+            "title": "Rai 2",
+            "name": "Full HD Http",
+            "genres": ["Rai"],
+            "poster": "https://i.imgur.com/uHtYy8w.png",
+            "url": "http://173.208.52.200/rai2/index.m3u8"
+        },
+        {
+            "id": "rai-3",
+            "title": "Rai 3",
+            "name": "Full HD Http",
+            "genres": ["Rai"],
+            "poster": "https://i.imgur.com/iXst6me.png",
+            "url": "http://173.208.52.200/rai3/index.m3u8"
+        },
+        {
+            "id": "rai-4",
+            "title": "Rai 4",
+            "name": "Full HD Http",
+            "genres": ["Rai"],
+            "poster": "https://i.imgur.com/KGg3hvr.png",
+            "url": "http://173.208.52.200/rai4/index.m3u8"
+        },
+        {
+            "id": "rai-premium",
+            "title": "Rai Premium",
+            "name": "Full HD",
+            "genres": ["Rai"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/rai-premium_c.png",
+            "url": "https://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=746992" 
+        },
+        {
+            "id": "rai-4k",
+            "title": "Rai 4K",
+            "name": "4K",
+            "genres": ["Rai"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/ad/Rai_4K_-_Logo_2016.svg/1920px-Rai_4K_-_Logo_2016.svg.png",
+            "url": "https://raievent10-elem-live.akamaized.net/hls/live/619189/raievent10/raievent10/playlist.m3u8"
+
+        },
+        {
+            "id": "rai-news",
+            "title": "Rai News",
+            "name": "",
+            "genres": ["Rai"],
+            "poster": "https://is1-ssl.mzstatic.com/image/thumb/Purple221/v4/31/05/eb/3105eb24-a953-7bb9-876d-0fcfb0a19055/AppIcon-0-0-1x_U007epad-0-10-0-0-85-220.png/1200x630wa.png",
+            "url": "https://streamcdnb4-8e7439fdb1694c8da3a0fd63e4dda518.msvdn.net/rainews1/hls/playlist_mo.m3u8"
+        },
+        {
+            "id": "rai-movie",
+            "title": "Rai Movie",
+            "name": "",
+            "genres": ["Rai"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/rai-movie_c.png",
+            "url": "https://m3u.iranvids.com/rai-movie/output.m3u8"
+        },
+        {
+            "id": "rai-sport",
+            "title": "Rai Sport",
+            "name": "",
+            "genres": ["Rai"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/rai-sport_c.png",
+            "url": "https://m3u.iranvids.com/rai-sport01/output.m3u8"
+        },
+        {
+            "id": "rete-4",
+            "title": "Rete 4",
+            "name": "Full HD Http",
+            "genres": ["Mediaset"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/5/5f/Rete_4_2018.svg/1024px-Rete_4_2018.svg.png",
+            "url": "http://173.208.52.200/rete4/index.m3u8"
+        },
+        {
+            "id": "euronews",
+            "title": "Euronews",
+            "name": "720p",
+            "genres": ["Euronews"],
+            "poster": "https://yt3.googleusercontent.com/t3slq37NYJRuP2UoEZDoPKyMClKyQULG8-j2DEfzL1XXcBvFpR6z6HD7rtc0wDn8Mqt0OtpU=s900-c-k-c0x00ffffff-no-rj",
+            "url": "https://rakuten-euronews-3-it.samsung.wurl.tv/manifest/playlist.m3u8"
+        },
+        {
+            "id": "canale-5",
+            "title": "Canale 5",
+            "name": "Full HD Http",
+            "genres": ["Mediaset"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/canale-5_c.png",
+            "url": "http://173.208.52.200/canale5/index.m3u8"
+        },
+        {
+            "id": "italia-1",
+            "title": "Italia 1",
+            "name": "Full HD Http",
+            "genres": ["Mediaset"],
+            "poster": "https://upload.wikimedia.org/wikipedia/en/thumb/e/e2/Italia_1.svg/1024px-Italia_1.svg.png",
+            "url": "http://173.208.52.200/italia1/index.m3u8"
+        },
+        {
+            "id": "topcrime",
+            "title": "Top Crime",
+            "name": "HD/FHD",
+            "genres": ["Mediaset"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/top-crime_c.png",
+            "url": "https://live02-seg.msf.cdn.mediaset.net/live/ch-lt/lt-clr.isml/index.m3u8"
+        },
+        {
+            "id": "mediaset-extra",
+            "title": "Mediaset Extra",
+            "name": "HD/FHD",
+            "genres": ["Mediaset"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/mediaset-extra_c.png",
+            "url": "https://live02-seg.msf.cdn.mediaset.net/live/ch-kq/kq-clr.isml/index.m3u8"
+        },
+        {
+            "id": "focus",
+            "title": "Focus",
+            "name": "HD/FHD",
+            "genres": ["Mediaset"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/d/d0/Focus_channel.png",
+            "url": "https://live02-seg.msf.cdn.mediaset.net/live/ch-fu/fu-clr.isml/index.m3u8"
+        },
+        {
+            "id": "boing",
+            "title": "Boing",
+            "name": "HD/FHD",
+            "genres": ["Mediaset"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/8/8c/Logo_Boing.png",
+            "url": "https://live02-seg.msf.cdn.mediaset.net/live/ch-kb/kb-clr.isml/index.m3u8"
+        },
+        {
+            "id": "cartoonito",
+            "title": "Cartoonito",
+            "name": "HD/FHD",
+            "genres": ["Mediaset"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a5/Cartoonito_-_Logo_2021.svg/1920px-Cartoonito_-_Logo_2021.svg.png",
+            "url": "https://live02-seg.msf.cdn.mediaset.net/live/ch-la/la-clr.isml/index.m3u8"
+        },
+        {
+            "id": "history",
+            "title": "History",
+            "name": "",
+            "genres": ["A+E"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/history_c.png"
+        },
+        {
+            "id": "comedy-central",
+            "title": "Comedy Central",
+            "name": "",
+            "genres": ["Paramount"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/comedy-central_c.png"
+        },
+        {
+            "id": "sky-tg-24",
+            "title": "Sky TG24",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://images-na.ssl-images-amazon.com/images/I/512j1jeZaHL.png",
+            "url": "https://hlslive-web-gcdn-skycdn-it.akamaized.net/TACT/12221/web/master.m3u8?hdnts=st=1701861650~exp=1765449000~acl=/*~hmac=84c9f3f71e57b13c3a67afa8b29a8591ea9ed84bf786524399545d94be1ec04d"
+        },
+        {
+            "id": "tv8",
+            "title": "TV8",
+            "name": "SD",
+            "genres": ["Sky"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/9/9a/TV8_logo.png",
+            "url": "https://hlslive-web-gcdn-skycdn-it.akamaized.net/TACT/11223/tv8web/master.m3u8?hdnea=st=1701861650~exp=1765449000~acl=/*~hmac=84c9f3f71e57b13c3a67afa8b29a8591ea9ed84bf786524399545d94be1ec04d"
+        },
+        {
+            "id": "cielo",
+            "title": "Cielo",
+            "name": "SD",
+            "genres": ["Sky"],
+            "poster": "https://static.sky.it/static_clientlibs/skycielo/clientlibs/clientlib-site/resources/images/facebook.jpg",
+            "url": "https://hlslive-web-gcdn-skycdn-it.akamaized.net/TACT/11219/cieloweb/master.m3u8?hdnea=st=1701861650~exp=1765449000~acl=/*~hmac=84c9f3f71e57b13c3a67afa8b29a8591ea9ed84bf786524399545d94be1ec04d"
+        },
+        {
+            "id": "sky-cinema-action",
+            "title": "Sky Cinema Action",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-cinema-action_c.png"
+        },
+        {
+            "id": "sky-arte",
+            "title": "Sky Arte",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.davinciface.com/wp-content/uploads/2022/07/sky_arte_logo-270x270.jpg"
+        },
+        {
+            "id": "sky-atlantic",
+            "title": "Sky Atlantic",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-atlantic_c.png"
+        },
+        {
+            "id": "sky-cinema-collection",
+            "title": "Sky Cinema Collection",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-cinema-collection_c.png"
+        },
+        {
+            "id": "sky-cinema-comedy",
+            "title": "Sky Cinema Comedy",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-cinema-comedy_c.png"
+        },
+        {
+            "id": "sky-cinema-drama",
+            "title": "Sky Cinema Drama",
+            "name": "",
+            "genres": ["Sky"],
+            "poster":"https://i.imgur.com/Z8hr5aR.png"
+        },
+        {
+            "id": "sky-cinema-due",
+            "title": "Sky Cinema Due",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://i.imgur.com/xfbZiXs.png"
+        },
+        {
+            "id": "sky-cinema-family",
+            "title": "Sky Cinema Family",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-cinema-family_c.png"
+        },
+        {
+            "id": "sky-cinema-romance",
+            "title": "Sky Cinema Romance",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-cinema-romance_c.png"
+        },
+        {
+            "id": "sky-cinema-suspence",
+            "title": "Sky Cinema Suspence",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://i.imgur.com/vS97bNg.png"
+        },
+        {
+            "id": "sky-cinema-uno",
+            "title": "Sky Cinema Uno",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-cinema-1_c.png"
+        },
+        {
+            "id": "sky-crime",
+            "title": "Sky Crime",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://i.imgur.com/j2JdQaH.png"
+        },
+        {
+            "id": "sky-documentaries",
+            "title": "Sky Documentaries",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://artworks.thetvdb.com/banners/posters/117551-3.jpg"
+        },
+        {
+            "id": "sky-investigation",
+            "title": "Sky Investigation",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-investigation_c.png"
+        },
+        {
+            "id": "sky-nature",
+            "title": "Sky Nature",
+            "name": "",
+            "genres": ["Sky"],
+            "poster":"https://search.bus-hit.me/image_proxy?url=https%3A%2F%2Fstatic.wikia.nocookie.net%2Flogosfake%2Fimages%2Fa%2Fad%2FSky_Nature_Generic_ID_2020.png%2Frevision%2Flatest%2Fscale-to-width-down%2F1200%3Fcb%3D20200725184630&h=71ab69ffa3abfe2ce6c20912b44f862adff4f10b9d4d761c18d292b7ffa3e9a9"
+        },
+        {
+            "id": "sky-serie",
+            "title": "Sky Serie",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://i.imgur.com/FYvSq5T.png"
+        },
+        {
+            "id": "sky-uno",
+            "title": "Sky Uno",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.miotvonline.com/wp-content/uploads/2020/09/sky-uno-straming-live-miotv.jpg"
+        },
+        {
+            "id": "sky-sport-24",
+            "title": "Sky Sport 24",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://img2.sport-tv-guide.live/images/tv-station-sky-sport24-it-356.png"
+
+        },
+        {
+            "id": "sky-sport-golf",
+            "title": "Sky Sport Golf",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://search.bus-hit.me/image_proxy?url=https%3A%2F%2Fencrypted-tbn0.gstatic.com%2Fimages%3Fq%3Dtbn%3AANd9GcRQoDZOK798-OYz0E_NAahzde_JW-hLcHK-PjLm0rCXyVVcj_Y%26s&h=4b1b7a276442b52778daf26f745d06f57ff6c0cf401f4d7f3e371a566247f3ef"
+        },
+        {
+            "id": "sky-sport-251",
+            "title": "Sky Sport 251",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-252",
+            "title": "Sky Sport 252",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-253",
+            "title": "Sky Sport 253",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-254",
+            "title": "Sky Sport 254",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-255",
+            "title": "Sky Sport 255",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-256",
+            "title": "Sky Sport 256",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-257",
+            "title": "Sky Sport 257",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-258",
+            "title": "Sky Sport 258",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-259",
+            "title": "Sky Sport 259",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"            
+        },
+        {
+            "id": "sky-sport-260",
+            "title": "Sky Sport 260",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-261",
+            "title": "Sky Sport 261",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://logodownload.org/wp-content/uploads/2020/06/sky-sports-logo-0-1.png"
+        },
+        {
+            "id": "sky-sport-max",
+            "title": "Sky Sport Max",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://i.imgur.com/TWl58VI.png"
+        },
+        {
+            "id": "sky-sport-uno",
+            "title": "Sky Sport Uno",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-sport-1_c.png"
+        },
+        {
+            "id": "sky-sport-f1",
+            "title": "Sky Sport F1",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://i1.wp.com/cache.pressmailing.net/thumbnail/story_hires/395b1e2f-a1c6-4cf6-9869-02155da4021f/Sky_F1_Logo.jpg.jpg"               
+        },
+        {
+            "id": "sky-sport-motogp",
+            "title": "Sky Sport MotoGP",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://img2.sport-tv-guide.live/images/tv-station-sky-sport-motogp-360.png"
+        },
+        {
+            "id": "sky-sport-calcio",
+            "title": "Sky Sport Calcio",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/sky-sport-2_c.png"
+        },
+        {
+            "id": "sky-sport-arena",
+            "title": "Sky Sport Arena",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://img2.sport-tv-guide.live/images/tv-station-sky-sport-arena-354.png"
+        },
+        {
+            "id": "sky-sport-tennis",
+            "title": "Sky Sport Tennis",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://pbs.twimg.com/profile_images/1752313472325431296/jr-YrkR6_400x400.png"
+        },
+        {
+            "id": "sky-sport-nba",
+            "title": "Sky Sport NBA",
+            "name": "",
+            "genres": ["Sky"],
+            "poster": "https://www.nbareligion.com/wp-content/uploads/2019/09/sky-sport-nba.jpg"
+        },
+        {
+            "id": "dazn-zona-a",
+            "title": "DAZN Zona A",
+            "name": "",
+            "genres": ["DAZN"],
+            "poster": "https://i.ytimg.com/vi/0cEfGLq-tz4/maxresdefault.jpg"
+        },
+        {
+            "id": "dazn-1",
+            "title": "DAZN 1",
+            "name": "",
+            "genres": ["DAZN"],
+            "poster": "https://i.ytimg.com/vi/0cEfGLq-tz4/maxresdefault.jpg"
+        },
+        {
+            "id": "eurosport-1",
+            "title": "Eurosport 1",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/eurosport-1_c.png"
+        },
+        {
+            "id": "eurosport-2",
+            "title": "Eurosport 2",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/eurosport-2_c.png"
+        },
+        {
+            "id": "dmax",
+            "title": "DMAX",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/d-max_c.png",
+            "url": "https://amg16146-wbdi-amg16146c8-samsung-it-1841.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-dmax-samsungit/playlist.m3u8"
+        },
+        {
+            "id": "foodnetwork",
+            "title": "Food Network",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster":"https://upload.wikimedia.org/wikipedia/commons/thumb/0/06/Food_Network_logo.svg/1024px-Food_Network_logo.svg.png",
+            "url": "https://amg16146-wbdi-amg16146c3-samsung-it-1836.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-foodnetwork-samsungit/playlist.m3u8"
+        },
+        {
+            "id": "frisbee",
+            "title": "Frisbee",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/9a/FRISBEE_LOGO_2015.png/1280px-FRISBEE_LOGO_2015.png",
+            "url": "https://amg16146-wbdi-amg16146c7-samsung-it-1840.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-frisbee-samsungit/playlist.m3u8"
+        },
+        {
+            "id": "giallo",
+            "title": "Giallo",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/giallo_c.png",
+            "url": "https://amg16146-wbdi-amg16146c5-samsung-it-1838.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-giallo-samsungit/playlist.m3u8"
+        },
+        {
+            "id": "hgtv",
+            "title": "HGTV",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a8/HGTV_2010.svg/1920px-HGTV_2010.svg.png",
+            "url": "https://amg16146-wbdi-amg16146c9-samsung-it-1842.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-hgtv-samsungit/playlist.m3u8"
+        },
+        {
+            "id": "k2",
+            "title": "K2",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://upload.wikimedia.org/wikipedia/it/thumb/7/70/K2_logo_%282013%29.svg/800px-K2_logo_%282013%29.svg.png",
+            "url": "https://amg16146-wbdi-amg16146c6-samsung-it-1839.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-k2-samsungit/playlist.m3u8"
+        },
+        {
+            "id": "nove",
+            "title": "Nove",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/nove_c.png",
+            "url": "https://amg16146-wbdi-amg16146c1-samsung-it-1831.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-nove-samsungit/playlist.m3u8"
+        },
+
+        {
+            "id": "realtime",
+            "title": "Real Time",
+            "name": "",
+            "genres": ["Warner Bros"],
+            "poster": "https://www.sorrisi.com/guidatv/bundles/tvscnewsite/css/images/loghi/real-time_c.png",
+            "url": "https://amg16146-wbdi-amg16146c2-samsung-it-1835.playouts.now.amagi.tv/playlist/amg16146-warnerbrosdiscoveryitalia-realtime-samsungit/playlist.m3u8"
+        },
+        {
+            "id": "supertennis",
+            "title": "Super Tennis",
+            "name": "",
+            "genres": ["FIT"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/0/02/SUPERTENNIS_HD.png",
+            "url": "https://live-embed.supertennix.hiway.media/restreamer/supertennix_client/gpu-a-c0-16/restreamer/rtmp/hls/h24_supertennix/manifest.m3u8"
+        },
+        {
+            "id": "solocalcio",
+            "title": "Solo Calcio",
+            "name": "",
+            "genres": ["Sportitalia"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/7/77/SI_Live_24_logo_%282019%29.svg/1280px-SI_Live_24_logo_%282019%29.svg.png",  
+            "url": "https://di-kzbhv8pw.vo.lswcdn.net/sportitalia/sisolocalcio/playlist.m3u8" 
+        },
+        {
+            "id": "sportitalia",
+            "title": "Sportitalia",
+            "name": "",
+            "genres": ["Sportitalia"],
+            "poster": "https://upload.wikimedia.org/wikipedia/en/5/55/Sportitalia.jpg",
+            "url": "https://di-kzbhv8pw.vo.lswcdn.net/sportitalia/sihd/playlist.m3u8"
+        },
+        {
+            "id": "sportitalia24",
+            "title": "Sportitalia 24",
+            "name": "",
+            "genres": ["Sportitalia"],
+            "poster": "https://upload.wikimedia.org/wikipedia/commons/thumb/7/77/SI_Live_24_logo_%282019%29.svg/1280px-SI_Live_24_logo_%282019%29.svg.png",
+            "url": "https://di-kzbhv8pw.vo.lswcdn.net/sportitalia/sihd/playlist.m3u8"
+        },
+        {
+            "id": "rsi-la-2",
+            "title": "RSI LA 2",
+            "name": "",
+            "genres": ["RSI"],
+            "poster": "https://livehere.one/img/rsi.png"    
+        },
+        {
+            "id": "baby-shark-tv",
+            "title": "Baby Shark TV",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://flxt.tmsimg.com/assets/p19459897_b_v13_aa.jpg",
+            "url": "https://c0c65b821b3542c3a4dca92702f59944.mediatailor.us-east-1.amazonaws.com/v1/master/04fd913bb278d8775298c26fdca9d9841f37601f/RakutenTV-eu_BabySharkTV/playlist.m3u8?ads.content_classification=6&ads.device_lmt=1&ads.device_make=&ads.device_model=&ads.device_type=web&ads.device_year=&ads.env=prod&ads.gdpr_consent=&ads.market=it&ads.player_height=&ads.player_width=&ads.pod_type=playerpage_midroll&ads.ppid=&ads.rtv_content_id=3623&ads.rtv_content_language=eng&ads.rtvid=271861&ads.streaming_id=17ded124-30eb-47bc-ab57-ddfce3a16599&ads.user_type=visitor&ads.wurl_channel=696"
+        },
+        {
+            "id": "adrenaline-movies",
+            "title": "Rakuten Adrenaline Movies",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBC11000050E_20231213T033148SQUARE.png_20231213033148.png",
+            "url": "https://minerva-fullmoon-1-eu.plex.wurl.tv/4300.m3u8"
+        },
+        {
+            "id": "bizzarro-movies",
+            "title": "Bizzarro Movies",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBA3300024IU_20240214T034959SQUARE.png_20240214034959.png",
+            "url": "https://minerva-bizzarromovies-1-eu.plex.wurl.tv/4300.m3u8"
+        },
+        {
+            "id": "cinema-italiano",
+            "title": "Cinema Italiano",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBA33000238E_20240313T074122SQUARE.png",
+            "url": "https://minerva-cinemasegreto-1-eu.plex.wurl.tv/4300.m3u8"
+        },
+        {
+            "id": "le-vite-degli-altri",
+            "title": "Le Vite Degli Altri",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBD3200002DU_20230913T031625SQUARE.png_20230913031625.png",
+            "url": "https://amg02512-nexodigital-amg02512c2-wedotv-eu-869.playouts.now.amagi.tv/playlist/amg02512-nexodigital-levitedeglialtri-wedotveu/playlist.m3u8"
+        },
+        {
+            "id": "dark-matter",
+            "title": "Dark Matter",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBC400001LX_20220404T005859SQUARE.png_20220404005901.png",
+            "url": "https://d39g1vxj2ef6in.cloudfront.net/v1/master/3fec3e5cac39a52b2132f9c66c83dae043dc17d4/prod-rakuten-stitched/master.m3u8?ads.xumo_channelId=88883020&ads.xumo_contentId=3480"
+        },
+        {
+            "id": "cine-western",
+            "title": "Cine Western",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBB20000072M_20240214T035001SQUARE.png_20240214035002.png",
+            "url": "https://minerva-wp-1-eu.plex.wurl.tv/4300.m3u8"
+        },
+        {
+            "id": "serie-crime",
+            "title": "Serie Crime",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://images-2.rakuten.tv/storage/global-live-channel/translation/artwork-negative/0e0a6638-7c4c-4065-82d7-a34d818388ee-width500.png",
+            "url": "https://rakuten-seriecrime-6-it.xiaomi.wurl.tv/4300.m3u8"
+        },
+        {
+            "id": "filmrise-sci-fi",
+            "title": "Filmrise Sci-Fi",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://images-3.rakuten.tv/storage/global-live-channel/translation/artwork_negative/ba0fa0a9-7e17-497e-abcc-9405dbb3a7f5-filmrise-sci-fi-1643623368-quality100.png",
+            "url": "https://d39g1vxj2ef6in.cloudfront.net/v1/master/3fec3e5cac39a52b2132f9c66c83dae043dc17d4/prod-rakuten-stitched/master.m3u8?ads.xumo_channelId=9991764"
+        },
+        {
+            "id": "doctor-who",
+            "title": "Doctor Who",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://images.pluto.tv/channels/62e7f8db27ce19000732d1aa/colorLogoPNG.png",
+            "url": "https://bbceu-doctorwho-1-it.rakuten.wurl.tv/3000.m3u8"
+        },
+        {
+            "id": "bbc-drama",
+            "title": "BBC Drama",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://images.pluto.tv/channels/62e7fa5ab5062e0007dcf97d/colorLogoPNG.png",
+            "url": "https://bbceu-bbcdrama-2-it.rakuten.wurl.tv/3000.m3u8"
+        },
+        {
+            "id": "documentari",
+            "title": "Documentari (Grandi Documentari)",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBC35000016T_20230208T013151SQUARE.png_20230208013152.png",
+            "url": "https://videosolutions-wedobigstories-rakuten.amagi.tv/playlist1080p.m3u8"
+        },
+        {
+            "id": "house-of-docs",
+            "title": "House of Docs",
+            "name": "",
+            "genres": ["Rakuten"],
+            "poster": "https://tvpnlogopeu.samsungcloud.tv/platform/image/sourcelogo/vc/00/02/34/ITBD1100001B7_20230412T042554SQUARE.png_20230412042554.png",
+            "url": "https://amg02512-nexodigital-amg02512c1-wedotv-eu-871.playouts.now.amagi.tv/playlist/amg02512-nexodigital-houseofdocs-wedotveu/playlist.m3u8"
+        },
+        {
+            "id": "pluto-matrimoni",
+            "title": "Pluto TV Matrimoni",
+            "name": "",
+            "genres": ["Pluto"],
+            "poster": "https://images.pluto.tv/channels/661f8f2506839f0008b864e9/colorLogoPNG.png",
+            "url": "http://stitcher.pluto.tv/v1/stitch/embed/hls/channel/661f8f2506839f0008b864e9/master.m3u8?deviceId=0&deviceModel=samsung&deviceVersion=0&appVersion=0&deviceType=samsung&deviceMake=samsung&deviceDNT=true"
+        },
+        {
+            "id": "the-asylum",
+            "title": "The Asylum",
+            "name": "",
+            "genres": ["Pluto"],
+            "poster": "https://images.pluto.tv/channels/62e8d5369e48940007fc1dc1/colorLogoPNG.png",
+            "url": "http://stitcher.pluto.tv/v1/stitch/embed/hls/channel/62e8d5369e48940007fc1dc1/master.m3u8?deviceType=samsung-tvplus&deviceMake=samsung&deviceModel=samsung&deviceVersion=unknown&appVersion=unknown&deviceLat=0&deviceLon=0&deviceDNT=%7BTARGETOPT%7D&deviceId=%7BPSID%7D&advertisingId=%7BPSID%7D&us_privacy=1YNY&samsung_app_domain=%7BAPP_DOMAIN%7D&samsung_app_name=%7BAPP_NAME%7D&profileLimit=&profileFloor=&embedPartner=samsung-tvplus"
+        },
+        {
+            "id": "western",
+            "title": "Western",
+            "name": "",
+            "genres": ["Pluto"],
+            "poster": "https://images.pluto.tv/channels/62e7fb67478a5b0007e6c50c/colorLogoPNG.png",
+            "url": "http://stitcher.pluto.tv/v1/stitch/embed/hls/channel/62e7fb67478a5b0007e6c50c/master.m3u8?deviceType=samsung-tvplus&deviceMake=samsung&deviceModel=samsung&deviceVersion=unknown&appVersion=unknown&deviceLat=0&deviceLon=0&deviceDNT=%7BTARGETOPT%7D&deviceId=%7BPSID%7D&advertisingId=%7BPSID%7D&us_privacy=1YNY&samsung_app_domain=%7BAPP_DOMAIN%7D&samsung_app_name=%7BAPP_NAME%7D&profileLimit=&profileFloor=&embedPartner=samsung-tvplus"
+        },
+        {
+            "id": "consulenze-illegali",
+            "title": "Consulenze Illegali",
+            "name": "",
+            "genres": ["Pluto"],
+            "poster": "https://images.pluto.tv/channels/60b9dc99521a1400079bdfba/colorLogoPNG.png",
+            "url": "http://stitcher.pluto.tv/v1/stitch/embed/hls/channel/60b9dc99521a1400079bdfba/master.m3u8?deviceType=samsung-tvplus&deviceMake=samsung&deviceModel=samsung&deviceVersion=unknown&appVersion=unknown&deviceLat=0&deviceLon=0&deviceDNT=%7BTARGETOPT%7D&deviceId=%7BPSID%7D&advertisingId=%7BPSID%7D&us_privacy=1YNY&samsung_app_domain=%7BAPP_DOMAIN%7D&samsung_app_name=%7BAPP_NAME%7D&profileLimit=&profileFloor=&embedPartner=samsung-tvplus"
+        }
+    ]
+}
+
+
+
+
+webru_vary = {
+    "sky-cinema-action": "calcioXac",
+    "comedy-central": "calcioXcomedycentral",
+    "history": "calcioXhistory",
+    "sky-arte": "calcioXskyarte",
+    "sky-atlantic": "calcioXskyatlantic",
+    "sky-cinema-collection": "calcioXskycinemacollection",
+    "sky-cinema-comedy": "calcioXskycinemacomedy",
+    "sky-cinema-drama": "calcioXskycinemadrama",
+    "sky-cinema-due": "calcioXskycinemadue",
+    "sky-cinema-family": "calcioXskycinemafamily",
+    "sky-cinema-romance": "calcioXskycinemaromance",
+    "sky-cinema-suspence": "calcioXskycinemasuspence",
+    "sky-cinema-uno": "calcioXskycinemauno",
+    "sky-crime": "calcioXskycrime",
+    "sky-documentaries": "calcioXskydocumentaries",
+    "sky-investigation": "calcioXskyinvestigation",
+    "sky-nature": "calcioXskynature",
+    "sky-serie": "calcioXskyserie",
+    "sky-uno": "calcioXskyuno",
+    "sky-sport-24": "calcioXskysport24",  
+}
+'''
+    "sky-sport-golf": "https://webuit.mizhls.ru/lb/calcioXskysportgolf/index.m3u8",
+    "sky-sport-251": "https://webuit.mizhls.ru/lb/calcioXskysport251/index.m3u8",
+    "sky-sport-253": "https://webuit.mizhls.ru/lb/calcioXskysport253/index.m3u8",
+    "sky-sport-max": "https://webuit.mizhls.ru/lb/calcioXskysportmax/index.m3u8",
+    "sky-sport-255": "https://webuit.mizhls.ru/lb/calcioXskysport255/index.m3u8",
+    "sky-sport-259": "https://webuit.mizhls.ru/lb/calcioXsky259/index.m3u8",
+    "sky-sport-252": "https://webuit.mizhls.ru/lb/calcioXskysport252/index.m3u8",
+    "sky-sport-254": "https://webuit.mizhls.ru/lb/calcioXskysport254/index.m3u8",
+    "sky-sport-256": "https://webuit.mizhls.ru/lb/calcioXskysport256/index.m3u8",
+    "sky-sport-257": "https://webuit.mizhls.ru/lb/calcioXskysport257/index.m3u8",
+    "sky-sport-258": "https://webuit.mizhls.ru/lb/calcioXsky258/index.m3u8",
+    "sky-sport-259": "https://webuit.mizhls.ru/lb/calcioXsky259/index.m3u8",
+    "sky-sport-260": "https://webuit.mizhls.ru/lb/calcioXsky260/index.m3u8",
+    "sky-sport-261": "https://webuit.mizhls.ru/lb/calcioXsky261/index.m3u8",
+    "eurosport-1": "https://webuit.mizhls.ru/lb/calcioXeurosport1/index.m3u8",
+    "eurosport-2": "https://webuit.mizhls.ru/lb/calcioXeurosport2/index.m3u8",
+    "sky-sport-uno": "https://webuit.mizhls.ru/lb/calcioXskysportuno/index.m3u8",
+    "sky-sport-f1": "https://webuit.mizhls.ru/lb/calcioXskysportf1/index.m3u8",
+    "sky-sport-motogp": "https://webuit.mizhls.ru/lb/calcioXskysportmotogp/index.m3u8",
+    "sky-sport-calcio": "https://webuit.mizhls.ru/lb/calcioXskysportcalcio/index.m3u8",
+    "sky-sport-arena": "https://webuit.mizhls.ru/lb/calcioXskysportarena/index.m3u8",
+    "sky-sport-tennis": "https://webuit.mizhls.ru/lb/calcioXskysporttennis/index.m3u8",
+    "sky-sport-nba": "https://webuit.mizhls.ru/lb/calcioXskysportnba/index.m3u8", 
+'''
+#"dazn-zona-a": "https://webuit.mizhls.ru/lb/calcioXzona/index.m3u8"
+webru_dlhd = {
+    "sky-sport-tennis": "premium576",
+    "sky-sport-uno": "premium461",
+    "sky-cinema-collection": "premium859",
+    "sky-cinema-romance": "premium864",
+    "sky-sport-24": "premium869",
+    "sky-sport-254": "premium874",
+    "sky-sport-f1": "premium577",
+    "sky-sport-arena": "premium462",
+    "sky-cinema-uno": "premium860",
+    "sky-cinema-family": "premium865",
+    "sky-sport-calcio": "premium870",
+    "sky-sport-255": "premium875",
+    "sky-cinema-action": "premium861",
+    "sky-cinema-due": "premium866",
+    "sky-sport-251": "premium871",
+    "sky-sport-256": "premium876",
+    "sky-sport-golf": "premium574",
+    "sky-uno": "premium881",
+    "sky-cinema-comedy": "premium862",
+    "sky-cinema-drama": "premium867",
+    "sky-sport-252": "premium872",
+    "sky-sport-257": "premium877",
+    "sky-sport-motogp": "premium575",
+    "sky-sport-football": "premium460",
+    "sky-cinema-uno-24": "premium863",
+    "sky-cinema-suspence": "premium868",
+    "sky-sport-253": "premium873",
+    "sky-serie": "premium880",
+    "dazn-1": "premium877"
+}
+extra_sources = {
+    "rai-1": ["https://m3u.iranvids.com/rai01/output.m3u8"],
+    "rai-2": ["https://m3u.iranvids.com/rai02/output.m3u8"],
+    "rai-3": ["https://dash2.antik.sk/live/test_rai_tre_tizen/playlist.m3u8","https://wzstreaming.rai.it/TVlive/liveStream/playlist.m3u8","https://list.iptvcat.com/my_list/s/1f22856f68f2fba4a993c47f47c78a64.m3u8","https://list.iptvcat.com/my_list/s/a372048a4fb440e752aec141aa02885f.m3u8","https://list.iptvcat.com/my_list/s/c7efe17aa0dc8096561967bfb828d4f3.m3u8","https://list.iptvcat.com/my_list/s/2d1f14bbb3370d263d8d3f0d9f5128e0.m3u8"],
+    "rete-4":["https://tvit.leicaflorianrobert.dev/mediaset/rete-4/stream.m3u8","https://live02-seg.msf.cdn.mediaset.net/live/ch-r4/r4-clr.isml/index.m3u8"],
+    "canale-5":["https://live02-seg.msf.cdn.mediaset.net/live/ch-c5/c5-clr.isml/index.m3u8","https://tvit.leicaflorianrobert.dev/mediaset/canale-5/stream.m3u8"],
+    "italia-1":["https://tvit.leicaflorianrobert.dev/mediaset/italia-1/stream.m3u8","https://live02-seg.msf.cdn.mediaset.net/live/ch-i1/i1-clr.isml/index.m3u8"],
+    "rai-4k": ["https://list.iptvcat.com/my_list/s/fbf04fbd9694eee71b5af9f12e49538d.m3u8"],
+    "rai-news":["https://8e7439fdb1694c8da3a0fd63e4dda518.msvdn.net/rainews1/hls/playlist_mo.m3u8"],
+    "topcrime": ["https://tvit.leicaflorianrobert.dev/mediaset/top-crime/stream.m3u8"],
+    "mediaset-extra": ["https://tvit.leicaflorianrobert.dev/mediaset/mediaset-extra/stream.m3u8"],
+    "focus": ["https://tvit.leicaflorianrobert.dev/mediaset/focus/stream.m3u8"],
+    "boing": ["https://tvit.leicaflorianrobert.dev/mediaset/boing/stream.m3u8"],
+    "cartoonito": ["https://tvit.leicaflorianrobert.dev/mediaset/cartoonito/stream.m3u8"],
+    "tv8": ["https://tvit.leicaflorianrobert.dev/sky/tv8/stream.m3u8"],
+    "cielo": ["https://tvit.leicaflorianrobert.dev/sky/cielo/stream.m3u8"],
+    "dmax": ["https://tvit.leicaflorianrobert.dev/discovery/dmax/stream.m3u8"],
+    "nove": ["https://tvit.leicaflorianrobert.dev/discovery/nove/stream.m3u8"],
+    "euronews": ["https://amg00882-amg00882c4-wedotv-eu-4536.playouts.now.amagi.tv/playlist/amg00882-euronewsfast-euronewsita-wedotveu/playlist.m3u8?app_bundle=&app_name=wedotv&app_store_url=https://wedotv.com&url=https://wedotv.com&gdpr=1&channel_name=Euronews - Italiano&content_custom_1_param=Euronews - Italiano"],
+    "doctor-who": ["https://amg00793-amg00793c17-samsung-it-4577.playouts.now.amagi.tv/playlist/amg00793-bbcstudios-drwhoitaly-samsungit/playlist.m3u8"]
+}
+skystreaming ={
+    "sky-sport-tennis": "https://skystreaming.guru/embed/MKCKP",
+    "sky-sport-24": "https://skystreaming.guru/embed/GB7zq",
+    "sky-sport-251": "https://skystreaming.guru/embed/drHbM",
+    "sky-sport-252": "https://skystreaming.guru/embed/m5kfg",
+    "sky-sport-253": "https://skystreaming.guru/embed/YprHf",
+    "sky-sport-254": "https://skystreaming.guru/embed/wroRV",
+    "sky-sport-255": "https://skystreaming.guru/embed/0TixN",
+    "sky-sport-256": "https://skystreaming.guru/embed/8g8bh",
+    "sky-sport-257": "https://skystreaming.guru/embed/ri859",
+    "sky-sport-258": "https://skystreaming.guru/embed/UoJuW",
+    "sky-sport-259": "https://skystreaming.guru/embed/squCy",
+    "sky-sport-260": "https://skystreaming.guru/embed/Z5h2e",
+    "sky-sport-261": "https://skystreaming.guru/embed/Hz9FW",
+    "sky-sport-uno": "https://skystreaming.guru/embed/tb1np",
+    "sky-sport-f1": "https://skystreaming.guru/embed/MLkym",
+    "sky-sport-motogp": "https://skystreaming.guru/embed/ARFFv",
+    "sky-sport-calcio": "https://skystreaming.guru/embed/STOZT",
+    "sky-sport-arena": "https://skystreaming.guru/embed/NkEda",
+    "sky-sport-max": "https://skystreaming.guru/embed/4QzWz",
+    "sky-sport-nba": "https://skystreaming.guru/embed/saR8j",
+    "sky-sport-golf": "https://skystreaming.guru/embed/s9L5f",
+    "eurosport-1": "https://skystreaming.guru/embed/Vyv99",
+    "eurosport-2": "https://skystreaming.guru/embed/um8E5",
+    "dazn-zona-a": ["https://hls.psz.pm/hls/serie/index.m3u8","https://hls.cls.autos/hls/serie/index.m3u8"],
+    "sportitalia": "https://hls.cls.autos/hls/sportitalia/index.m3u8",
+}
+huhu = {
+    "canale-5": "1101559666",
+    "sky-sport-motogp": "2090703806",
+    "rai-1": "1225653759",
+    "sky-cinema-drama": "1235530177",
+    "sky-cinema-action": "3812796171",
+    "Dazn": "2745635299",
+    "sky-sport-uno": "3192996672",
+    "canale-5": "1534161807",
+    "mediaset-extra": "477466531",
+    "Dazn-1": "1376440573",
+    "sky-sport-24": "2775802255",
+    "sky-sport-24": "3445562519",
+}
+provider_map = {
+        'SC': 'STREAMINGCOMMUNITY',
+        'SC_FS': 'SC_FAST_SEARCH',
+        'LC': 'LORDCHANNEL',
+        'SW': 'STREAMINGWATCH',
+        'TF_FS': 'TF_FAST_SEARCH',
+        'TF': 'TANTIFILM',  # Assuming 'TF' should also be handled
+        'FT': 'FILMPERTUTTI',
+        'AW': 'ANIMEWORLD'
+    }

Src/Utilities/info.py

@@ -0,0 +1,193 @@
+from Src.Utilities.loadenv import load_env
+from tmdbv3api import TMDb, Movie, TV
+from Src.Utilities.convert_date import convert_US_date, convert_IT_date
+import Src.Utilities.config as config
+import json
+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
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+        elif type == "StreamingCommunity":
+            full_date = show.first_air_date
+            date = full_date.split("-")[0]
+            print(date)
+            return showname,date
+        elif type == "StreamingCommunityFS":
+                return showname
+        elif type == "Tantifilm":
+            date = show.first_air_date
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+        elif type == "TantifilmFS":
+            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 type == "DDLStream":
+            return showname
+        elif type == "Cb01":
+            date = show.first_air_date
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "Whvx":
+            date = show.first_air_date
+            date = date.split("-")[0]
+            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
+            date = date.split("-")[0]
+            #GET US RELEASE DATE because filmpertutti somewhy uses US release date
+            return showname,date
+        elif type == "StreamingCommunity":
+            date = show.release_dates
+            date = date.split("-")[0]
+            return showname
+        elif type == "StreamingCommunityFS":
+            return showname
+        elif type == "Tantifilm":
+            date = show.release_date
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname,date
+        elif type == "TantifilmFS":
+                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
+        elif type == "DDLStream":
+            return showname
+        elif type == "Cb01":
+            date = show.release_date
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "Whvx":
+            date = show.release_date
+            date = date.split("-")[0]
+            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']
+            date = date.split("-")[0]
+            print("Real date",date)
+            return showname, date
+        elif type == "StreamingCommunity":
+            date = data['tv_results'][0]['first_air_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "StreamingCommunityFS":
+            return showname
+        elif type == "Tantifilm":
+            date = data['tv_results'][0]['first_air_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "TantifilmFS":
+                return showname
+        elif type == "Cool":
+            return showname
+        elif type == "DDLStream":
+            return showname
+        elif type == "Cb01":
+            date = data['tv_results'][0]['first_air_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "Whvx":
+            date = data['tv_results'][0]['first_air_date']
+            date = date.split("-")[0]
+            return showname,date
+
+    elif ismovie == 1:
+        showname= data['movie_results'][0]['title']
+        if type == "Filmpertutti":
+            date = data['movie_results'][0]['release_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "StreamingCommunity":
+            date = data['movie_results'][0]['release_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "StreamingCommunityFS":
+            return showname
+        elif type == "Tantifilm":
+            date = data['movie_results'][0]['release_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "Cool":
+            return showname
+        elif type == "DDLStream":
+            return showname
+        elif type == "Cb01":
+            date = data['movie_results'][0]['release_date']
+            date = date.split("-")[0]
+            return showname,date
+        elif type == "Whvx":
+            date = data['movie_results'][0]['release_date']
+            date = date.split("-")[0]
+            return showname,date
+
+
+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

Src/Utilities/loadenv.py

@@ -0,0 +1,22 @@
+import os
+import Src.Utilities.config as config
+MYSTERIUS = config.MYSTERIUS  
+dotenv = config.dotenv
+HF = config.HF
+Public_Instance = config.Public_Instance
+#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')
+    env_vars['PROXY_CREDENTIALS'] = os.getenv('PROXY')
+    env_vars['MEDIAFLOW_PASS'] = os.getenv('MEDIAFLOW_PASS')
+    if Public_Instance == "1":
+        env_vars['ALTERNATIVE_LINK'] = os.getenv('ALTERNATIVE_LINK')
+    return env_vars

config.json

@@ -0,0 +1,41 @@
+{
+  "Siti": {
+         "StreamingCommunity": {
+             "domain": "buzz"
+         },
+         "Filmpertutti": {
+             "domain": "diy"
+         },
+         "Tantifilm":{
+             "domain": "bond"
+         },
+         "Mysterius":{
+             "enabled": "0"    
+         },
+        "LordChannel":{
+             "domain":"com"
+        },
+        "StreamingWatch":{
+            "domain":"org"
+        },
+        "AnimeWorld":{
+            "domain":"so"
+        },
+        "SkyStreaming":{
+            "domain":"guru"
+        },
+        "DaddyLiveHD":{
+            "enabled":"1"
+        }
+ },
+ "General":{
+     "load_env": "0",
+     "HOST": "0.0.0.0",
+     "PORT": "8080",
+     "HF": "1",
+     "Public_Instance": "0",
+     "MediaProxy": ["Test"],
+     "ForwardProxy": ["Test"],
+     "Proxy": []
+ }
+}

example.env

@@ -1,7 +1,3 @@
 TMDB_KEY= "INSERT YOUR API KEY HERE"
-FT_DOMAIN = "INSERT FILMPERTUTTI DOMAIN"
+MEDIAFLOW_PASS = "INSERT YOUR MEDIAFLOW PASS HERE"
-SC_DOMAIN = "INSERT STREAMINGCOMMUNITY DOMAIN"
-FILMPERTUTTI= "Put 1 if enabled, 0 if disabled"
-STREAMINGCOMMUNITY = "Put 1 if enabled, 0 if disabled"
-
 

filmpertutti.py

@@ -1,119 +0,0 @@
-
-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 loadenv import load_env
-from info import get_info, is_movie
-from convert_date import convert_US_date
-import logging
-
-_, FT_DOMAIN,_,_ ,_= load_env()
-#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
-            break
-    return url, tid  
-
-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]
-    if ismovie == 0 : 
-        season = int(general[2])
-        episode = int(general[3])
-    tmdba  = get_TMDb_id_from_IMDb_id(imdb_id)
-    type = "Filmpertutti"
-    showname,date = get_info(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'
-    url,tid = search(query,date)
-    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

@@ -1,42 +0,0 @@
-from loadenv import load_env
-from tmdbv3api import TMDb, Movie, TV
-from convert_date import convert_US_date, convert_IT_date
-TMDB_KEY,_,_,FILMPERTUTTI,STREAMINGCOMMUNITY = load_env()
-
-def get_info(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
-        elif type == "StreamingCommunity":
-            date = show.last_air_date
-            print("Real date",date)
-    else:
-        movie = Movie()
-        show= movie.details(tmbda)
-        showname= show.title
-        #Get all release dates
-        date = show.release_dates
-        if type == "Filmpertutti":
-            #GET US RELEASE DATE because filmpertutti somewhy uses US release date
-            date = convert_US_date(date)
-    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[-1]
-        ismovie = 0
-        imdb_id = imdb_id.split(":")[0]
-        return ismovie,imdb_id,season,episode
-    else:
-        ismovie = 1
-        return ismovie,imdb_id

loadenv.py

@@ -1,10 +0,0 @@
-import os
-from dotenv import load_dotenv
-load_dotenv(".env")
-def load_env():
-    TMDB_KEY = os.getenv('TMDB_KEY')
-    FT_DOMAIN = os.getenv('FT_DOMAIN')
-    SC_DOMAIN= os.getenv('SC_DOMAIN')
-    FILMPERTUTTI = os.getenv('FILMPERTUTTI')
-    STREAMINGCOMMUNITY = os.getenv('STREAMINGCOMMUNITY')
-    return TMDB_KEY, FT_DOMAIN, SC_DOMAIN, FILMPERTUTTI, STREAMINGCOMMUNITY

requirements.txt

@@ -2,5 +2,10 @@ bs4
 tmdbv3api
 dateparser
 python-dotenv
-flask
+fastapi
+uvicorn
+tzdata
 lxml
+slowapi
+curl_cffi
+fake-headers

run.py

@@ -1,63 +1,287 @@
-from flask import Flask, jsonify, abort
+from fastapi import FastAPI, HTTPException,Request
-from filmpertutti import filmpertutti
+from fastapi.responses import JSONResponse,RedirectResponse,HTMLResponse
-from streamingcommunity import streaming_community
+from Src.API.filmpertutti import filmpertutti
-from loadenv import load_env
+from  Src.API.streamingcommunity import streaming_community
-TMDB_KEY, FT_DOMAIN, SC_DOMAIN, FILMPERTUTTI, STREAMINGCOMMUNITY = load_env()
+from  Src.API.tantifilm import tantifilm
-
+from  Src.API.lordchannel import lordchannel
-
+from  Src.API.streamingwatch import streamingwatch
-app = Flask(__name__)
+import  Src.Utilities.config as config
+import logging
+from Src.API.okru import okru_get_url
+from Src.API.animeworld import animeworld
+from Src.Utilities.dictionaries import okru,STREAM,extra_sources,webru_vary,webru_dlhd,provider_map,skystreaming
+from Src.API.epg import tivu, tivu_get,epg_guide,convert_bho_1,convert_bho_2,convert_bho_3
+from Src.API.webru import webru,get_skystreaming
+from curl_cffi.requests import AsyncSession
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from slowapi.middleware import SlowAPIMiddleware
+from static.static import HTML
+# Configure logging
+MYSTERIUS = config.MYSTERIUS
+DLHD = config.DLHD
+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 Src.API.cool import cool
 
+app = FastAPI()
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_middleware(SlowAPIMiddleware)
 MANIFEST = {
     "id": "org.stremio.mammamia",
-    "version": "1.0.0",
+    "version": "1.1.0",
-    "catalogs": [],
+    "catalogs": [
-    "resources": ["stream"],
+        {
-    "types": ["movie", "series"],
+            "type": "tv",
+            "id": "tv_channels",
+            "name": "TV Channels",
+            "behaviorHints": {
+                "configurable": True,
+                "configurationRequired": True
+                },
+            "extra": [
+                {
+                    "name": "genre",
+                    "isRequired": False,
+                    "options": ["Rai", "Mediaset", "Sky", "Euronews", "La7", "Warner Bros", "FIT", "Sportitalia","RSI","DAZN", "Rakuten", "Pluto", "A+E", "Paramount", "Chill"]
+                }
+            ]
+        }
+    ],
+    "resources": ["stream", "catalog", "meta"],
+    "types": ["movie", "series", "tv"],
     "name": "Mamma Mia",
-    "description": "Addon providing HTTPS Stream for Italian Movies/Series",
+    "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 = jsonify(data)
+    resp = JSONResponse(data)
     resp.headers['Access-Control-Allow-Origin'] = '*'
     resp.headers['Access-Control-Allow-Headers'] = '*'
     return resp
 
-@app.route('/manifest.json')
+@app.get('/config')
+def config():
+    return RedirectResponse(url="/")
+@app.get('/{config}/manifest.json')
 def addon_manifest():
     return respond_with(MANIFEST)
+@app.get('/manifest.json')
+def manifest():
+    return RedirectResponse(url="/|SC|LC|SW|/manifest.json")
 
-@app.route('/')
+@app.get('/', response_class=HTMLResponse)
-def root():
+def root(request: Request):
-    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"
+    forwarded_proto = request.headers.get("x-forwarded-proto")
+    scheme = forwarded_proto if forwarded_proto else request.url.scheme
+    instance_url = f"{scheme}://{request.url.netloc}"
+    html_content = HTML.replace("{instance_url}", instance_url)
+    return html_content
+async def addon_catalog(type: str, id: str, genre: str = None):
+    print(f"Received genre parameter: {genre}")
+    if type != "tv":
+        raise HTTPException(status_code=404)
+    
+    catalogs = {"metas": []}
+    
+    for channel in STREAM["channels"]:
+        if genre and genre not in channel.get("genres", []):
+            continue  # Skip channels that don't match the selected genre
+        
+        description = f'Watch {channel["title"]}'
+        catalogs["metas"].append({
+            "id": channel["id"],
+            "type": "tv",
+            "name": channel["title"],
+            "poster": channel["poster"],  # Add poster URL if available
+            "description": description,
+            "genres": channel.get("genres", [])
+        })
+
+    return catalogs
+@app.get('/{config}/catalog/{type}/{id}.json')
+@limiter.limit("5/second")
+async def first_catalog(request: Request,type: str, id: str, genre: str = None):
+    catalogs = await addon_catalog(type, id,genre)
+    return respond_with(catalogs)
+
+@app.get('/{config}/catalog/{type}/{id}/genre={genre}.json')
+async def first_catalog(type: str, id: str, genre: str = None):
+    catalogs = await addon_catalog(type, id,genre)
+    return respond_with(catalogs)
+
+@app.get('/{config}/meta/tv/{id}.json')
+@limiter.limit("20/second")
+async def addon_meta(request: Request,id: str):
+    # Find the channel by ID
+    channel = next((ch for ch in STREAM['channels'] if ch['id'] == id), None)
+    
+    if not channel:
+        raise HTTPException(status_code=404, detail="Channel not found")
+    async with AsyncSession() as client:
+        if channel["id"] in convert_bho_1 or channel["id"] in convert_bho_2 or channel["id"] in convert_bho_3:
+            description,title =  await epg_guide(channel["id"],client)
+        elif channel["id"] in tivu:
+            description = await tivu_get(channel["id"],client)
+            print(description)
+            title = ""
+        else:
+            description = f'Watch {channel["title"]}'
+            title = ""
+    meta = {
+        'meta': {
+            'id': channel['id'],
+            'type': 'tv',
+            'name': channel['name'],
+            'poster': channel['poster'],
+            'posterShape': 'landscape',
+            'description': title + "\n" + description,
+            # Additional fields can be added here
+            'background': channel['poster'],  # Example of using the same poster as background
+            'logo': channel['poster'],
+            'genres': channel.get('genres', []),  # Example of using the same poster as logo
+        }
+    }
+    if 'url' in channel:
+        meta['meta']['url'] = channel['url']  # Using the stream URL as a website link
+    return respond_with(meta)
 
 
-
+@app.get('/{config}/stream/{type}/{id}.json')
-@app.route('/stream/<type>/<id>.json')
+@limiter.limit("5/second")
-def addon_stream(type, id):
+async def addon_stream(request: Request,config, type, id,):
     if type not in MANIFEST['types']:
-        abort(404) 
+        raise HTTPException(status_code=404)
     streams = {'streams': []}
-    if STREAMINGCOMMUNITY == "1":
+    config_providers = config.split('|')
-        url_streaming_community = streaming_community(id)
+    provider_maps = {name: "0" for name in provider_map.values()}
-        print(url_streaming_community)
+    for provider in config_providers:
-        if url_streaming_community is not None:
+            if provider in provider_map:
-            streams['streams'].append({'title': 'StreamingCommunity 1080p', 'url': f'{url_streaming_community}?rendition=1080p'})
+                provider_name = provider_map[provider]
-            streams['streams'].append({'title': 'StreamingCommunity 720p', 'url': f'{url_streaming_community}?rendition=720p'})
+                provider_maps[provider_name] = "1"
 
-    # If FILMPERTUTTI == 1, scrape that site      
+    async with AsyncSession() as client:
-    if FILMPERTUTTI == "1":
+        if type == "tv":
-        url_filmpertutti = filmpertutti(id)
+            for channel in STREAM["channels"]:
-        if url_filmpertutti is not None:
+                if channel["id"] == id:
-            streams['streams'].append({'title': 'Filmpertutti', 'url': url_filmpertutti})
+                    i = 0
+                    if 'url' in channel:
+                        i = i+1
+                        streams['streams'].append({
+                            'title': f"{HF}Server {i} " + f" "+ channel['name'] + " " + channel['title'] ,
+                            'url': channel['url']
+                            })    
+                    if id in okru:
+                        i = i+1
+                        channel_url = await okru_get_url(id,client)
+                        streams['streams'].append({
+                            'title':  f"{HF}Server {i} " +  channel['title'] + " OKRU",
+                            'url': channel_url
+                        })
+                    if id in extra_sources:
+                        list_sources = extra_sources[id]
+                        for item in list_sources:
+                            i = i+1
+                            streams['streams'].append({'title':f"{HF}Server {i} " + channel['title'],'url': item})
+                    if id in skystreaming:
                         
-    # If no streams were added, abort with a 404 error
+                        urls = await get_skystreaming(id,client)
+                        for url in urls:
+                            i = i+1
+                            Host = urls[url]
+                            print(url,Host)
+                            streams['streams'].append({'title': f'{HF}Server {i}', 'url': url, "behaviorHints": {"notWebReady": True, "proxyHeaders": {"request": {"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0", "Accept": "*/*", "Accept-Language": "en-US,en;q=0.5", "Origin": "https://skystreaming.guru", "DNT": "1", "Sec-GPC": "1", "Connection": "keep-alive", "Referer": "https://skystreaming.guru/", "Sec-Fetch-Dest": "empty", "Sec-Fetch-Mode": "cors", "Sec-Fetch-Site": "cross-site", "Pragma": "no-cache", "Cache-Control": "no-cache", "TE": "trailers","Host": Host}}}})
+                            
+                    if id in webru_vary:
+                        i = i+1
+                        webru_url = await webru(id,"vary",client)
+                        streams['streams'].append({'title': f"{HF}Server {i} " + channel['title'],'url': webru_url})
+                    if id in webru_dlhd:
+                        if DLHD == "1":
+                            i = i+1
+                            webru_url_2 = await webru(id,"dlhd",client)
+                            streams['streams'].append({'title': f"{HF}Server {i} " + channel['title'],'url': webru_url_2})
             if not streams['streams']:
-        abort(404)
+                raise HTTPException(status_code=404)
+            return respond_with(streams)
+        elif "tt" in id or "tmdb" in id or "kitsu" in id:
+            print(f"Handling movie or series: {id}")
+            if "kitsu" in id:
+                if provider_maps['ANIMEWORLD'] == "1":
+                    animeworld_urls = await animeworld(id,client)
+                    if animeworld_urls:
+                        print(f"AnimeWorld Found Results for {id}")
+                        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:
+                        print(f"Mysterius Found Results for {id}")
+                        for resolution, link in results.items():
+                            streams['streams'].append({'title': f'{HF}Mysterious {resolution}', 'url': link})
+                print(provider_maps['STREAMINGCOMMUNITY'])
+                if provider_maps['STREAMINGCOMMUNITY'] == "1":
+                    SC_FAST_SEARCH = provider_maps['SC_FAST_SEARCH']
+                    url_streaming_community,url_720_streaming_community,quality_sc = await streaming_community(id,client,SC_FAST_SEARCH)
+                    if url_streaming_community is not None:
+                        print(f"StreamingCommunity Found Results for {id}")
+                        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 provider_maps['LORDCHANNEL'] == "1":
+                    url_lordchannel,quality_lordchannel = await lordchannel(id,client)
+                    if quality_lordchannel == "FULL HD" and url_lordchannel !=  None:
+                        print(f"LordChannel Found Results for {id}")
+                        streams['streams'].append({'title': f'{HF}LordChannel 1080p', 'url': url_lordchannel})
+                    elif url_lordchannel !=  None:
+                        print(f"LordChannel Found Results for {id}")
+                        streams['streams'].append({'title': f'{HF}LordChannel 720p', 'url': url_lordchannel})            
+                if provider_maps['FILMPERTUTTI'] == "1":
+                    url_filmpertutti = await filmpertutti(id,client)
+                    if url_filmpertutti is not None:
+                        print(f"Filmpertutti Found Results for {id}")
+                        streams['streams'].append({'title': 'Filmpertutti', 'url': url_filmpertutti})
+                if provider_maps['TANTIFILM'] == "1":
+                    TF_FAST_SEARCH = provider_maps['TF_FAST_SEARCH']                    
+                    url_tantifilm = await tantifilm(id,client,TF_FAST_SEARCH)
+                    if url_tantifilm:
+                        print(f"TantiFilm Found Results for {id}")
+                        if not isinstance(url_tantifilm, str):
+                            for title, url in url_tantifilm.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_tantifilm,  'behaviorHints': {'proxyHeaders': {"request": {"Referer": "https://d000d.com/"}}, 'notWebReady': True}})
+                if provider_maps['STREAMINGWATCH'] == "1":
+                    url_streamingwatch = await streamingwatch(id,client)
+                    if url_streamingwatch:
+                        print(f"Streaming Watch Found Results for {id}")
+                        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__':
-    app.run(host='0.0.0.0', port=8080)
+    import uvicorn
+    uvicorn.run("run:app", host=HOST, port=PORT, log_level="info")

static/static.py

@@ -0,0 +1,273 @@
+# static.py
+
+HTML = """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Mamma Mia</title>
+    <link rel="icon" href="https://creazilla-store.fra1.digitaloceanspaces.com/emojis/49647/pizza-emoji-clipart-md.png" type="image/x-icon">
+    <title>Fast Search Example</title>
+    <style>
+        * {
+            box-sizing: border-box;
+        }
+        body, html {
+            margin: 0;
+            padding: 0;
+            width: 100%;
+            height: 100%;
+            font-size: 2.2vh;
+            font-family: 'Open Sans', Arial, sans-serif;
+            color: white;
+            background: url('https://i.postimg.cc/m2ZqvpZj/italian-seamless-free-vector-pattern3.png') center center repeat;
+            background-size: cover;
+            display: flex;
+            align-items: flex-start;
+            justify-content: center;
+            overflow-y: auto;
+        }
+        #addon {
+            background: rgba(0, 0, 0, 0.8);
+            padding: 0.5vh;
+            border-radius: 10px;
+            width: 65vh;
+            max-width: 100%;
+            text-align: center;
+            margin-top: 10vh;
+        }
+        .logo {
+            width: 12vh;
+            margin: 0 auto;
+            margin-bottom: 3vh;
+            margin-top: -3vh;
+        }
+        .logo img {
+            width: 100%;
+            height: auto;
+        }
+        h1, h2, h3 {
+            margin: 0;
+            text-shadow: 0 0 1vh rgba(0, 0, 0, 0.15);
+        }
+        h1 {
+            font-size: 4.5vh;
+            font-weight: 700;
+        }
+        h2 {
+            font-size: 2vh;
+            font-weight: normal;
+            font-style: italic;
+            opacity: 0.8;
+            margin-bottom: 20px;
+        }
+        h3 {
+            font-size: 2.2vh;
+            margin-bottom: 10px;
+        }
+        .provider-group {
+            display: flex;
+            align-items: center; /* Vertically align items */
+            justify-content: space-between; /* Spread items across the available space */
+            margin-bottom: 2vh;
+            background: rgba(255, 255, 255, 0.1);
+            padding: 1.5vh;
+            border-radius: 5px;
+            overflow: hidden;
+            width: 100%;
+        }
+        .provider-group label {
+            display: flex;
+            align-items: center; /* Align items within label vertically centered */
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            flex-grow: 1; /* Let the label take as much space as possible */
+            font-size: 2.2vh;
+        }
+        .fast-search {
+            display: flex;
+            align-items: center; /* Align the Fast Search checkbox vertically centered */
+            margin-left: 10px; /* Space between provider and Fast Search */
+        }
+        .fast-search input[type="checkbox"] {
+            margin-right: 0.5vh; /* Space between the checkbox and label */
+            width: 3vh;
+            height: 3vh;
+        }
+        .provider-group input[type="checkbox"] {
+            margin-right: 1.5vh;
+            width: 4vh;
+            height: 4vh;
+        }
+        .parent-container {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            width: 100%;
+        }
+        .contact {
+            position: absolute;
+            left: 0;
+            bottom: 4vh;
+            width: 100%;
+            text-align: center;
+        }
+        .contact a {
+            font-size: 1.4vh;
+            font-style: italic;
+        }
+        button {
+            border: 0;
+            outline: 0;
+            color: white;
+            background: #8A5AAB;
+            padding: 1.2vh 3.5vh;
+            text-align: center;
+            font-family: 'Open Sans', Arial, sans-serif;
+            font-size: 2.2vh;
+            font-weight: 600;
+            cursor: pointer;
+            display: block;
+            box-shadow: 0 0.5vh 1vh rgba(0, 0, 0, 0.2);
+            transition: box-shadow 0.1s ease-in-out;
+            width: 80%;
+            max-width: 35vh;
+            margin: 1vh auto;
+        }
+        button:hover {
+            box-shadow: none;
+        }
+        button:active {
+            box-shadow: 0 0 0 0.5vh white inset;
+        }
+        #manifestBox {
+            margin-top: 2vh;
+            padding: 2vh;
+            background: rgba(255, 255, 255, 0.2);
+            border-radius: 5px;
+            display: none;
+            text-align: left;
+            white-space: pre-wrap;
+        }
+        #generateManifestButton {
+            background: #4CAF50;
+        }
+        #installButton {
+            background: #FF5722;
+        }
+        #installButton a {
+            color: white;
+            text-decoration: none;
+        }
+        #additionalText {
+            margin-top: 2vh;
+            font-size: 1.8vh;
+            text-align: left;
+        }
+        /* Responsive adjustments for smaller screens */
+        @media (max-width: 600px) {
+            .provider-group label {
+                font-size: 2vh;
+                white-space: nowrap;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div id="addon">
+        <div class="logo">
+            <img src="https://creazilla-store.fra1.digitaloceanspaces.com/emojis/49647/pizza-emoji-clipart-md.png" alt="Logo">
+        </div>
+        <h1 class="name">Mamma Mia</h1>
+        <h2 class="version">v1.1.0</h2>
+        <div id="additionalText">
+            <h2>This addon provides Movie, Series, Anime, and Live TV HTTPS Streams.<br> https://github.com/UrloMythus/MammaMia/</h2>
+        </div>
+        <p class="description">Configure your providers: Note that if you enable Fast Search results will be less accurate but faster. <br> Filmpertutti and Tantifilm won't work if you are not using a local (on your PC) instance.</p>
+        <h3 class="gives">Select Providers:</h3>
+        <form class="pure-form" id="provider-form">
+            <div class="provider-group">
+                <label for="streamingcommunity" class="provider-label">
+                    <input type="checkbox" id="streamingcommunity"> StreamingCommunity
+                </label>
+                <span class="fast-search">
+                    <label for="fast_search_sc">
+                        <input type="checkbox" id="fast_search_sc"> Fast Search
+                    </label>
+                </span>
+            </div>
+            <div class="provider-group">
+                <label for="lordchannel" class="provider-label">
+                    <input type="checkbox" id="lordchannel"> LordChannel
+                </label>
+            </div>
+            <div class="provider-group">
+                <label for="streamingwatch" class="provider-label">
+                    <input type="checkbox" id="streamingwatch"> StreamingWatch
+                </label>
+            </div>
+            <div class="provider-group">
+                <label for="tantifilm" class="provider-label">
+                    <input type="checkbox" id="tantifilm"> Tantifilm
+                </label>
+                <span class="fast-search">
+                    <label for="fast_search_tf">
+                        <input type="checkbox" id="fast_search_tf"> Fast Search
+                    </label>
+                </span>
+            </div>
+            <div class="provider-group">
+                <label for="filmpertutti" class="provider-label">
+                    <input type="checkbox" id="filmpertutti"> Filmpertutti
+                </label>
+            </div>
+            <div class="provider-group">
+                <label for="animeworld" class="provider-label">
+                    <input type="checkbox" id="animeworld"> Animeworld
+                </label>
+            </div>
+        </form>
+        <button id="generateManifestButton">Generate Link</button>
+        <button id="installButton">INSTALL</button>
+        <div id="manifestBox"></div>
+    </div>
+       <script>
+        function generateManifest() {
+            let manifest = "|";
+            const providers = {
+                "streamingcommunity": "SC",
+                "fast_search_sc": "SC_FS",
+                "lordchannel": "LC",
+                "streamingwatch": "SW",
+                "tantifilm": "TF",
+                "fast_search_tf": "TF_FS",
+                "filmpertutti": "FT",
+                "animeworld": "AW"
+            };
+            
+            for (const id in providers) {
+                if (document.getElementById(id).checked) {
+                    manifest += providers[id] + "|";
+                }
+            }
+            const instanceUrl = "{instance_url}";  // Keep http in the URL
+            const manifestUrl = instanceUrl + "/" + manifest + "/" + "manifest.json";
+            return manifestUrl;
+        }
+        document.getElementById('generateManifestButton').addEventListener('click', function() {
+            const manifestUrl = generateManifest();
+            document.getElementById("manifestBox").style.display = "block";
+            document.getElementById("manifestBox").innerText = manifestUrl;
+        });
+        document.getElementById('installButton').addEventListener('click', function() {
+            let manifestUrl = generateManifest();
+            manifestUrl = manifestUrl.replace("http://", "");
+            manifestUrl = manifestUrl.replace("https://", "");
+            const stremioUrl = "stremio://" + manifestUrl;
+            window.location.href = stremioUrl;
+        });
+    </script>
+</body>
+</html>
+"""

streamingcommunity.py

@@ -1,102 +0,0 @@
-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 loadenv import load_env
-from info import get_info, is_movie
-#Get domain
-_, _,SC_DOMAIN,_ ,_= load_env()
-
-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'
-}
-
-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']
-        return tid,slug
-
-        
-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):
-    #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': 'c1bdf1189cb68fca28151c8e909bd053'
-        }   
-      #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):
-    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:
-        #If it is a imbd then conver it to tmbd
-        tmdba  = get_TMDb_id_from_IMDb_id(imdb_id)
-    else:
-        #else just equals them
-        tmdba = imdb_id.replace("tmdb:","")
-    type = "StreamingCommunity"
-    showname,date = get_info(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
-        episode_id = get_season_episode_id(tid,slug,season,episode)
-        url = get_episode_link(episode_id,tid)
-        print(url)
-        return url