freeflix-cli 1.0.0__py3-none-any.whl

freeflix_cli/anilist.py

@@ -0,0 +1,207 @@
+import json
+from curl_cffi import requests
+from typing import Optional, Dict, Any, List
+
+
+class AniListClient:
+    def __init__(self, token: Optional[str] = None):
+        self.url = "https://graphql.anilist.co"
+        self.token = token
+        self.headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        if self.token:
+            self.headers["Authorization"] = f"Bearer {self.token}"
+
+    def set_token(self, token: str):
+        """Set the authorization token."""
+        self.token = token
+        self.headers["Authorization"] = f"Bearer {token}"
+
+    def _query(
+        self, query: str, variables: Dict[str, Any] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Send a GraphQL query to AniList."""
+        try:
+            response = requests.post(
+                self.url,
+                json={"query": query, "variables": variables},
+                headers=self.headers,
+                timeout=10,
+            )
+            response.raise_for_status()
+            data = response.json()
+            if "errors" in data:
+                print(f"AniList API Error: {data['errors']}")
+                return None
+            return data["data"]
+        except Exception as e:
+            print(f"Request Error: {e}")
+            return None
+
+    def validate_token(self) -> Optional[Dict[str, Any]]:
+        """Check if the current token is valid and return user info."""
+        query = """
+        query {
+            Viewer {
+                id
+                name
+                avatar {
+                    large
+                }
+            }
+        }
+        """
+        data = self._query(query)
+        if data and data.get("Viewer"):
+            return data["Viewer"]
+        return None
+
+    def search_media(self, search: str) -> List[Dict[str, Any]]:
+        """Search for an anime/manga by title."""
+        query = """
+        query ($search: String) {
+            Page(page: 1, perPage: 10) {
+                media(search: $search, type: ANIME, sort: SEARCH_MATCH) {
+                    id
+                    title {
+                        romaji
+                        english
+                        native
+                    }
+                    coverImage {
+                        medium
+                    }
+                    format
+                    episodes
+                    status
+                    seasonYear
+                }
+            }
+        }
+        """
+        variables = {"search": search}
+        data = self._query(query, variables)
+        if data and data.get("Page") and data.get("Page", {}).get("media"):
+            return data["Page"]["media"]
+        return []
+
+    def get_media_status(self, media_id: int, user_id: int) -> Optional[Dict[str, Any]]:
+        """Get the user's current status for a specific media."""
+        query = """
+        query ($mediaId: Int, $userId: Int) {
+            MediaList(mediaId: $mediaId, userId: $userId) {
+                id
+                status
+                progress
+                score
+            }
+        }
+        """
+        variables = {"mediaId": media_id, "userId": user_id}
+        # Note: MediaList returns 404/null if not found, we need to handle that gracefully
+        try:
+            data = self._query(
+                query, variables
+            )  # This might fail if not found depending on API behavior
+            if data:
+                return data.get("MediaList")
+        except Exception:
+            pass
+        return None
+
+    def update_progress(self, media_id: int, progress: int) -> bool:
+        """Update the progress for a media item. Also sets status to CURRENT if not already."""
+        query = """
+        mutation ($mediaId: Int, $progress: Int, $status: MediaListStatus) {
+            SaveMediaListEntry(mediaId: $mediaId, progress: $progress, status: $status) {
+                id
+                progress
+                status
+            }
+        }
+        """
+        # We enforce status to CURRENT whenever we update progress,
+        # unless it's already completed (logic could be refined)
+        variables = {"mediaId": media_id, "progress": progress, "status": "CURRENT"}
+        data = self._query(query, variables)
+        return data is not None and "SaveMediaListEntry" in data
+
+    def get_user_watching(self, user_id: int) -> List[Dict[str, Any]]:
+        """Get the user's current watching list."""
+        query = """
+        query ($userId: Int) {
+            MediaListCollection(userId: $userId, type: ANIME, status: CURRENT, sort: UPDATED_TIME_DESC) {
+                lists {
+                    entries {
+                        mediaId
+                        progress
+                        media {
+                            title {
+                                romaji
+                                english
+                            }
+                            coverImage {
+                                medium
+                            }
+                            format
+                            episodes
+                            seasonYear
+                        }
+                    }
+                }
+            }
+        }
+        """
+        variables = {"userId": user_id}
+        data = self._query(query, variables)
+        if (
+            data
+            and data.get("MediaListCollection")
+            and data["MediaListCollection"].get("lists")
+        ):
+            # Flatten lists (there should be only one for CURRENT usually, but structure is a list of lists)
+            entries = []
+            for lst in data["MediaListCollection"]["lists"]:
+                entries.extend(lst.get("entries", []))
+            return entries
+        return []
+
+    def get_media_with_relations(self, media_id: int) -> Optional[Dict[str, Any]]:
+        """Get media details including episode count and relations (sequels)."""
+        query = """
+        query ($mediaId: Int) {
+            Media(id: $mediaId) {
+                id
+                title {
+                    romaji
+                    english
+                }
+                episodes
+                relations {
+                    edges {
+                        relationType
+                        node {
+                            id
+                            title {
+                                romaji
+                                english
+                            }
+                            episodes
+                            format
+                        }
+                    }
+                }
+            }
+        }
+        """
+        variables = {"mediaId": media_id}
+        data = self._query(query, variables)
+        if data and data.get("Media"):
+            return data["Media"]
+        return None
+
+
+# Global instance
+anilist_client = AniListClient()

freeflix_cli/cli_utils.py

@@ -0,0 +1,191 @@
+import os
+import readchar
+import re
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.text import Text
+from rich.live import Live
+from rich import print as rprint
+
+console = Console()
+
+
+def clear_screen():
+    """Clear the terminal screen."""
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+def get_user_input(prompt: str, default: str = None) -> str:
+    """
+    Get user input with a styled prompt.
+
+    Args:
+        prompt: The prompt text to display
+        default: The default value to display
+
+    Returns:
+        The user's input as a string
+    """
+    styled_prompt = Text(f"\n❯ {prompt}: ", style="bold cyan")
+    console.print(styled_prompt, end="")
+    return input().strip() or default
+
+
+def pause():
+    """Wait for user input before continuing."""
+    console.input("\n[dim]Press Enter to continue...[/dim]")
+
+
+def select_from_list(options: list[str], prompt: str, default_index: int = 0) -> int:
+    """
+    Display an interactive menu where users can navigate with arrow keys.
+
+    Args:
+        options: List of options to display
+        prompt: Header text for the menu
+        default_index: Index to select by default
+
+    Returns:
+        Index of the selected option (0-based)
+    """
+    selected_index = max(0, min(default_index, len(options) - 1))
+    start_index = 0
+
+    def generate_renderable():
+        nonlocal start_index
+
+        # Calculate dynamic window size based on terminal height
+        term_height = console.size.height
+        # Reserve lines for prompt (2), header/spacing (2), arrows (2) -> ~6 lines reserve
+        reserved_lines = 6
+        available_height = max(3, term_height - reserved_lines)
+        window_size = min(len(options), available_height)
+
+        # Adjust start_index to keep selected_index in view
+        if selected_index < start_index:
+            start_index = selected_index
+        elif selected_index >= start_index + window_size:
+            start_index = selected_index - window_size + 1
+
+        # Ensure start_index is valid
+        start_index = max(0, min(start_index, len(options) - window_size))
+        end_index = min(len(options), start_index + window_size)
+
+        lines = [Text(f"\n❯ {prompt}", style="bold cyan")]
+
+        # Up arrow indicator
+        if start_index > 0:
+            lines.append(Text("  ↑ ...", style="dim"))
+
+        for idx in range(start_index, end_index):
+            option = options[idx]
+            if idx == selected_index:
+                lines.append(Text(f"  ● {option}", style="green bold"))
+            else:
+                lines.append(Text(f"    {option}", style="white"))
+
+        # Down arrow indicator
+        if end_index < len(options):
+            lines.append(Text("  ↓ ...", style="dim"))
+
+        return Group(*lines)
+
+    with Live(generate_renderable(), refresh_per_second=10, transient=True) as live:
+        while True:
+            key = readchar.readkey()
+
+            if key == readchar.key.UP:
+                selected_index = (selected_index - 1) % len(options)
+                live.update(generate_renderable())
+            elif key == readchar.key.DOWN:
+                selected_index = (selected_index + 1) % len(options)
+                live.update(generate_renderable())
+            elif key == readchar.key.ENTER:
+                break
+            elif key == readchar.key.CTRL_C:
+                raise KeyboardInterrupt("Menu cancelled by user")
+
+    console.print(
+        f"\n[bold cyan]❯ {prompt}[/bold cyan] [green]{options[selected_index]}[/green]"
+    )
+    return selected_index
+
+
+def print_header(text: str):
+    """
+    Print a styled header with a decorative panel.
+
+    Args:
+        text: Header text to display
+    """
+    console.print()
+    panel = Panel(
+        Text(text, style="bold white", justify="center"),
+        style="cyan",
+        border_style="bright_cyan",
+        padding=(0, 2),
+    )
+    console.print(panel)
+
+
+def print_success(message: str):
+    """
+    Print a success message with a green checkmark.
+
+    Args:
+        message: Success message to display
+    """
+    console.print(f"[green]✓[/green] {message}")
+
+
+def print_error(message: str):
+    """
+    Print an error message with a red X.
+
+    Args:
+        message: Error message to display
+    """
+    console.print(f"[red]✗[/red] {message}")
+
+
+def print_info(message: str):
+    """
+    Print an info message with a blue icon.
+
+    Args:
+        message: Info message to display
+    """
+    console.print(f"[blue]ℹ[/blue] {message}")
+
+
+def print_warning(message: str):
+    """
+    Print a warning message with a yellow icon.
+
+    Args:
+        message: Warning message to display
+    """
+    console.print(f"[yellow]⚠[/yellow] {message}")
+
+
+def clean_title(title: str) -> str:
+    """
+    Remove season and part indicators from a title to help with search.
+    Example: "One Piece Season 4" -> "One Piece"
+    """
+    # Remove Season X, S2, Part 2, etc. (case insensitive)
+    # Common patterns: Season 1, S1, Part 1, Cour 1, etc.
+    patterns = [
+        r"\s+Season\s+\d+",
+        r"\s+S\d+",
+        r"\s+Part\s+\d+",
+        r"\s+Cour\s+\d+",
+        r"\s+\d+(st|nd|rd|th)\s+Season",
+        r"\s+-\s+\d+",  # Sometimes title - 2
+    ]
+
+    cleaned = title
+    for pattern in patterns:
+        cleaned = re.sub(pattern, "", cleaned, flags=re.IGNORECASE)
+
+    return cleaned.strip()

freeflix_cli/config_loader.py

@@ -0,0 +1,62 @@
+import json
+import re
+from curl_cffi import requests
+
+
+def strip_json_comments(json_str: str) -> str:
+    """
+    Remove // and /* */ comments from JSON string.
+    """
+    # Remove // comments
+    json_str = re.sub(r"(?<!:)\/\/.*$", "", json_str, flags=re.MULTILINE)
+    # Remove /* */ comments
+    json_str = re.sub(r"\/\*.*?\*\/", "", json_str, flags=re.DOTALL)
+    return json_str
+
+
+def strip_trailing_commas(json_str: str) -> str:
+    """
+    Remove trailing commas from JSON objects and arrays.
+    """
+    return re.sub(r",\s*([\]}])", r"\1", json_str)
+
+
+def load_remote_jsonc(url: str, default: dict) -> dict:
+    """
+    Fetch a remote JSONC file, strip comments, and parse it.
+    Returns the default dictionary if fetching or parsing fails.
+    """
+    try:
+        response = requests.get(url, impersonate="chrome", timeout=5)
+        response.raise_for_status()
+
+        clean_json = strip_json_comments(response.text)
+        clean_json = strip_trailing_commas(clean_json)
+
+        return json.loads(clean_json)
+    except Exception as e:
+        print(f"Warning: Failed to load remote config from {url}: {e}")
+        return default
+
+
+def load_local_jsonc(file_path: str, default: dict = None) -> dict:
+    """
+    Load a local JSONC file, strip comments, and parse it.
+    Returns default if the file is missing or invalid.
+    """
+    import os
+
+    if not os.path.exists(file_path):
+        return default or {}
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        clean_json = strip_json_comments(content)
+        clean_json = strip_trailing_commas(clean_json)
+
+        return json.loads(clean_json)
+    except Exception as e:
+        print(f"Warning: Failed to load local config from {file_path}: {e}")
+        return default or {}

freeflix_cli/defaults.py

@@ -0,0 +1,150 @@
+# Default configurations acting as fallback
+# These values are used if remote configuration cannot be loaded
+
+DEFAULT_PLAYERS = {
+    "wishonly": {
+        "type": "default",
+        "referrer": "full",
+        "alt-used": True,
+        "sec_headers": "Sec-Fetch-Dest:empty;Sec-Fetch-Mode:cors;Sec-Fetch-Site:cross-site;Content-Cache: no-cache",
+        "mode": "proxy",
+    },
+    "hgbazooka": {"type": "default"},
+    "hailindihg": {"type": "default"},
+    "gradehgplus": {"type": "default"},
+    "taylorplayer": {"type": "default"},
+    "vidmoly": {"type": "vidmoly"},
+    # "oneupload": {"type": "default"},
+    "tipfly": {"type": "default"},
+    # "luluvdoo": {
+    #     "type": "b",
+    #     "sec_headers": "Sec-Fetch-Dest:empty;Sec-Fetch-Mode:cors;Sec-Fetch-Site:cross-site",
+    # },
+    # "luluvdo": {
+    #     "type": "b",
+    #     "sec_headers": False,
+    # },
+    # "lulustream": {
+    #     "type": "b",
+    #     "sec_headers": "Sec-Fetch-Dest:empty;Sec-Fetch-Mode:cors;Sec-Fetch-Site:cross-site",
+    # },
+    "ups2up": {"type": "default"},
+    "ico3c": {"type": "default"},
+    "fsvid": {"type": "default", "m3u8-extractor": {"no-header": True}},
+    "darkibox": {"type": "default"},
+    "minochinos": {"type": "default"},
+    "movearnpre": {
+        "type": "default",
+        "referrer": "full",
+        "alt-used": False,
+        "sec_headers": "Sec-Fetch-Dest:empty;Sec-Fetch-Mode:cors;Sec-Fetch-Site:same-origin",
+    },
+    "smoothpre": {
+        "type": "default",
+        "referrer": "full",
+        "alt-used": True,
+        "sec_headers": "Sec-Fetch-Dest:empty;Sec-Fetch-Mode:cors;Sec-Fetch-Site:cross-site;Content-Cache: no-cache",
+        "mode": "proxy",
+    },
+    "vidhideplus": {"type": "default"},
+    "dinisglows": {
+        "type": "default",
+        "referrer": "full",
+        "alt-used": True,
+        "sec_headers": "Sec-Fetch-Dest:empty;Sec-Fetch-Mode:cors;Sec-Fetch-Site:same-origin",
+    },
+    "mivalyo": {"type": "default"},
+    "dingtezuni": {"type": "default"},
+    "bingezove": {"type": "default"},
+    "vidzy": {"type": "default"},
+    "ok.ru": {"type": "default"},
+    "videzz": {
+        "type": "vidoza",
+        "mode": "proxy",
+        "no-header": True,
+        "ext": "mp4",
+    },
+    "vidoza": {
+        "type": "vidoza",
+        "mode": "proxy",
+        "no-header": True,
+        "ext": "mp4",
+    },
+    "sendvid": {"type": "sendvid", "mode": "proxy", "ext": "mp4"},
+    "sibnet": {
+        "type": "sibnet",
+        "mode": "proxy",
+        "ext": "mp4",
+        "referrer": "full",
+        "no-header": True,
+    },
+    "uqload": {
+        "type": "uqload",
+        "sec_headers": "Sec-Fetch-Dest:video;Sec-Fetch-Mode:no-cors;Sec-Fetch-Site:same-site",
+        "ext": "mp4",
+    },
+    "filemoon": {
+        "type": "filemoon",
+        "referrer": "https://ico3c.com/",
+        "no-header": True,
+    },
+    "bysebuho": {
+        "type": "filemoon",
+        "referrer": "https://ico3c.com/",
+        "no-header": True,
+    },
+    "bysekoze": {
+        "type": "filemoon",
+        "referrer": "https://ico3c.com/",
+        "no-header": True,
+    },
+    "kakaflix": {"type": "kakaflix"},
+    # "myvidplay": {"type": "myvidplay", "referrer": "https://myvidplay.com/"},
+    "embed4me": {"type": "embed4me"},
+    "coflix.upn": {"type": "embed4me"},
+    "veev": {"type": "veev", "ext": "mp4"},
+    "xtremestream": {"type": "xtremestream"},
+}
+
+DEFAULT_NEW_URL = {
+    "lulustream": "luluvdo",
+    "vidoza.net": "videzz.net",
+    "oneupload.to": "oneupload.net",
+    "uqload.cx": "uqload.is",
+    # Dinisglows Player
+    "mivalyo": "dinisglows",
+    "vidhideplus": "dinisglows",
+    "dingtezuni": "dinisglows",
+    # Vidmoly Player
+    "vidmoly.to": "vidmoly.biz",
+    "vidmoly.me": "vidmoly.biz",
+    "vidmoly.net": "vidmoly.biz",
+}
+
+DEFAULT_KAKAFLIX_PLAYERS = {
+    "moon2": "ico3c",
+    "viper": "ico3c",
+    # "tokyo": "myvidplay"
+}
+
+DEFAULT_SOURCE_PORTAL = {
+    "french-stream": "https://french-stream.one",
+    "anime-sama": "https://animes-sama.fr",
+    "coflix": "https://coflix.fans",
+    "sudatchi": "https://sudatchi.com",
+    "animetsu": "https://animetsu.live",
+    "animetsu-api": "https://b.animetsu.live",
+    "animetsu-proxy": "https://ani.metsu.site/proxy",
+    "allanime-api": "https://api.allanime.day/api",
+    "allanime-referer": "https://allmanga.to",
+    "allanime-base": "https://allanime.day",
+    "anizone": "https://anizone.to",
+    "videasy": "https://api.videasy.net",
+    "videasy-referer": "https://cineby.gd",
+    "vidlink": "https://vidlink.pro",
+    "hexa": "https://themoviedb.hexa.su",
+    "hexa-referer": "https://hexa.su",
+    "multi-decrypt": "https://enc-dec.app/api",
+    "mapple": "https://mapple.uk",
+    "xpass": "https://play.xpass.top",
+}