mmas 2.5.6__tar.gz

mmas-2.5.6/API/Hianime/anicli.py

@@ -0,0 +1,204 @@
+import requests
+import re
+import base64
+import json
+
+from playwright.sync_api import sync_playwright as spw
+from bs4 import BeautifulSoup
+from urllib.parse import quote, urljoin, unquote
+
+
+OBF_KEY = b'otaku-embed-v1'
+
+def _xor_bytes(data: bytes) -> bytes:
+    return bytes(b ^ OBF_KEY[i % len(OBF_KEY)] for i, b in enumerate(data))
+
+def deobfuscate(blob: str) -> dict:
+    raw = base64.b64decode(unquote(blob))
+    return json.loads(_xor_bytes(raw).decode('utf-8'))
+
+class EpisodeUnavailableError(ValueError):
+    """MAL asked for an episode hianime doesn't have."""
+BASE = "https://hianime.at"
+SEARCH_URL = BASE + "/search?keyword={}"
+UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:155.0) "
+    "Gecko/20100101 Firefox/155.0")
+
+session = requests.Session()
+session.headers.update({
+    "User-Agent": UA,
+    "Accept": "application/json, text/plain, */*",
+    "X-Requested-With": "XMLHttpRequest",
+    "Referer": "https://hianime.at/",
+})
+
+def searchAnime(query: str) -> list:
+    url = SEARCH_URL.format(quote(query))
+    response = session.get(url, timeout=20)
+    response.raise_for_status()
+
+    soup = BeautifulSoup(response.text, "html.parser")
+    results = []
+
+    for item in soup.select(".film_list-wrap .flw-item, .film_list-wrap .film-poster-ahref"):
+        link = item.select_one("a[href]")
+        title = item.select_one(".film-name, .dynamic-name, [title]")
+        if not link:
+            continue
+
+        href = urljoin(BASE, link.get("href"))
+        name = (
+            title.get("title")
+            if title and title.get("title")
+            else title.get_text(" ", strip=True) if title else href
+        )
+
+        results.append({
+            "title": name,
+            "url": href
+        })
+    return results
+
+def chooseAnime(query:str) -> str:
+
+    results = searchAnime(query)
+
+    if not results:
+        raise RuntimeError(f"no results for {query!r}")
+
+    for index, anime in enumerate(results, start=1):
+        print(f"{index}. {anime['title']}")
+
+    while True:
+        raw = input(f"Pick a number (1-{len(results)}): ").strip()
+        if not raw.isdigit():
+            print("Not a number, try again")
+            continue
+        choice = int(raw)
+        if 1 <= choice <= len(results):
+            return results[choice - 1]["url"]
+        print(f"Out of range, pick between 1 and {len(results)}.")
+
+def getAnimeId(watchUrl):
+
+    m = re.search(r"-(\d+)(?:\?|$)", watchUrl)
+    if not m:
+        raise ValueError(f"no anime id in {watchUrl!r}")
+    
+    return int(m.group(1))
+
+def getEpisodes(watchUrl: str) -> list:
+    aId = getAnimeId(watchUrl)
+    r = session.get(f"{BASE}/api/theme/episode/list/{aId}",
+                    headers={"Referer": BASE + "/"})
+    r.raise_for_status()
+
+    data = r.json()
+
+    if not data.get("status"):
+        raise RuntimeError(f"episode list returned status=false: {data}")
+
+    soup = BeautifulSoup(data["html"], "html.parser")
+    episodes =[]
+    for a in soup.select("a.ssl-item.ep-item"):
+        episodes.append({
+            "number":   int(a["data-number"]),
+            "id":       int(a["data-id"]),
+            "url":      urljoin(BASE,a["href"]),
+        })
+    return episodes
+
+def pickServer(html: str, serverName: str = "ZokoAnime", kind: str = "sub") -> str:
+    soup = BeautifulSoup(html, "html.parser")
+    for item in soup.select(".server-item"):
+        if item.get("data-type") != kind:
+            continue
+        if item.get("data-server-name", "").strip() != serverName:
+                    continue
+        raw = item.get("data-hash")
+        if not raw:
+            continue
+        return base64.b64decode(raw).decode("utf-8")
+    raise ValueError(f"server {serverName!r} ({kind}) not found")
+
+def getServer(eId:int) -> str:
+
+    r = session.get(
+        "https://hianime.at/api/theme/episode/servers",
+        params={"episodeId": eId},
+        headers={"Referer": "https://hianime.at/"},
+    )
+
+    r.raise_for_status()
+    data = r.json()
+    if not data.get("status"):
+        raise RuntimeError(f"servers endpoint returned status = false: {data}")
+    return data["html"]
+
+def getEnglishSub(embedUrl: str) -> str | None:
+    r = session.get(embedUrl, headers={"Referer": BASE + "/"}, timeout=20)
+    m = re.search(r'window\.__P\s*=\s*"([^"]+)"', r.text)
+    if not m:
+        return None
+    config = deobfuscate(m.group(1))
+    for s in config.get("subtitles", []):
+        if s.get("label", "").strip().lower() == "english":
+            return s["src"]
+    return None
+
+def getM3u8(embedUrl: str, tout:int = 30000) ->tuple  :
+    master= {}
+    referer = {}
+    subUrl = getEnglishSub(embedUrl)
+
+    with spw() as p:
+        browser = p.chromium.launch(headless=True)
+        ctx = browser.new_context(user_agent=UA)
+        page = ctx.new_page()
+
+        def onResp(resp):
+            url = resp.url
+            if "master.m3u8" in url and "master" not in master:
+                master["master" ] = url
+                try:
+                    headers= resp.request.headers
+                    if "referer" in headers:
+                        referer["referer"] = headers["referer"]
+                except Exception:
+                    pass
+
+        page.on("response", onResp)
+        page.goto(embedUrl, wait_until="networkidle", timeout=tout)
+        page.wait_for_timeout(3000)
+        browser.close()
+
+        if "master" not in master:
+            raise RuntimeError("master.m3u8 not captured. Video player embed may have changed")
+        return (master["master"], referer.get("referer", "https://megacloud.tv/"), subUrl)
+
+
+
+
+
+        
+def primeSession(query: str, ep: int,  type: str = "sub", watchUrl: str = None) -> tuple :
+    if watchUrl is None:
+        watchUrl = chooseAnime(query)
+
+    episodes = getEpisodes(watchUrl)
+    firstEp = episodes[0]['id']
+    lastEp = episodes[-1]['number']
+    if ep > lastEp:
+        raise EpisodeUnavailableError(
+            f"{ep} does not exist in Hianime. This is the case if:\n"
+            "  1. You have finished the Anime — check the MAL episode counter.\n"
+            "  2. The Anime is still airing and this episode hasn't released yet.\n"
+            "  3. The episode exists but hianime hasn't uploaded it yet."
+        )
+    ep = ep-1
+    
+        
+    embed = pickServer(getServer(firstEp+ep), "ZokoAnime", type)
+    master, referer, subUrl = getM3u8(embed)
+
+    return master, referer, subUrl

mmas-2.5.6/API/MD/requests.py

@@ -0,0 +1,137 @@
+import json
+import requests
+import os
+import time
+import subprocess
+import re
+from config import manga_folder, mpv_path, JsonIO
+from pathlib import Path
+
+
+class MangaDexAPI:
+    def __init__(self, lang="en"):
+        self.base_url = "https://api.mangadex.org"
+        self.lang = lang
+
+    def search_manga(self, title, limit):
+
+        order = {
+            "relevance": "desc",
+        }
+        final_order_query = {}
+
+        for key,value in order.items():
+            final_order_query[f"order[{key}]"] = value
+
+        r = requests.get(
+            f"{self.base_url}/manga",
+            params={
+                **{
+                    "title": title,
+                    "limit": limit
+                },
+                **final_order_query,
+            })
+        return r
+    def get_chapters(self, offset):
+        with open(JsonIO / "filteredList.json", "r") as f:
+            data = json.load(f)
+            ID = data[0]["id"]
+            r = requests.get(
+                f"{self.base_url}/manga/{ID}/feed",
+                params={
+                    "translatedLanguage[]": ["en"],
+                    "order[chapter]": "asc",
+                    "limit": 1,
+                    "offset": offset
+                    
+                }
+            )
+            chapters = r.json()
+        if chapters:
+            
+            chapter_id = chapters ["data"][0]["id"]
+        else: print("x")
+        
+        rd = requests.get(
+            f"{self.base_url}/at-home/server/{chapter_id}"
+        )
+        rd.raise_for_status
+        
+        data= rd.json()
+        baseUrl = data["baseUrl"]
+        hash = data["chapter"]["hash"]
+        file_names = data["chapter"]["data"]
+        
+        folder = os.path.join(manga_folder, f'chapter_{chapter_id[:8]}')
+        os.makedirs(folder, exist_ok=True)
+
+        start_time = time.time()
+        
+        for i, file_name in enumerate(file_names, 1):
+            url = f"{baseUrl}/data/{hash}/{file_name}"
+            response = requests.get(url)
+            response.raise_for_status()
+            
+            file_path = os.path.join(folder, f"page_{i}.jpg")
+            with open(file_path, "wb") as f:
+                f.write(response.content)
+                
+        elapsed = time.time() - start_time
+        print(f"Downloaded pages in {elapsed:.2f} seconds")
+    
+        print(folder)
+        return folder
+        
+
+    def simple_maga_id(self, title, rp):
+        data = rp
+
+        filtered = []
+        for manga in data['data']:
+            attrs = manga['attributes']
+            has_english = (
+                attrs.get('title', {}).get('en') or
+                any(alt.get('en') for alt in attrs.get('altTitles', [])) or
+                attrs.get('description', {}).get('en')
+            )
+            if has_english:
+                simplified = {
+                    "id": manga['id'],
+                    "title": attrs.get('title', {}),
+                    "altTitles": attrs.get('altTitles', []),
+                    "lastChapter": attrs.get('lastChapter'),
+                    "status": attrs.get('status'),
+                    "availableTranslatedLanguages": attrs.get('availableTranslatedLanguages', [])
+                }
+                filtered.append(simplified)
+
+        if filtered:
+            etitles = [filtered[0]['title'].get('en')] + [alt.get('en') for alt in filtered[0]['altTitles'] if alt.get('en')]
+            
+            if title in etitles:
+                filtered = [filtered[0]]
+
+        with open(JsonIO / "filteredList.json", "w") as f:
+            json.dump(filtered, f, indent=2)
+            
+    def load_manga(self, title, chapter):
+        response = self.search_manga(title, 5)
+        print(self.simple_maga_id(title, response.json()))
+        
+        manga_path = Path(self.get_chapters(chapter))
+        image_files = [f for f in Path(manga_path).iterdir() if f.suffix.lower() in ('.jpg', '.jpeg', '.png')]
+        if not image_files:
+            print(f"No Manga downloaded. Check if Chapter {chapter} has an english translated chapter on Mangadex")
+            return None
+        else:
+            images = sorted(image_files, key=lambda x: int(re.search(r'\d+', x.stem).group()))
+            mpv_process=subprocess.Popen([
+                mpv_path,
+                "--fs",
+                "--keep-open=no",
+                "--image-display-duration=inf",
+                *[str(img) for img in images]
+            ])
+
+            return manga_path, mpv_process

mmas-2.5.6/API/Mal/auth.py

@@ -0,0 +1,195 @@
+import base64
+import json
+import os
+import secrets
+import threading
+import time
+import webbrowser
+
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlencode, urlparse, parse_qs
+
+import requests
+
+from config import EKEY, TOKEN_PATH, get_client_id
+
+
+AUTH_URL             = "https://myanimelist.net/v1/oauth2/authorize"
+TOKEN_URL            = "https://myanimelist.net/v1/oauth2/token"
+REDIRECT_URI         = "http://localhost:8080/callback"
+PORT = 8080
+REFRESH_WARN_SECONDS   = 24 * 3600 # pretty much the time when you should refresh your tokens.
+
+def _load_tokens() -> dict | None:
+    if not TOKEN_PATH.exists():
+        return None
+    try:
+        blob = TOKEN_PATH.read_bytes()
+        return json.loads(EKEY.decrypt(blob).decode())
+    except Exception:
+        return None
+
+def _save_tokens(data: dict) -> None:
+    blob = EKEY.encrypt(json.dumps(data).encode())
+    TOKEN_PATH.write_bytes(blob)
+    try:
+        os.chmod(TOKEN_PATH, 0o600)
+    except OSError:
+        pass
+
+
+
+def _b64_url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
+
+def _new_pkce_pair() -> tuple[str, str]:
+    verifier    = _b64_url(secrets.token_bytes(64))
+    return verifier, verifier
+
+class _CallBackHandler(BaseHTTPRequestHandler):
+    captured:dict = {}
+
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        if parsed.path != urlparse(REDIRECT_URI).path:
+            self.send_response(404); self.end_headers(); return
+
+        params = parse_qs(parsed.query)
+        _CallBackHandler.captured = {
+            "code" : params.get("code" , [None])[0],
+            "state": params.get("state", [None])[0],
+            "error": params.get("error", [None])[0],
+        }
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.end_headers()
+        self.wfile.write(b"<h2>You can close this tab and return to the terminal.</h2>")
+
+        threading.Thread(target=self.server.shutdown, daemon=True).start()
+
+    def log_message(self, *a, **k):
+        pass
+
+def _wait_for_callback(timeout: int = 300) -> dict:
+    _CallBackHandler.captured = {}
+    server = ThreadingHTTPServer(("127.0.0.1", PORT), _CallBackHandler)
+    server.timeout = timeout
+
+    t = threading.Thread(target=server.serve_forever, daemon=True)
+    t.start()
+    t.join(timeout)
+    server.server_close()
+    return _CallBackHandler.captured
+
+
+def run_oauth_flow(no_browser:bool = False) -> dict:
+    verifier, challenge = _new_pkce_pair()
+    state = _b64_url(secrets.token_bytes(16))
+    client_id = get_client_id()
+
+    params = {
+        "response_type": "code",
+        "client_id": client_id,
+        "redirect_uri": REDIRECT_URI,
+        "code_challenge": challenge,
+        "code_challenge_method": "plain",
+        "state": state,
+    }
+    url = f"{AUTH_URL}?{urlencode(params)}"
+
+    if no_browser:
+        print(f"Open the following URL in your browser (on any machine):\n {url} \nAfter authorizing, MAL will redirect to {REDIRECT_URI} \n",
+              "which won't load. Copy the 'code=' value out of the URL bar and paste it here.")
+        code = input("code: ").strip()
+    else:
+        print("Opening browser for MAL authorization...")
+        webbrowser.open(url)
+        captured = _wait_for_callback()
+        if captured.get("error"):
+            raise RuntimeError(f"OAuth error: {captured['error']}")
+        if captured.get("state") != state:
+            raise RuntimeError("state mismatch, possible CSRF, aborting")
+        code = captured.get("code")
+
+    if not code:
+        raise RuntimeError("No authorization code received")
+
+    r = requests.post(
+        TOKEN_URL,
+        auth=(client_id, ""),
+        data={
+            "grant_type":       "authorization_code",
+            "code":             code,
+            "redirect_uri":     REDIRECT_URI,
+            "code_verifier":    verifier,
+        }
+    )
+    r.raise_for_status()
+    tok = r.json()
+    tok["verifier"]         = verifier
+    tok["obtained_at"]       = time.time()
+    tok["refresh_obtained_at"]= time.time()
+    tok["access_expires_at"]  = time.time() + tok["expires_in"]
+    tok["refresh_expires_at"] = time.time() + tok.get("refresh_token_expires_in", 30*24*3600)
+    _save_tokens(tok)
+    return tok
+
+def _refresh_tokens(tok: dict) -> dict:
+    client_id    = get_client_id()
+    r           = requests.post(
+        TOKEN_URL,
+        auth=(client_id, ""),
+        data={
+        "grant_type":       "refresh_token",
+        "refresh_token":    tok["refresh_token"],
+    })
+    if r.status_code == 400 and "invalid_grant" in r.text:
+        raise RuntimeError("refresh token expired. Reauthorize yourself")
+        
+    r.raise_for_status()
+    new = r.json()
+
+    new["verifier"]         =tok.get("verifier", "")
+    new["obtained_at"]       = time.time()
+    new["refresh_obtained_at"]= time.time()
+    new["access_expires_at"]  = time.time() + new["expires_in"]
+    new["refresh_expires_at"] = time.time() + new.get("refresh_token_expires_in", 30*24*3600)
+    _save_tokens(new)
+    return new
+
+def get_access_token(interactive: bool = True) -> str:
+    tok= _load_tokens()
+
+    if tok is None:
+        if not interactive:
+            raise RuntimeError("No tokens and not allowed to run OAuth flow")
+        tok = run_oauth_flow()
+
+    if time.time() > tok["access_expires_at"] - 300:
+        try:
+            tok = _refresh_tokens(tok)
+        except RuntimeError:
+            if not interactive:
+                raise
+            print("Refresh token expired. Re-authorizing...")
+            tok = run_oauth_flow()
+
+    elif time.time() > tok["refresh_expires_at"] - REFRESH_WARN_SECONDS:
+        try:
+            tok = _refresh_tokens(tok)
+        except RuntimeError:
+            if not interactive:
+                raise
+            print("Refresh token expired. Re-authorizing...")
+            tok = run_oauth_flow()
+    return tok["access_token"]
+
+
+
+
+
+
+
+
+
+

mmas-2.5.6/API/Mal/manage.py

@@ -0,0 +1,308 @@
+import json
+import subprocess
+import time
+import re
+import shutil
+
+from pathlib import Path
+
+from API.Mal.requests import reqMal
+from API.MD.requests import MangaDexAPI as reqMd
+from API.Hianime.anicli import primeSession, searchAnime as hianimeSearch
+from config import mpv_path, JsonIO, hianime_urls
+
+class ManageMal:
+    """This handles all the shared Logic"""
+
+    def __repr__(self):
+        media = getattr(self, "media", None)
+        return f"{type(self).__name__}(media={media!r})"
+    
+    MEDIA:      str
+    COUNT_FIELD:str
+    UNIT:       str
+    VERB:       str
+
+    def __init__(self):
+        if self.MEDIA is None:
+            raise TypeError(f"{type(self).__name__} mnust define MEDIA")
+        self.media  = self.MEDIA
+        self.mal    = reqMal(self.MEDIA)
+        self.list_path    = JsonIO / f"{self.media}List.json"
+        self.titles_path  = JsonIO / f"{self.media}EnTitles.json"
+
+    def get_all_en_titles(self):
+        if not self.list_path.exists():
+            self.mal.get_list()
+        if not self.list_path.exists():
+            raise RuntimeError(f"{self.list_path} was not created.")
+
+        with open(self.list_path, "r") as f:
+            data = json.load(f)
+
+        new_data = {
+            "media":        self.media,
+            "fetched_at":   time.time(),
+            "entries":      {},
+        }
+
+        for entry in data["data"]:
+            node    = entry["node"]
+            data_id = node["id"]
+            titles  = node["alternative_titles"]
+            status_dict  = node["my_list_status"]
+
+            all_titles = []
+            en      = titles.get("en")
+            synonyms= titles.get("synonyms")
+
+            if en:
+                all_titles.append(en)
+            if synonyms:
+                all_titles.extend(synonyms)
+
+            count   = status_dict.get(self.COUNT_FIELD, 0)
+            status  = status_dict.get("status")
+
+            new_data["entries"][data_id] = {
+                "type":             self.media, #purely for readability
+                "id":               data_id,
+                "titles":           all_titles,
+                "main_title":       node["title"],
+                self.COUNT_FIELD:   count,
+                "status":           status,
+            }
+        with open(self.titles_path, "w") as f:
+            json.dump(new_data, f, indent=2)
+
+    def search_data(self, query: str):
+        if not self.titles_path.exists():
+            self.get_all_en_titles()
+        if not self.titles_path.exists():
+            raise RuntimeError("English titles file missing and/or not created.")
+
+        with open(self.titles_path,"r") as f:
+            root = json.load(f)
+
+        if root:
+            time_stamp = root["fetched_at"]
+            if time.time() - time_stamp > 86400:
+                print("data out of date, getting new")
+                self.get_all_en_titles()
+                with open(self.titles_path, "r") as f:
+                    root = json.load(f)
+
+        entries = root["entries"]
+
+
+        results = []
+
+        for info in entries.values():
+            all_titles = info["titles"] + [info["main_title"]]
+            if any(query.lower() in t.lower() for t in all_titles):
+                results.append(info)
+        if results:
+            return results
+
+        print(f"{query} not found in your list.")
+        answer = input("Continue search outside of your list? [y/n]: ").strip().lower()
+
+        if answer == "y":
+            remote = self.mal.look_up_entry(query)
+            for info in remote.values():
+                all_titles = info["titles"] + [info["main_title"]]
+                if any(query.lower() in t.lower() for t in all_titles):
+                    results.append(info)
+            if results:
+                return results
+            return []
+
+        if answer == "n":
+            print("Okay, exiting")
+            return []
+
+        print("Unknown answer, exiting")
+        return []
+
+    def search_match(self, query, mode: str = ""):
+        result = self.choose_mal(query)
+        if result is None:
+            print(f"Check if '{query}' is in your MAL list.")
+            return
+
+        mal_id      = result["id"]
+        mal_title   = result["main_title"]
+        number      = result[self.COUNT_FIELD] + 1
+
+        while True:
+            played = self._play(mal_title, mal_id, number, mode)
+            if played is None:
+                break
+
+            response = input(
+                f"Did you finish {self.UNIT.lower()} {number}? [y/n]: "
+            ).strip().lower()
+
+            if response == "y":
+                print("Updating MAL status...")
+                time.sleep(1)
+                if self.mal.update_mal(mal_id, number):
+                    print("Updated list.")
+                else: 
+                    print("MAL rejected the update")
+
+                ask_next = input(
+                    f"Continue with {self.UNIT} {number + 1}? [y/n] "
+                ).strip().lower()
+                if ask_next == "y":
+                    number += 1
+                    continue
+                print("Goodbye.")
+                break
+            if response == "n":
+                print(f"{self.UNIT} not finished. No changes saved.")
+                break
+            print("Invalid input.")
+            break
+
+
+    def choose_mal(self, query):
+        results = self.search_data(query)
+        if not results:
+            print("No results")
+            return None
+
+        for i, info in enumerate(results, start=1):
+            print(f"{i}. {info['main_title']} ({self.VERB}: {info[self.COUNT_FIELD]})")
+
+        while True:
+            raw = input(f"Pick a number (1-{len(results)}): ").strip()
+            if not raw.isdigit():
+                print("Not a number, try again.")
+                continue
+            choice = int(raw)
+
+            if 1 <= choice <= len(results):
+                return results[choice-1]
+            print(f"Out of range. Pick between 1 and {len(results)}!")
+
+class ManageAnime(ManageMal):
+    """Subclass to handle any Anime related call"""
+
+    MEDIA       = "anime"
+    COUNT_FIELD = "num_episodes_watched"
+    UNIT        = "Episode"
+    VERB        = "Watched"
+
+    def _play(self, mal_title:str, mal_id:int, number:int, mode:str = ""):
+        watch_url = self.resolve_hianime_watch_url(mal_title, mal_id)
+        print(f"Loading {mal_title}, Episode {number} in {mode}")
+
+        try:
+            master, referer, sub_url = primeSession(
+                mal_title, number, mode, watchUrl=watch_url
+            )
+        except Exception as e:
+            print(f"Failed to prime session: {e}")
+            return None
+        mpv_args = [
+            mpv_path,
+            "--fs",
+            "--keep-open=no",
+            f"--http-header-fields=Referer: {referer}",
+            "--sid=auto",
+            "--slang=en,eng,english",
+            "--sub-file-paths=", 
+            "--cache=yes",
+            "--force-window=yes",
+            "--demuxer-max-bytes=100MiB",
+            master,
+        ]
+        if sub_url:
+            mpv_args.append(f"--sub-file={sub_url}")
+            mpv_args.append(f"--sid=1")
+
+        mpv_process = subprocess.Popen(mpv_args)
+        mpv_process.wait()
+        return True
+
+
+    def resolve_hianime_watch_url(self, mal_title:str, mal_id):
+        """Search Hianime by the MAL title"""
+        cache_path  = hianime_urls
+        key         = str(mal_id)
+
+        cache = {}
+
+        if cache_path.exists():
+            try:
+                with open(cache_path) as f:
+                    cache = json.load(f)
+            except (json.JSONDecodeError, OSError):
+                cache = {}
+        if key in cache:
+            return cache[key]
+
+
+        hits = hianimeSearch(mal_title)
+        if not hits:
+            raise RuntimeError(f"Hianime has no results for {mal_title!r}")
+
+        def _norm(s):
+            return re.sub(r"[^a-z0-9]+", "", s.lower())
+
+        target = _norm(mal_title)
+        exact = [h for h in hits if _norm(h["title"]) == target]
+        if len(exact) == 1:
+            print(f"Using Hianime match: {exact[0]['title']}")
+            url = exact[0]['url']
+
+        elif len(hits) == 1:
+            print(f"Using Hianime match: {hits[0]['title']}")
+            url = hits[0]['url']
+        else:
+            for i, h in enumerate(hits, start=1):
+                print(f"{i}. {h['title']}")
+
+            while True: 
+                raw = input(f"Pick a Hianime result (1-{len(hits)})").strip()
+                if not raw.isdigit():
+                    print("Not a number, try again.")
+                    continue
+                choice = int(raw)
+                if 1 <= choice <= len(hits):
+                    url = hits[choice - 1]["url"]
+                    break
+                print(f"Out of range, pick between 1 and {len(hits)}.")
+        cache[key] = url
+        with open(cache_path, "w") as f:
+            json.dump(cache, f, indent=2)
+
+        return url
+
+class ManageManga(ManageMal):
+    """Subclass to handle any MAnga related call"""
+
+    MEDIA       = "manga"
+    COUNT_FIELD = "num_chapters_read"
+    UNIT        = "Chapter"
+    VERB        = "Read"
+
+    def __init__(self):
+        super().__init__()
+        self.md = reqMd()
+
+
+
+    def _play(self, mal_title, mal_id, number, mode):
+        print(f"Loading {mal_title}, Chapter {number}")
+        folder, proc =  self.md.load_manga(mal_title, number)
+
+        if proc is None:
+            return None
+
+        try:
+            proc.wait()
+        finally:
+            shutil.rmtree(folder, ignore_erros = True)
+        return True

mmas-2.5.6/API/Mal/requests.py

@@ -0,0 +1,102 @@
+import requests
+import json
+import time
+
+from API.Mal.auth import get_access_token
+from config import JsonIO
+from pathlib import Path
+
+
+class reqMal():
+
+
+    def __init__(self, media_type:str):
+        if media_type not in ("anime", "manga"):
+            raise ValueError(
+                f"I made a mistake in the code. Please report it. "
+                f"Unknown mediaType: {media_type!r}"
+            )
+        
+        if media_type == "manga":
+                self.ce_unit, self.rw_unit = "chapters", "read"
+        else:   self.ce_unit, self.rw_unit =  "episodes",  "watched" 
+
+        self.media = media_type
+        self.url = "https://api.myanimelist.net/v2"
+
+    def __repr__(self):
+        return f"reqMal(media={self.media!r})"
+
+    def _auth_headers(self):
+        return {"Authorization": f"Bearer {get_access_token()}"}
+
+    def get_list(self):
+        r=requests.get(f"{self.url}/users/@me/{self.media}list",
+                    headers=self._auth_headers(),
+                    params={
+                        "sort":f"{self.media}_title",
+                        "fields": "alternative_titles, my_list_status",
+                        "limit": 200,
+                    }
+                )
+        r.raise_for_status()
+
+        with open(JsonIO / f"{self.media}List.json", "w") as f:
+            json.dump(r.json(),f,indent=2)
+        print(f"Successfully fetched {len(r.json()['data'])} {self.media} entries")
+        return r.json()
+
+    def look_up_entry(self, query):
+        """Search up entries not found in User's active list """
+        r = requests.get(
+            f"{self.url}/{self.media}",
+            headers=self._auth_headers(),
+            params={
+                "q": query,
+                "limit": 10,
+                "fields": "alternative_titles,my_list_status"
+            },
+        )
+        r.raise_for_status()
+        data = {}
+        for entry in r.json()["data"]:
+            node    = entry["node"]
+            alt     = node.get("alternative_titles", {})
+            status  = node.get("my_list_status") or {}
+            data_id = node["id"]
+
+            all_titles = []
+            if alt.get("en"):
+                all_titles.append(alt["en"])
+            all_titles.extend(alt.get("synonyms", []))
+
+            count_field  = f"num_{self.ce_unit}_{self.rw_unit}"
+            count       = status.get(count_field, 0)
+            kind = ""
+            if self.media == "anime":
+                kind =  "episodesWatched"
+            else: kind ="chaptersRead"
+
+            data[data_id] = {
+                "id":       data_id,
+                "titles":   all_titles,
+                "mainTitle":entry["node"]["title"],
+                kind:       count,
+                "status":   status.get("status"),
+                "fetchedAt":time.time()
+            }
+
+
+        return data
+
+    def update_mal(self, mal_id, progress):
+        r = requests.patch(
+            f"{self.url}/{self.media}/{mal_id}/my_list_status",
+            headers=self._auth_headers(),
+            data={
+                f"num_{self.ce_unit}_{self.rw_unit}": progress,
+            }
+        )
+
+        r.raise_for_status()
+        return r.ok

mmas-2.5.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luca Barthel
+
+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.

mmas-2.5.6/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: mmas
+Version: 2.5.6
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: cryptography>=39.0.0
+Requires-Dist: platformdirs>=4.11.0
+Requires-Dist: playwright>=1.63.0
+Requires-Dist: beautifulsoup4>=4.15.0
+Dynamic: license-file
+Dynamic: requires-dist

mmas-2.5.6/browserSetup.py

@@ -0,0 +1,15 @@
+import subprocess
+import sys
+
+from pathlib import Path
+
+def main():
+    """Download Playwright browsers for the mmas tool."""
+    print("Downloading Playwright browsers (this may take a few minutes)...")
+    try:
+        subprocess.check_call([sys.executable, "-m", "playwright", "install"])
+        print("Playwright browsers installed successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to install Playwright browsers: {e}")
+        print("This tool needs Playwright browsers. You can retry manually with: playwright install")
+        sys.exit(1)

mmas-2.5.6/config.py

@@ -0,0 +1,72 @@
+import os 
+import shutil
+
+from pathlib import Path
+from cryptography.fernet import Fernet
+from platformdirs import user_config_dir, user_data_dir
+
+APP_NAME    = "mmas"    #MangaMalAniSearch
+APP_AUTHOR = "Lucman00"
+
+CONFIG_DIR   = Path(user_config_dir(APP_NAME,APP_AUTHOR))
+DATA_DIR     = Path(user_data_dir(APP_NAME, APP_AUTHOR))
+CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+EKEY_PATH    = CONFIG_DIR / "fernet.key"
+CID_PATH     = CONFIG_DIR / "clientID" #might not even need this. who knows
+TOKEN_PATH   = CONFIG_DIR / "token.json"
+
+def _load_or_create_ekey() -> Fernet:
+    if EKEY_PATH.exists():
+        key = EKEY_PATH.read_bytes().strip()
+    else:
+        key=Fernet.generate_key()
+        EKEY_PATH.write_bytes(key)
+        try:
+            os.chmod(EKEY_PATH, 0o600)
+        except OSError:
+            pass #pov non unix system
+    return Fernet(key)
+
+EKEY = _load_or_create_ekey() #runs at config time. startup.
+
+bakedCliId = "1edac3e5b806a5eae0321f45ef7951e9"
+
+def get_client_id() -> str:
+    if CID_PATH.exists():
+        return CID_PATH.read_text().strip()
+    return bakedCliId
+
+
+manga_folder = str(DATA_DIR / "manga")
+Path(manga_folder).mkdir(parents=True, exist_ok=True)
+JsonIO = Path(DATA_DIR) / "JsonIO"
+Path(JsonIO).mkdir(parents=True, exist_ok=True)
+hianime_urls = Path(DATA_DIR) / "JsonIO" / "hianime_urls.json"
+
+
+
+def find_mpv():
+    path = shutil.which("mpv")
+    if path:
+        return path
+    
+    if os.name == "nt": 
+        winget_base = Path(os.environ.get("LOCALAPPDATA", "")) / "Microsoft" / "WinGet" / "Links"
+        print(winget_base)
+        if winget_base.exists():
+            for mpv_exe in winget_base.rglob("mpv.exe"):
+                print(mpv_exe)
+                return Path(mpv_exe)
+    return None
+
+
+
+mpv_path = find_mpv()
+
+if mpv_path == None:
+    raise RuntimeError("mpv not found on PATH.\n"
+        "  Windows: winget install mpv, then make sure its folder is on PATH\n"
+        "  macOS:   brew install mpv\n"
+        "  Linux:   sudo apt install mpv (or your package manager)")

mmas-2.5.6/main.py

@@ -0,0 +1,54 @@
+import sys
+import os
+import click
+
+from pathlib import Path
+
+from API.Mal.manage import ManageAnime as MA
+from API.Mal.manage import ManageManga as MM
+
+@click.group()
+def cli():
+    """Manga/Anime searcher and Cli tool integration"""
+    pass
+
+@cli.command(help="Search anime or manga by Title. Use --type (-t) to decide the Audio track. This only applies to Anime")
+@click.argument('title')
+@click.argument ('mediatype',
+                type =click.Choice(['manga','anime'],
+                case_sensitive=False))
+@click.option('--type', '-t',
+                'aType',
+                type=click.Choice(['sub','dub'], case_sensitive=False),
+                default='sub',
+                show_default=True,
+                help="Audio track for anime (ignored for manga). ")
+
+# @click.option('--jp', '-japanese',
+#             type=click)
+# Consideration is adding japanese manga. haven't found any source yet.
+
+def search(title, mediatype, aType):
+    """Search anime or manga by Title"""
+
+    
+    if mediatype.lower() == "manga":
+        print(f"Searching for Manga titled {title}")
+        MM().search_match(title)
+    elif mediatype.lower() == "anime": 
+        print(f"Searching for Anime titled {title} in {aType}")
+        MA().search_match(title, aType)
+    else :
+        print("How did we get here? https://c.tenor.com/omyuVB-fnjMAAAAd/tenor.gif")
+
+
+@cli.command()
+@click.option("--nobrowser", "-N", is_flag=True, help="Print URL and paste code manually")
+def login(nobrowser):
+    """Authenticate with MAL (runs automatically on first use)"""
+    from API.Mal.auth import run_oauth_flow
+    run_oauth_flow(nobrowser)
+    click.echo("Authenticated")
+
+if __name__ == '__main__':
+    cli()

mmas-2.5.6/mmas.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: mmas
+Version: 2.5.6
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: cryptography>=39.0.0
+Requires-Dist: platformdirs>=4.11.0
+Requires-Dist: playwright>=1.63.0
+Requires-Dist: beautifulsoup4>=4.15.0
+Dynamic: license-file
+Dynamic: requires-dist

mmas-2.5.6/mmas.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+browserSetup.py
+config.py
+main.py
+setup.py
+API/__init__.py
+API/Hianime/__init__.py
+API/Hianime/anicli.py
+API/MD/__init__.py
+API/MD/requests.py
+API/Mal/__init__.py
+API/Mal/auth.py
+API/Mal/manage.py
+API/Mal/requests.py
+mmas.egg-info/PKG-INFO
+mmas.egg-info/SOURCES.txt
+mmas.egg-info/dependency_links.txt
+mmas.egg-info/entry_points.txt
+mmas.egg-info/requires.txt
+mmas.egg-info/top_level.txt

mmas-2.5.6/mmas.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mmas-2.5.6/mmas.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+mmas = main:cli
+mmas-setup = browserSetup:main

mmas-2.5.6/mmas.egg-info/requires.txt

@@ -0,0 +1,6 @@
+click>=8.0.0
+requests>=2.28.0
+cryptography>=39.0.0
+platformdirs>=4.11.0
+playwright>=1.63.0
+beautifulsoup4>=4.15.0

mmas-2.5.6/mmas.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+API
+browserSetup
+config
+main

mmas-2.5.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mmas-2.5.6/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='mmas',
+    version='2.5.6',
+    packages=find_packages(),
+    py_modules=['main', 'config', 'browserSetup'],
+    install_requires=[
+        'click>=8.0.0',
+        'requests>=2.28.0',
+        'cryptography>=39.0.0',
+        'platformdirs>=4.11.0',
+        'playwright>=1.63.0',
+        'beautifulsoup4>=4.15.0',
+    ],
+    entry_points={
+        'console_scripts': [
+            'mmas=main:cli',
+            'mmas-setup=browserSetup:main'
+        ],
+    },
+    include_package_data=True,
+)