Fix Okru+ fix skystreaming

README.md

@@ -292,7 +292,7 @@ Open your instance URL and configure MammaMia. Once you are done you can click o
 
   
 
-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
 
   
 

Src/API/cb01.py

@@ -0,0 +1,263 @@
+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
+
+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

@@ -4,6 +4,7 @@ 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 = {
@@ -33,6 +34,7 @@ async def get_links(slug,season,episode,ismovie,client):
             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:
@@ -63,7 +65,7 @@ async def get_links(slug,season,episode,ismovie,client):
             print(f"JSONDecodeError: {e}")
             return None
 
-    except client.RequestException as e:
+    except Exception as e:
         print(f"Request error: {e}")
         return None
     
@@ -144,3 +146,15 @@ async def cool(imdb,client):
     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

@@ -139,9 +139,6 @@ convert_bho_3 = {
 
 async def tivu_get(id,client):
     try:
-        cookies = {
-        'ASP.NET_SessionId': 'p2fk5silp5mjgtx0j5chjrh3',
-        }
         ik = tivu[id]
         headers = {
             'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0',
@@ -162,11 +159,11 @@ async def tivu_get(id,client):
             'Pragma': 'no-cache',
             'Cache-Control': 'no-cache',
         }
-    
         data = {
             'ik': ik
         }
-        response = await client.post('https://www.tivu.tv/getPrograms.ashx', cookies=cookies, headers=headers, data=data)
+
+        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()

Src/API/filmpertutti.py

@@ -9,6 +9,7 @@ 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 = {
@@ -122,6 +123,7 @@ async def filmpertutti(imdb,client):
         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:
@@ -135,6 +137,7 @@ async def filmpertutti(imdb,client):
         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)
@@ -156,6 +159,8 @@ async def test_animeworld():
 if __name__ == "__main__":
     import asyncio
     asyncio.run(test_animeworld())
+
+
 '''
 
 
@@ -163,8 +168,6 @@ if __name__ == "__main__":
 
 
 
-
-
 '''
     series_response = await client.get(link, headers=headers, follow_redirects=True)
         series_soup = BeautifulSoup(series_response.text, 'lxml')

Src/API/lordchannel.py

@@ -31,7 +31,6 @@ async def search(showname,date,season,episode,ismovie,client):
         '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']:
@@ -99,13 +98,14 @@ async def lordchannel(imdb,client):
         return None,None
     
 
-
+'''
-#async def test_animeworld():
+async def test_animeworld():
     async with httpx.AsyncClient() as client:
-        results = await lordchannel("tt6468322:1:1",client)
+        results = await lordchannel("tt14134334:1:1",client)
         print(results)
 
-#if __name__ == "__main__":
+if __name__ == "__main__":
     import httpx
     import asyncio
     asyncio.run(test_animeworld())  
+    '''

Src/API/okru.py

@@ -5,14 +5,18 @@ from Src.Utilities.dictionaries import okru
 
 
 async def okru_get_url(id,client):
-    embed_link = okru[id]
+    try:
-    print(embed_link)
+        embed_link = okru[id]
-    response = await client.get(embed_link, allow_redirects=True, impersonate = "chrome120")
+        print(embed_link)
-    soup = BeautifulSoup(response.text, 'lxml')
+        response = await client.get(embed_link, allow_redirects=True, impersonate = "chrome120")
-    div = soup.find('div', {'data-module': 'OKVideo'})
+        soup = BeautifulSoup(response.text, 'lxml')
-    data_options = div.get('data-options')
+        div = soup.find('div', {'data-module': 'OKVideo'})
-    data = json.loads(data_options)
+        data_options = div.get('data-options')
-    metadata = json.loads(data['flashvars']['metadata'])
+        data = json.loads(data_options)
-    m3u8_link = metadata['hlsMasterPlaylistUrl']
+        metadata = json.loads(data['flashvars']['metadata'])
-    print("MammaMia: Found results for Okru")
+        m3u8_link = metadata['hlsMasterPlaylistUrl']
-    return m3u8_link
+        print("MammaMia: Found results for Okru")
+        return m3u8_link
+    except Exception as e:
+        print("MammaMia: No results found for Okru")
+        return None

Src/API/streamingcommunity.py

@@ -8,6 +8,8 @@ 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
@@ -22,8 +24,8 @@ async def get_version(client):
 
     try:
         random_headers = headers.generate()
-        random_headers['Referer'] = "https://streamingcommunity.buzz/"
+        random_headers['Referer'] = f"https://streamingcommunity.{SC_DOMAIN}/"
-        random_headers['Origin'] = "https://streamingcommunity.buzz"
+        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
@@ -41,8 +43,10 @@ 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,impersonate = "chrome120")
+    response = await client.get(query, headers = random_headers, allow_redirects=True)
     print(response)
     response = response.json()
 
@@ -228,6 +232,7 @@ async def streaming_community(imdb,client,SC_FAST_SEARCH):
                         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)
@@ -250,7 +255,7 @@ 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 = "tt16288804:1:1"  # This is an example ID format
+        test_id = "tt12930350"  # This is an example ID format
         results = await streaming_community(test_id, client,"0")
 
 if __name__ == "__main__":

Src/API/streamingwatch.py

@@ -4,9 +4,18 @@ 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}',
@@ -28,7 +37,7 @@ async def search(showname,season,episode,date,ismovie,client):
         data = {
             'action': 'data_fetch',
             'keyword': showname,
-            '_wpnonce': '648328b831',
+            '_wpnonce': wponce,
         }
         cookies = {
              'wordpress_test_cookie': 'WP%20Cookie%20check',
@@ -54,7 +63,7 @@ async def search(showname,season,episode,date,ismovie,client):
         data_json = response.text
         data = json.loads(data_json)
         for entry in data:
-            if f"stagione-{season}-episodio-{episode}" in entry["slug"]:
+            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}
@@ -91,8 +100,21 @@ async def streamingwatch(imdb,client):
        showname = showname.replace(" ", "+").replace("–", "+").replace("—","+")
        hdplayer = await search(showname,season,episode,date,ismovie,client)
        url = await hls_url(hdplayer,client)
-       print("MammaMia: StreamingWatch found results for StreamingCommunity")
+       print(f"MammaMia: StreamingWatch found results for {showname}")
        return url
-    except:
+    except Exception as e:
-          print("MammaMia: StreamingWatch Failed")
+          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

@@ -8,9 +8,10 @@ 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']

Src/API/webru.py

@@ -1,6 +1,7 @@
 import random
+from bs4 import BeautifulSoup,SoupStrainer
 import Src.Utilities.config as config
-from Src.Utilities.dictionaries import webru_vary,webru_dlhd
+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')
@@ -41,7 +42,20 @@ async def webru(id,site,client):
         mediaproxy = config.MediaProxy
         medialink = random.choice(mediaproxy)
         new_stream_url = f'{medialink}proxy/hls?key_url=https%3A%2F%2Fkey.mizhls.ru%2F&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'
+        print(new_stream_url)
         return new_stream_url
     except Exception as e:
         print("WebRu failed",e)
         return None
+    
+
+
+async def get_skystreaming(id,client):
+    skystreaming_link =  skystreaming[id]
+    response =  await client.get(skystreaming_link, headers=headers, allow_redirects=True, impersonate = "chrome120")
+    soup = BeautifulSoup(response.text, 'lxml', parse_only=SoupStrainer('source'))
+    m3u8_url = soup.get('src')
+    start = m3u8_url.find('//') + 2
+    end = m3u8_url.find('/', start)
+    Host = m3u8_url[start:end]
+    return m3u8_url,Host

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/dictionaries.py

@@ -836,7 +836,31 @@ extra_sources = {
     "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"]
 }
-
+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",
+}
 provider_map = {
         'SC': 'STREAMINGCOMMUNITY',
         'SC_FS': 'SC_FAST_SEARCH',

Src/Utilities/info.py

@@ -46,6 +46,16 @@ def get_info_tmdb(tmbda,ismovie,type):
             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()
@@ -82,6 +92,16 @@ def get_info_tmdb(tmbda,ismovie,type):
             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')
@@ -107,6 +127,16 @@ async def get_info_imdb(imdb_id, ismovie, type,client):
                 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']
@@ -126,6 +156,17 @@ async def get_info_imdb(imdb_id, ismovie, type,client):
             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}'

config.json

@@ -1,34 +1,33 @@
 {
-    "Siti": {
+  "Siti": {
-           "StreamingCommunity": {
+         "StreamingCommunity": {
-               "domain": "buzz"
+             "domain": "buzz"
-           },
+         },
-           "Filmpertutti": {
+         "Filmpertutti": {
-               "domain": "diy"
+             "domain": "diy"
-           },
+         },
-           "Tantifilm":{
+         "Tantifilm":{
-               "domain": "bond"
+             "domain": "bond"
-           },
+         },
-           "Mysterius":{
+         "Mysterius":{
-               "enabled": "0"    
+             "enabled": "0"    
-           },
+         },
-          "LordChannel":{
+        "LordChannel":{
-               "domain":"com"
+             "domain":"com"
-          },
+        },
-          "StreamingWatch":{
+        "StreamingWatch":{
-              "domain":"org"
+            "domain":"org"
-          },
+        },
-          "AnimeWorld":{
+        "AnimeWorld":{
-              "domain":"so"
+            "domain":"so"
-          }
+        }
-   },
+ },
-   "General":{
+ "General":{
-       "load_env": "0",
+     "load_env": "1",
-       "HOST": "0.0.0.0",
+     "HOST": "0.0.0.0",
-       "PORT": "8080",
+     "PORT": "8080",
-       "HF": "1",
+     "HF": "0",
-       "Public_Instance": "0",
+     "Public_Instance": "0",
-       "MediaProxy": ["https://putinputout-newmediaflow-proxy.hf.space/"]
+     "MediaProxy": ["test"]
-   }
+ }
-   }
+}
-   

run.py

@@ -9,9 +9,9 @@ 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
+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
+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
@@ -75,6 +75,9 @@ def config():
 @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.get('/', response_class=HTMLResponse)
 def root(request: Request):
@@ -174,7 +177,7 @@ async def addon_stream(request: Request,config, type, id,):
                     if 'url' in channel:
                         i = i+1
                         streams['streams'].append({
-                            'title': f"Server {i} " + f" "+ channel['name'] + " " + channel['title'] ,
+                            'title': f"{HF}Server {i} " + f" "+ channel['name'] + " " + channel['title'] ,
                             'url': channel['url']
                             })    
                     if id in okru:
@@ -188,11 +191,16 @@ async def addon_stream(request: Request,config, type, id,):
                         list_sources = extra_sources[id]
                         for item in list_sources:
                             i = i+1
-                            streams['streams'].append({'title':f"Server {i} " + channel['title'],'url': item})
+                            streams['streams'].append({'title':f"{HF}Server {i} " + channel['title'],'url': item})
+                    if id in skystreaming:
+                        i = i+1
+                        url, host = get_skystreaming(id,client)
+                        streams['streams'].append({'title': f'{HF}Server {i}', 'url': url,  'behaviorHints': {'proxyHeaders': {"request": {"Referer": "https://skystreaming.guru/", "Origin": "https://skystreaming.guru", "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36", "Accept": "*/*", "Accept-Language": "it-IT,it;q=0.9", "Host": host}}, 'notWebReady': True}})
+
                     if id in webru_vary:
                         i = i+1
                         webru_url = await webru(id,"vary",client)
-                        streams['streams'].append({'title': f"Server {i} " + channel['title'],'url': webru_url})
+                        streams['streams'].append({'title': f"{HF}Server {i} " + channel['title'],'url': webru_url})
             if not streams['streams']:
                 raise HTTPException(status_code=404)
             return respond_with(streams)