pinak-cli 1.2.1__tar.gz → 1.3.0__tar.gz

{pinak_cli-1.2.1/pinak_cli.egg-info → pinak_cli-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pinak-cli
-Version: 1.2.1
+Version: 1.3.0
 Summary: A powerful, aesthetic command-line media downloader using yt-dlp
 Author: Pinak Team
 License-Expression: MIT

pinak_cli-1.3.0/pinak/__init__.py

@@ -0,0 +1,2 @@
+# Pinak CLI Package
+__version__ = "1.3.0"

{pinak_cli-1.2.1 → pinak_cli-1.3.0}/pinak/cli.py

@@ -56,36 +56,58 @@ console = Console()
 def ask_with_esc(q):
     """Wrapper to allow Esc key to cancel questionary prompts."""
     try:
+        try:
 
-        @q.application.key_bindings.add(Keys.Escape, eager=True)
-        def _(event):
-            event.app.exit(result=None)
+            @q.application.key_bindings.add(Keys.Escape, eager=True)
+            def _(event):
+                event.app.exit(result=None)
 
-    except AttributeError:
-        from prompt_toolkit.key_binding import KeyBindings, merge_key_bindings
+        except AttributeError:
+            from prompt_toolkit.key_binding import KeyBindings, merge_key_bindings
 
-        kb = KeyBindings()
+            kb = KeyBindings()
 
-        @kb.add(Keys.Escape, eager=True)
-        def _(event):
-            event.app.exit(result=None)
+            @kb.add(Keys.Escape, eager=True)
+            def _(event):
+                event.app.exit(result=None)
 
-        q.application.key_bindings = merge_key_bindings([q.application.key_bindings, kb])
+            q.application.key_bindings = merge_key_bindings([q.application.key_bindings, kb])
+    except Exception:
+        pass
 
     # Catch internal KeyboardInterrupt from Ctrl+C to avoid redundant messages
     try:
         return q.ask(kbi_msg="")
     except TypeError:
         # Fallback if kbi_msg is not supported in the user's questionary version
-        return q.ask()
+        try:
+            return q.ask()
+        except Exception:
+            try:
+                msg = getattr(q, "message", "Enter value: ")
+                return input(str(msg)).strip()
+            except (EOFError, KeyboardInterrupt):
+                return None
+    except Exception:
+        # Fallback to standard input if prompt_toolkit / terminal fails
+        try:
+            msg = getattr(q, "message", "Enter value: ")
+            return input(str(msg)).strip()
+        except (EOFError, KeyboardInterrupt):
+            return None
 
 
 def repl_loop():  # pragma: no cover - interactive TTY loop, exercised manually
     print_banner()
     username = config.get("username", "").strip()
     if not username:
-        console.print("[yellow][!] Before we begin, please tell us your name.[/]")
-        username = ask_with_esc(questionary.text("Enter your name:"))
+        try:
+            username = ask_with_esc(questionary.text("Enter your name:"))
+        except Exception:
+            try:
+                username = input("Enter your name: ").strip()
+            except (EOFError, KeyboardInterrupt):
+                username = None
         if not username:
             print(f"\n{CYAN}[*] Goodbye!{RESET}")
             sys.exit(0)
@@ -102,6 +124,7 @@ def repl_loop():  # pragma: no cover - interactive TTY loop, exercised manually
         "/open": "Open the current output folder",
         "/history": "View download history",
         "/batch": "Download multiple URLs from a text file",
+        "/any": "Download content from any platform supported by yt-dlp",
         "/instagram": "Download post, reel, igtv from Instagram",
         "/video": "Download video from a URL",
         "/audio": "Download video/song directly as MP3",
@@ -143,6 +166,7 @@ def repl_loop():  # pragma: no cover - interactive TTY loop, exercised manually
         def append_string(self, string: str) -> None:
             lower_str = string.strip().lower()
             if lower_str in [
+                "/any",
                 "/video",
                 "/audio",
                 "/trim",
@@ -155,7 +179,10 @@ def repl_loop():  # pragma: no cover - interactive TTY loop, exercised manually
             super().append_string(string)
 
     history_file = os.path.expanduser("~/.pinak_cli_history")
-    session = PromptSession(history=FilteredHistory(history_file))
+    try:
+        session = PromptSession(history=FilteredHistory(history_file))
+    except Exception:
+        session = None
 
     kb = KeyBindings()
 
@@ -164,6 +191,7 @@ def repl_loop():  # pragma: no cover - interactive TTY loop, exercised manually
         buffer = event.current_buffer
         text = buffer.text.strip().lower()
         if text in [
+            "/any",
             "/video",
             "/audio",
             "/trim",
@@ -196,25 +224,44 @@ def repl_loop():  # pragma: no cover - interactive TTY loop, exercised manually
                 print_update_notice(updater.PINAK_PACKAGE, updater.PINAK_UPDATE_AVAILABLE)
                 has_shown_pinak_update = True
 
-            cmd = session.prompt(
-                "Pinak 🔱 > ",
-                default=default_cmd,
-                completer=commands_completer,
-                complete_while_typing=True,
-                style=custom_style,
-                mouse_support=False,
-                key_bindings=kb,
-            ).strip()
+            if session is not None:
+                try:
+                    cmd = session.prompt(
+                        "Pinak 🔱 > ",
+                        default=default_cmd,
+                        completer=commands_completer,
+                        complete_while_typing=True,
+                        style=custom_style,
+                        mouse_support=False,
+                        key_bindings=kb,
+                    ).strip()
+                except (EOFError, KeyboardInterrupt):
+                    print_exit_screen(interrupted=True)
+                    break
+                except Exception:
+                    try:
+                        cmd = input("Pinak 🔱 > ").strip()
+                    except (EOFError, KeyboardInterrupt):
+                        print_exit_screen(interrupted=True)
+                        break
+            else:
+                try:
+                    cmd = input("Pinak 🔱 > ").strip()
+                except (EOFError, KeyboardInterrupt):
+                    print_exit_screen(interrupted=True)
+                    break
 
             default_cmd = ""
+            cmd = cmd.strip().lstrip("\ufeff")
 
             if not cmd:
                 continue
 
             lower_cmd = cmd.lower()
 
-            # Fallback if somehow submitted (e.g. mouse double click)
-            if lower_cmd in [
+            # Fallback if somehow submitted (e.g. mouse double click in prompt_toolkit)
+            if session is not None and lower_cmd in [
+                "/any",
                 "/video",
                 "/audio",
                 "/trim",
@@ -626,20 +673,66 @@ def repl_loop():  # pragma: no cover - interactive TTY loop, exercised manually
 
             if cmd.startswith("/"):
                 if not (
-                    lower_cmd.startswith("/audio ")
+                    lower_cmd.startswith("/any ")
+                    or lower_cmd.startswith("/audio ")
                     or lower_cmd.startswith("/video ")
                     or lower_cmd.startswith("/instagram ")
+                    or lower_cmd in ("/any", "/video", "/audio", "/instagram")
                 ):
                     print(f"{YELLOW}[!] Unknown command: {cmd}. Type /help for assistance.{RESET}")
                     continue
+                if lower_cmd in ("/any", "/video", "/audio", "/instagram"):
+                    try:
+                        raw_url = input("Enter URL to download: ").strip()
+                    except (KeyboardInterrupt, EOFError):
+                        print(f"{YELLOW}[*] Canceled.{RESET}")
+                        continue
+                    if not raw_url:
+                        print(f"{RED}[!] Error: No URL provided.{RESET}")
+                        continue
+                    cmd = f"{cmd} {raw_url}"
+                    lower_cmd = cmd.lower()
+                is_any = lower_cmd.startswith("/any ")
                 url, extract_audio, force, quality = parse_download_text(cmd)
-                handle_download(url, extract_audio=extract_audio, force=force, quality=quality)
+                handle_download(
+                    url,
+                    extract_audio=extract_audio,
+                    force=force,
+                    quality=quality,
+                    is_any_command=is_any,
+                )
             else:
-                if cmd.lower().startswith("http"):
+                if lower_cmd.startswith("any "):
+                    url, extract_audio, force, quality = parse_download_text(cmd)
+                    handle_download(
+                        url,
+                        extract_audio=extract_audio,
+                        force=force,
+                        quality=quality,
+                        is_any_command=True,
+                    )
+                elif lower_cmd == "any":
+                    try:
+                        raw_url = input("Enter URL to download: ").strip()
+                    except (KeyboardInterrupt, EOFError):
+                        print(f"{YELLOW}[*] Canceled.{RESET}")
+                        continue
+                    if not raw_url:
+                        print(f"{RED}[!] Error: No URL provided.{RESET}")
+                        continue
+                    url, extract_audio, force, quality = parse_download_text(f"/any {raw_url}")
+                    handle_download(
+                        url,
+                        extract_audio=extract_audio,
+                        force=force,
+                        quality=quality,
+                        is_any_command=True,
+                    )
+                elif cmd.lower().startswith("http"):
                     print(
-                        f"{YELLOW}[!] Direct URL detected. Use /video, /audio, or /instagram before the link."
+                        f"{YELLOW}[!] Direct URL detected. Use /any, /video, /audio, or /instagram before the link."
                     )
-                    print(f"    Example: /instagram {cmd}{RESET}")
+                    print(f"    Example: /any {cmd}{RESET}")
                 else:
                     print(
                         f"{YELLOW}[!] Unknown input: '{cmd}'. Type /help to see all commands.{RESET}"
@@ -711,12 +804,18 @@ def maybe_print_offline_notice() -> bool:
 @app.command()
 def main(
     url: str | None = typer.Argument(None, help="The URL to download from"),
+    extra_arg: str | None = typer.Argument(
+        None, help="Optional secondary URL or command argument (e.g. pinak any <url>)"
+    ),
     output: str | None = typer.Option(None, "-o", "--output", help="Output directory"),
     force: bool = typer.Option(False, "--force", help="Force download despite duplicates"),
     audio: bool = typer.Option(False, "--audio", help="Extract audio directly as MP3"),
     quality: str | None = typer.Option(
         None, "--quality", help="Quality: best, worst, audio, 360p, 720p, 1080p"
     ),
+    any_link: bool = typer.Option(
+        False, "--any", help="Allow any type of link supported by yt-dlp"
+    ),
     doctor: bool = typer.Option(False, "--doctor", help="Run environment checks and exit"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose debug output"),
     log_file: str | None = typer.Option(
@@ -769,8 +868,13 @@ def main(
     updater.start_background_update_check()
     maybe_print_offline_notice()
 
+    if url in ("any", "/any"):
+        any_link = True
+        url = extra_arg
+
     has_args = bool(
         url
+        or any_link
         or output
         or force
         or audio
@@ -786,7 +890,18 @@ def main(
         from .commands.run import run_single
 
         raise typer.Exit(
-            code=run_single(url, output, force, audio, quality, doctor, verbose, dry_run, as_json)
+            code=run_single(
+                url,
+                output,
+                force,
+                audio,
+                quality,
+                doctor,
+                verbose,
+                dry_run,
+                as_json,
+                is_any=any_link,
+            )
         )
     repl_loop()
 

{pinak_cli-1.2.1 → pinak_cli-1.3.0}/pinak/commands/info.py

@@ -23,12 +23,40 @@ def open_output_folder() -> None:
     os.makedirs(output_dir, exist_ok=True)
     path = os.path.abspath(output_dir)
     try:
+        import shutil
+        import subprocess
         import webbrowser
 
+        opened = False
         if sys.platform.startswith("win"):
-            os.startfile(path)
-        else:
+            if hasattr(os, "startfile"):
+                try:
+                    os.startfile(path)
+                    opened = True
+                except Exception:
+                    pass
+            if not opened and shutil.which("explorer"):
+                try:
+                    subprocess.run(["explorer", path], check=False)  # nosec B603, B607
+                    opened = True
+                except Exception:
+                    pass
+        elif sys.platform == "darwin" and shutil.which("open"):
+            try:
+                subprocess.run(["open", path], check=False)  # nosec B603, B607
+                opened = True
+            except Exception:
+                pass
+        elif shutil.which("xdg-open"):
+            try:
+                subprocess.run(["xdg-open", path], check=False)  # nosec B603, B607
+                opened = True
+            except Exception:
+                pass
+
+        if not opened:
             webbrowser.open(Path(path).as_uri())
+
         print(f"{GREEN}[+] Opened: {path}{RESET}")
     except Exception as e:
         print(f"{RED}[X] Could not open folder: {e}{RESET}")
@@ -51,6 +79,10 @@ def print_help() -> None:
             "View history; filters: failed, audio, media, search <text>",
         ),
         ("/batch <file>", "Download multiple URLs from a text file"),
+        (
+            "/any <url>",
+            "Download content from any platform supported by yt-dlp",
+        ),
         (
             "/instagram <url>",
             "Download post, reel, igtv from Instagram with description & metadata",

{pinak_cli-1.2.1 → pinak_cli-1.3.0}/pinak/commands/run.py

@@ -117,6 +117,7 @@ def run_single(
     verbose: bool,
     dry_run: bool,
     as_json: bool,
+    is_any: bool = False,
 ) -> int:
     """Execute single-command mode. Returns the process exit code."""
     if output:
@@ -161,6 +162,7 @@ def run_single(
         force=force,
         quality=norm_quality,
         interactive=False,
+        is_any_command=is_any,
     )
     if as_json:
         print(json.dumps(result_to_jsonable(result), indent=2))

{pinak_cli-1.2.1 → pinak_cli-1.3.0}/pinak/config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import json
 import os
 import shutil
@@ -148,17 +149,34 @@ def init_config() -> dict[str, Any]:
         elif os.path.exists(LOCAL_CONFIG):
             shutil.copy(LOCAL_CONFIG, CONFIG_FILE)
 
+    def _load_from_path(path: str) -> bool:
+        if not os.path.exists(path):
+            return False
+        with open(path, encoding="utf-8") as f:
+            raw = f.read().strip()
+        if not raw:
+            return False
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            data = _migrate_legacy_keys(data)
+            settings = PinakSettings(**data)
+            config.update(settings.model_dump())
+            return True
+        return False
+
+    loaded = False
     try:
-        if os.path.exists(CONFIG_FILE):
-            with open(CONFIG_FILE, encoding="utf-8") as f:
-                data = json.load(f)
-            if isinstance(data, dict):
-                data = _migrate_legacy_keys(data)
-                # Load with Pydantic for validation
-                settings = PinakSettings(**data)
-                config.update(settings.model_dump())
+        loaded = _load_from_path(CONFIG_FILE)
     except Exception:
-        pass
+        loaded = False
+
+    # Fallback to backup file if primary CONFIG_FILE was missing, empty, or corrupted
+    if not loaded:
+        bak_file = CONFIG_FILE + ".bak"
+        with contextlib.suppress(Exception):
+            if _load_from_path(bak_file):
+                with contextlib.suppress(Exception):
+                    shutil.copy2(bak_file, CONFIG_FILE)
 
     return config
 
@@ -177,11 +195,28 @@ def save_config(config_data: dict[str, Any] | None = None) -> bool:
     if config_data is not None:
         config.update(config_data)
 
+    temp_file = CONFIG_FILE + ".tmp"
+    bak_file = CONFIG_FILE + ".bak"
     try:
         valid_settings = validate_settings(config)
         config.update(valid_settings.model_dump())
-        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
-            f.write(valid_settings.model_dump_json(indent=4))
+        serialized = valid_settings.model_dump_json(indent=4)
+
+        parent_dir = os.path.dirname(CONFIG_FILE)
+        if parent_dir:
+            os.makedirs(parent_dir, exist_ok=True)
+
+        with open(temp_file, "w", encoding="utf-8") as f:
+            f.write(serialized)
+            f.flush()
+            with contextlib.suppress(AttributeError, OSError):
+                os.fsync(f.fileno())
+
+        if os.path.exists(CONFIG_FILE):
+            with contextlib.suppress(Exception):
+                shutil.copy2(CONFIG_FILE, bak_file)
+
+        os.replace(temp_file, CONFIG_FILE)
         return True
     except ConfigError as ce:
         print(f"\033[91m[X] Could not write {CONFIG_FILE}: {ce}\033[0m")
@@ -193,3 +228,7 @@ def save_config(config_data: dict[str, Any] | None = None) -> bool:
             "\033[93m[!] Tip: check that values are valid (e.g. quality=best/720p, video_format=mp4). Run `pinak --doctor` for details.\033[0m"
         )
         return False
+    finally:
+        if os.path.exists(temp_file):
+            with contextlib.suppress(Exception):
+                os.remove(temp_file)

{pinak_cli-1.2.1 → pinak_cli-1.3.0}/pinak/doctor.py

@@ -158,15 +158,37 @@ def run_doctor(verbose: bool = False) -> bool:
         timeout = 10.0
     internet_ok = False
     connected_host = ""
-    for host in ("https://www.google.com", "https://1.1.1.1"):
+    for host in (
+        "https://www.google.com",
+        "https://1.1.1.1",
+        "https://www.cloudflare.com",
+        "https://httpbin.org/status/200",
+    ):
         try:
             # Fixed HTTPS connectivity probe — no user-controlled scheme. nosec B310
-            urllib.request.urlopen(host, timeout=timeout).close()  # nosec B310
-            internet_ok = True
-            connected_host = host.split("//")[-1]
-            break
+            req = urllib.request.Request(host, headers={"User-Agent": "PinakCLI"})
+            with urllib.request.urlopen(req, timeout=timeout) as resp:  # nosec B310
+                if hasattr(resp, "close"):
+                    resp.close()
+                internet_ok = True
+                connected_host = host.split("//")[-1].split("/")[0]
+                break
         except Exception:
             continue
+
+    if not internet_ok:
+        import socket
+
+        sock_timeout = min(timeout, 2.0)
+        for ip, port in (("1.1.1.1", 53), ("8.8.8.8", 53)):
+            try:
+                with socket.create_connection((ip, port), timeout=sock_timeout):
+                    internet_ok = True
+                    connected_host = f"{ip}:{port} (socket fallback)"
+                    break
+            except Exception:
+                continue
+
     checks.append(
         (
             "Internet Connection",