diff --git a/M3U8/fetch.py b/M3U8/fetch.py index 4a2918b..b85a58c 100644 --- a/M3U8/fetch.py +++ b/M3U8/fetch.py @@ -6,7 +6,6 @@ from pathlib import Path from scrapers import ( fawa, istreameast, - lotus, pixel, ppv, roxie, @@ -17,8 +16,8 @@ from scrapers import ( streamhub, streamsgate, strmd, + time4tv, tvpass, - watchfooty, webcast, ) from scrapers.utils import get_logger, network @@ -50,7 +49,6 @@ async def main() -> None: tasks = [ asyncio.create_task(fawa.scrape()), asyncio.create_task(istreameast.scrape()), - asyncio.create_task(lotus.scrape()), asyncio.create_task(pixel.scrape()), asyncio.create_task(ppv.scrape()), asyncio.create_task(roxie.scrape()), @@ -61,8 +59,8 @@ async def main() -> None: asyncio.create_task(streamhub.scrape()), asyncio.create_task(streamsgate.scrape()), asyncio.create_task(strmd.scrape()), + asyncio.create_task(time4tv.scrape()), asyncio.create_task(tvpass.scrape()), - # asyncio.create_task(watchfooty.scrape()), asyncio.create_task(webcast.scrape()), ] @@ -71,7 +69,6 @@ async def main() -> None: additions = ( fawa.urls | istreameast.urls - | lotus.urls | pixel.urls | ppv.urls | roxie.urls @@ -82,8 +79,8 @@ async def main() -> None: | streamfree.urls | streamhub.urls | streamsgate.urls + | time4tv.urls | tvpass.urls - | watchfooty.urls | webcast.urls ) diff --git a/M3U8/scrapers/lotus.py b/M3U8/scrapers/lotus.py deleted file mode 100644 index cc7e1a2..0000000 --- a/M3U8/scrapers/lotus.py +++ /dev/null @@ -1,138 +0,0 @@ -from functools import partial - -from playwright.async_api import async_playwright - -from .utils import Cache, Time, get_logger, leagues, network - -log = get_logger(__name__) - -urls: dict[str, dict[str, str | float]] = {} - -TAG = "LOTUS" - -CACHE_FILE = Cache(f"{TAG.lower()}.json", exp=5_400) - -API_CACHE = Cache(f"{TAG.lower()}-api.json", exp=28_800) - -BASE_URL = "https://lotusgamehd.xyz/api-event.php" - - -def fix_league(s: str) -> str: - return " ".join(x.capitalize() for x in s.split()) if len(s) > 5 else s.upper() - - -async def get_events(cached_keys: list[str]) -> list[dict[str, str]]: - now = Time.clean(Time.now()) - - if not (api_data := API_CACHE.load(per_entry=False)): - api_data = {} - - if r := await network.request(BASE_URL, log=log): - api_data: dict = r.json() - - api_data["timestamp"] = now.timestamp() - - API_CACHE.write(api_data) - - events = [] - - for info in api_data.get("days", []): - event_dt = Time.from_str(info["day_et"], timezone="ET") - - if now.date() != event_dt.date(): - continue - - for event in info["items"]: - if (event_league := event["league"]) == "channel tv": - continue - - sport = fix_league(event_league) - - event_name = event["title"] - - if f"[{sport}] {event_name} ({TAG})" in cached_keys: - continue - - event_streams: list[dict[str, str]] = event["streams"] - - if not (event_link := event_streams[0].get("link")): - continue - - events.append( - { - "sport": sport, - "event": event_name, - "link": event_link, - "timestamp": now.timestamp(), - } - ) - - return events - - -async def scrape() -> None: - cached_urls = CACHE_FILE.load() - - cached_count = len(cached_urls) - - urls.update(cached_urls) - - log.info(f"Loaded {cached_count} event(s) from cache") - - log.info(f'Scraping from "{BASE_URL}"') - - events = await get_events(cached_urls.keys()) - - log.info(f"Processing {len(events)} new URL(s)") - - if events: - async with async_playwright() as p: - browser, context = await network.browser(p) - - for i, ev in enumerate(events, start=1): - handler = partial( - network.process_event, - url=ev["link"], - url_num=i, - context=context, - log=log, - ) - - url = await network.safe_process( - handler, - url_num=i, - log=log, - ) - - if url: - sport, event, link, ts = ( - ev["sport"], - ev["event"], - ev["link"], - ev["timestamp"], - ) - - tvg_id, logo = leagues.get_tvg_info(sport, event) - - key = f"[{sport}] {event} ({TAG})" - - entry = { - "url": url, - "logo": logo, - "base": "https://vividmosaica.com/", - "timestamp": ts, - "id": tvg_id or "Live.Event.us", - "link": link, - } - - urls[key] = cached_urls[key] = entry - - await browser.close() - - if new_count := len(cached_urls) - cached_count: - log.info(f"Collected and cached {new_count} new event(s)") - - else: - log.info("No new events found") - - CACHE_FILE.write(cached_urls) diff --git a/M3U8/scrapers/time4tv.py b/M3U8/scrapers/time4tv.py new file mode 100644 index 0000000..f84fafc --- /dev/null +++ b/M3U8/scrapers/time4tv.py @@ -0,0 +1,138 @@ +import re +from functools import partial +from urllib.parse import urljoin + +from playwright.async_api import async_playwright +from selectolax.parser import HTMLParser + +from .utils import Cache, Time, get_logger, leagues, network + +log = get_logger(__name__) + +urls: dict[str, dict[str, str | float]] = {} + +TAG = "TIME4TV" + +CACHE_FILE = Cache(f"{TAG.lower()}.json", exp=5_400) + +BASE_URL = "https://time4tv.icu/" + + +def fix_league(s: str) -> str: + return " ".join(x.capitalize() for x in s.split()) if len(s) > 5 else s.upper() + + +async def get_events(cached_keys: list[str], now: Time) -> dict[dict[str, str]]: + events = [] + + if not (html_data := await network.request(BASE_URL, log=log)): + return events + + pattern = re.compile(r"openPlayerPopup\(\s*(\d+)\s*\)", re.IGNORECASE) + + soup = HTMLParser(html_data.content) + + for row in soup.css(".wrap .row"): + if not (date := row.css_first(".date")): + continue + + event_date = date.text(strip=True).replace("\t", " ") + + try: + event_dt = Time.from_str(event_date, fmt="%m/%d/%Y %I:%M %p") + except ValueError: + continue + + if event_dt.date() != now.date(): + continue + + league = row.css_first(".league") + + title = row.css_first(".title") + + hds_a = row.css_first(".hds a") + + if not (league and title and hds_a): + continue + + sport, event = fix_league(league.text(strip=True)), title.text(strip=True) + + if f"[{sport}] {event} ({TAG})" in cached_keys: + continue + + onclick = hds_a.attributes.get("onclick", "") + + if not (match := pattern.search(onclick)): + continue + + events.append( + { + "sport": sport, + "event": event, + "link": urljoin(BASE_URL, f"player1.php?{match[1]}"), + } + ) + + return events + + +async def scrape() -> None: + cached_urls = CACHE_FILE.load() + + cached_count = len(cached_urls) + + urls.update(cached_urls) + + log.info(f"Loaded {cached_count} event(s) from cache") + + log.info(f'Scraping from "{BASE_URL}"') + + now = Time.clean(Time.now()) + + events = await get_events(cached_urls.keys(), now) + + log.info(f"Processing {len(events)} new URL(s)") + + async with async_playwright() as p: + browser, context = await network.browser(p) + + for i, ev in enumerate(events, start=1): + handler = partial( + network.process_event, + url=ev["link"], + url_num=i, + context=context, + log=log, + ) + + url = await network.safe_process( + handler, + url_num=i, + log=log, + ) + + if url: + sport, event = ev["sport"], ev["event"] + + tvg_id, logo = leagues.info(sport) + + key = f"[{sport}] {event} ({TAG})" + + entry = { + "url": url, + "logo": logo, + "base": "https://vividmosaica.com/", + "timestamp": now.timestamp(), + "id": tvg_id or "Live.Event.us", + } + + urls[key] = cached_urls[key] = entry + + await browser.close() + + if new_count := len(cached_urls) - cached_count: + log.info(f"Collected and cached {new_count} new event(s)") + else: + log.info("No new events found") + + CACHE_FILE.write(cached_urls) diff --git a/M3U8/scrapers/utils/config.py b/M3U8/scrapers/utils/config.py index e0062a1..c940864 100644 --- a/M3U8/scrapers/utils/config.py +++ b/M3U8/scrapers/utils/config.py @@ -89,23 +89,22 @@ class Time(datetime): else: formats = [ + "%B %d, %Y %H:%M", "%B %d, %Y %I:%M %p", "%B %d, %Y %I:%M:%S %p", - "%m/%d/%Y %I:%M %p", - "%B %d, %Y %H:%M", "%B %d, %Y %H:%M:%S", "%Y-%m-%d", "%Y-%m-%d %H:%M", "%Y-%m-%d %H:%M:%S", - "%Y-%m-%d %H:%M %p", "%Y-%m-%d %I:%M %p", + "%Y-%m-%d %H:%M %p", "%Y/%m/%d %H:%M", "%Y/%m/%d %H:%M:%S", - "%m/%d/%Y %H:%M", - "%m/%d/%Y %H:%M:%S", "%Y-%m-%dT%H:%M:%S", "%Y/%m/%dT%H:%M:%S.%fZ", - "%Y-%m-%dT%H:%M:%S.%fZ", + "%m/%d/%Y %H:%M", + "%m/%d/%Y %I:%M %p", + "%m/%d/%Y %H:%M:%S", "%a, %d %b %Y %H:%M:%S %z", ] diff --git a/M3U8/scrapers/watchfooty.py b/M3U8/scrapers/watchfooty.py deleted file mode 100644 index 5b0a3df..0000000 --- a/M3U8/scrapers/watchfooty.py +++ /dev/null @@ -1,315 +0,0 @@ -import asyncio -import re -from functools import partial -from itertools import chain -from typing import Any -from urllib.parse import urljoin - -from playwright.async_api import BrowserContext, async_playwright - -from .utils import Cache, Time, get_logger, leagues, network - -log = get_logger(__name__) - -urls: dict[str, dict[str, str | float]] = {} - -TAG = "WATCHFTY" - -CACHE_FILE = Cache(f"{TAG.lower()}.json", exp=10_800) - -API_FILE = Cache(f"{TAG.lower()}-api.json", exp=19_800) - -API_URL = "https://api.watchfooty.st" - -BASE_MIRRORS = [ - "https://www.watchfooty.top", - "https://www.watchfooty.st", - "https://www.watchfooty.su", -] - -VALID_SPORTS = [ - "american-football", - # "australian-football", - # "baseball", - "basketball", - # "cricket", - # "darts", - "fighting", - "football", - "golf", - "hockey", - "racing", - # "rugby", - # "tennis", - # "volleyball", -] - - -async def refresh_api_cache(now: Time) -> list[dict[str, Any]]: - log.info("Refreshing API cache") - - tasks = [ - network.request( - urljoin(API_URL, "api/v1/matches/all"), - log=log, - params={"date": d.date()}, - ) - for d in [now, now.delta(days=1)] - ] - - results = await asyncio.gather(*tasks) - - if not (data := [*chain.from_iterable(r.json() for r in results if r)]): - return [] - - for ev in data: - ev["ts"] = ev.pop("timestamp") - - data[-1]["timestamp"] = now.timestamp() - - return data - - -async def process_event( - url: str, - url_num: int, - context: BrowserContext, -) -> str | None: - - pattern = re.compile(r"\((\d+)\)") - - page = await context.new_page() - - captured: list[str] = [] - - got_one = asyncio.Event() - - handler = partial( - network.capture_req, - captured=captured, - got_one=got_one, - ) - - page.on("request", handler) - - try: - await page.goto( - url, - wait_until="domcontentloaded", - timeout=15_000, - ) - - await page.wait_for_timeout(2_000) - - try: - header = await page.wait_for_selector( - "text=/Stream Links/i", - timeout=5_000, - ) - - text = await header.inner_text() - except TimeoutError: - log.warning(f"URL {url_num}) Can't find stream links header.") - - return - - if not (match := pattern.search(text)) or int(match[1]) == 0: - log.warning(f"URL {url_num}) No available stream links.") - - return - - try: - first_available = await page.wait_for_selector( - 'a[href*="/stream/"]', - timeout=3_000, - ) - except TimeoutError: - log.warning(f"URL {url_num}) No available stream links.") - - return - - if not (href := await first_available.get_attribute("href")): - log.warning(f"URL {url_num}) No available stream links.") - - return - - await page.goto( - href, - wait_until="domcontentloaded", - timeout=5_000, - ) - - wait_task = asyncio.create_task(got_one.wait()) - - try: - await asyncio.wait_for(wait_task, timeout=6) - except asyncio.TimeoutError: - log.warning(f"URL {url_num}) Timed out waiting for M3U8.") - - return - - finally: - if not wait_task.done(): - wait_task.cancel() - - try: - await wait_task - except asyncio.CancelledError: - pass - - if captured: - log.info(f"URL {url_num}) Captured M3U8") - - return captured[-1] - - log.warning(f"URL {url_num}) No M3U8 captured after waiting.") - - return - - except Exception as e: - log.warning(f"URL {url_num}) Exception while processing: {e}") - - return - - finally: - page.remove_listener("request", handler) - - await page.close() - - -async def get_events(base_url: str, cached_keys: list[str]) -> list[dict[str, str]]: - now = Time.clean(Time.now()) - - if not (api_data := API_FILE.load(per_entry=False, index=-1)): - api_data = await refresh_api_cache(now) - - API_FILE.write(api_data) - - events = [] - - pattern = re.compile(r"\-+|\(") - - start_dt = now.delta(minutes=-30) - end_dt = now.delta(minutes=5) - - for event in api_data: - match_id = event.get("matchId") - - name = event.get("title") - - league = event.get("league") - - if not (match_id and name and league): - continue - - if event["sport"] not in VALID_SPORTS: - continue - - sport = pattern.split(league, 1)[0].strip() - - if f"[{sport}] {name} ({TAG})" in cached_keys: - continue - - if not (ts := event.get("ts")): - continue - - start_ts = float(f"{ts}"[:-3]) - - event_dt = Time.from_ts(start_ts) - - if not start_dt <= event_dt <= end_dt: - continue - - logo = urljoin(API_URL, poster) if (poster := event.get("poster")) else None - - events.append( - { - "sport": sport, - "event": name, - "link": urljoin(base_url, f"stream/{match_id}"), - "logo": logo, - "timestamp": event_dt.timestamp(), - } - ) - - return events - - -async def scrape() -> None: - cached_urls = CACHE_FILE.load() - - valid_urls = {k: v for k, v in cached_urls.items() if v["url"]} - - valid_count = cached_count = len(valid_urls) - - urls.update(valid_urls) - - log.info(f"Loaded {cached_count} event(s) from cache") - - if not (base_url := await network.get_base(BASE_MIRRORS)): - log.warning("No working Watch Footy mirrors") - - CACHE_FILE.write(cached_urls) - - return - - log.info(f'Scraping from "{base_url}"') - - events = await get_events(base_url, cached_urls.keys()) - - log.info(f"Processing {len(events)} new URL(s)") - - if events: - async with async_playwright() as p: - browser, context = await network.browser(p, browser="external") - - for i, ev in enumerate(events, start=1): - handler = partial( - process_event, - url=ev["link"], - url_num=i, - context=context, - ) - - url = await network.safe_process( - handler, - url_num=i, - log=log, - ) - - sport, event, logo, ts, link = ( - ev["sport"], - ev["event"], - ev["logo"], - ev["timestamp"], - ev["link"], - ) - - key = f"[{sport}] {event} ({TAG})" - - tvg_id, pic = leagues.get_tvg_info(sport, event) - - entry = { - "url": url, - "logo": logo or pic, - "base": base_url, - "timestamp": ts, - "id": tvg_id or "Live.Event.us", - "link": link, - } - - cached_urls[key] = entry - - if url: - valid_count += 1 - urls[key] = entry - - await browser.close() - - if new_count := valid_count - cached_count: - log.info(f"Collected and cached {new_count} new event(s)") - - else: - log.info("No new events found") - - CACHE_FILE.write(cached_urls)