mikancli 0.1.0__py3-none-any.whl

mikancli/__init__.py

@@ -0,0 +1,7 @@
+"""MikanCli package."""
+
+__all__ = [
+    "__version__",
+]
+
+__version__ = "0.1.0"

mikancli/__main__.py

@@ -0,0 +1,5 @@
+from mikancli.cli.entrypoint import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mikancli/cli/__init__.py

@@ -0,0 +1,3 @@
+from mikancli.cli.entrypoint import main
+
+__all__ = ["main"]

mikancli/cli/entrypoint.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from mikancli.cli.input_parsing import prompt_word_list
+from mikancli.cli.prompts import ExitRequested, select_option
+from mikancli.cli.qbittorrent_flow import (
+    QBITTORRENT_SUBMISSION_SKIPPED,
+    prompt_for_qbittorrent_setup_if_needed,
+    prompt_to_submit_rule_to_qbittorrent,
+    run_qbittorrent_configuration_flow,
+    setup_qbittorrent,
+)
+from mikancli.cli.save_path_flow import (
+    build_content_save_path,
+    prompt_for_content_folder_name,
+    resolve_save_path,
+)
+from mikancli.cli.search_flow import resolve_mikan_selection, run_interactive_selection
+from mikancli.config import get_config_path, load_config
+from mikancli.core.models import AppConfig, RuleDraft, SearchRequest
+from mikancli.core.normalize import collapse_spaces
+from mikancli.core.rules import build_rule_draft
+from mikancli.display import print_text_summary
+
+STARTUP_ACTION_SEARCH = "search"
+STARTUP_ACTION_QBITTORRENT = "qbittorrent"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Create the command-line parser for MikanCli flags and positional arguments. Returns a configured ArgumentParser; it does not parse arguments by itself."""
+    parser = argparse.ArgumentParser(
+        prog="mikancli",
+        description=(
+            "Search Mikan for an anime, inspect subgroup RSS contents, and preview "
+            "or submit qBittorrent RSS rule inputs."
+        ),
+    )
+    parser.add_argument("keyword", nargs="?", help="Anime title or search phrase.")
+    parser.add_argument(
+        "--include",
+        action="append",
+        default=[],
+        help="Word that must appear in accepted releases. Repeat for multiple values.",
+    )
+    parser.add_argument(
+        "--exclude",
+        action="append",
+        default=[],
+        help="Word that must not appear in accepted releases. Repeat for multiple values.",
+    )
+    parser.add_argument(
+        "--save-path",
+        help="Optional save path to attach to the qBittorrent rule.",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Print the draft as JSON.",
+    )
+    parser.add_argument(
+        "--setup-qbittorrent",
+        action="store_true",
+        help="Configure and verify qBittorrent WebUI access.",
+    )
+    return parser
+
+
+def _prompt_startup_action() -> str:
+    return select_option(
+        "Choose what you want to do",
+        [
+            (STARTUP_ACTION_SEARCH, "Search anime"),
+            (STARTUP_ACTION_QBITTORRENT, "Modify qBittorrent configurations"),
+        ],
+        default=STARTUP_ACTION_SEARCH,
+        allow_exit=True,
+    )
+
+
+def build_request_from_args(args: argparse.Namespace, *, config: AppConfig, config_path: Path) -> SearchRequest:
+    """Convert parsed JSON-mode CLI arguments into a SearchRequest. Returns the cleaned request or raises ValueError when the required keyword is missing."""
+
+    if not args.keyword:
+        raise ValueError("keyword is required when using --json")
+
+    save_path = resolve_save_path(
+        args.save_path,
+        config,
+        prompt_for_default=False,
+        config_path=config_path,
+    )
+
+    return SearchRequest(
+        keyword=collapse_spaces(args.keyword),
+        include_words=tuple(args.include),
+        exclude_words=tuple(args.exclude),
+        save_path=save_path,
+    )
+
+
+def _build_interactive_draft(args: argparse.Namespace, *, config: AppConfig,config_path: Path) -> RuleDraft:
+
+    bangumi, subgroup = run_interactive_selection(initial_keyword=args.keyword)
+
+    include_words = tuple(args.include) or prompt_word_list(
+        "Enter include words separated by commas, or press Enter to skip: "
+    )
+    exclude_words = tuple(args.exclude) or prompt_word_list(
+        "Enter exclude words separated by commas, or press Enter to skip: "
+    )
+    save_path = resolve_save_path(
+        args.save_path,
+        config,
+        prompt_for_default=True,
+        config_path=config_path,
+    )
+    content_folder_name = prompt_for_content_folder_name(bangumi.title)
+    final_save_path = build_content_save_path(save_path, content_folder_name)
+
+    request = SearchRequest(
+        keyword=bangumi.title,
+        include_words=include_words,
+        exclude_words=exclude_words,
+        save_path=final_save_path,
+    )
+    return build_rule_draft(
+        request,
+        bangumi=bangumi,
+        subgroup=subgroup,
+        notes=("Review the draft before submitting it to qBittorrent.",),
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    config_path = get_config_path()
+    config = load_config(config_path)
+
+    if args.setup_qbittorrent:
+        try:
+            return setup_qbittorrent(config, config_path)
+        except ExitRequested:
+            print("Exited MikanCli.")
+            return 0
+
+    if args.json:
+        try:
+            request = build_request_from_args(
+                args,
+                config=config,
+                config_path=config_path,
+            )
+        except ValueError as exc:
+            parser.error(str(exc))
+
+        bangumi, subgroup, lookup_notes = resolve_mikan_selection(request)
+        draft = build_rule_draft(
+            request,
+            bangumi=bangumi,
+            subgroup=subgroup,
+            notes=lookup_notes,
+        )
+        print(json.dumps(draft.to_dict(), ensure_ascii=False, indent=2))
+        return 0
+
+    has_startup_menu = args.keyword is None
+
+    while True:
+        try:
+            if has_startup_menu:
+                while True:
+                    startup_action = _prompt_startup_action()
+                    if startup_action == STARTUP_ACTION_QBITTORRENT:
+                        setup_exit_code = run_qbittorrent_configuration_flow(config, config_path)
+                        if setup_exit_code != 0:
+                            return setup_exit_code
+                        config = load_config(config_path)
+                        continue
+                    break
+
+            setup_exit_code = prompt_for_qbittorrent_setup_if_needed(
+                config,
+                config_path,
+            )
+            if setup_exit_code != 0:
+                return setup_exit_code
+            config = load_config(config_path)
+            draft = _build_interactive_draft(
+                args,
+                config=config,
+                config_path=config_path,
+            )
+        except ExitRequested:
+            print("Exited MikanCli.")
+            return 0
+
+        summary_exit_code = print_text_summary(draft)
+        if summary_exit_code != 0:
+            return summary_exit_code
+        try:
+            submission_exit_code = prompt_to_submit_rule_to_qbittorrent(config, draft)
+        except ExitRequested:
+            print("Exited MikanCli.")
+            return 0
+
+        if has_startup_menu and submission_exit_code == QBITTORRENT_SUBMISSION_SKIPPED:
+            config = load_config(config_path)
+            continue
+
+        return 0 if submission_exit_code == QBITTORRENT_SUBMISSION_SKIPPED else submission_exit_code

mikancli/cli/input_parsing.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from mikancli.cli.prompts import prompt_text
+from mikancli.core.normalize import collapse_spaces
+
+
+def prompt_required_text(prompt: str) -> str:
+    while True:
+        entered = collapse_spaces(prompt_text(prompt, allow_exit=True))
+        if entered:
+            return entered
+        print("A value is required.")
+
+
+def parse_word_list(value: str) -> tuple[str, ...]:
+    """Parse a comma-separated word list while dropping blanks and duplicates. Example: parse_word_list("HEVC, 1080p, HEVC") returns ("HEVC", "1080p")."""
+    words: list[str] = []
+    seen: set[str] = set()
+
+    for raw_part in value.split(","):
+        cleaned = collapse_spaces(raw_part)
+        if not cleaned:
+            continue
+
+        marker = cleaned.casefold()
+        if marker in seen:
+            continue
+
+        seen.add(marker)
+        words.append(cleaned)
+
+    return tuple(words)
+
+
+def prompt_word_list(prompt: str) -> tuple[str, ...]:
+    entered = collapse_spaces(prompt_text(prompt, allow_exit=True))
+    if not entered:
+        return ()
+
+    return parse_word_list(entered)

mikancli/cli/prompts.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, TypeVar
+
+from mikancli.core.normalize import collapse_spaces
+
+T = TypeVar("T")
+EXIT_OPTION = "__exit_cli__"
+EXIT_TEXT_VALUES = {"exit", "quit"}
+PROMPT_SEPARATOR = "----------------------------------------"
+MENU_SEPARATOR_LABEL = ""
+
+
+class ExitRequested(Exception):
+    """Raised when the user explicitly chooses to quit the CLI."""
+
+
+def _get_inquirer():
+    try:
+        from InquirerPy import inquirer
+    except ImportError as exc:
+        raise RuntimeError(
+            "Interactive mode requires InquirerPy. Install project dependencies first."
+        ) from exc
+
+    return inquirer
+
+
+def _prepare_prompt_message(message: str) -> str:
+    print(f"\n{PROMPT_SEPARATOR}")
+    return message.strip("\n")
+
+
+def _get_menu_separator() -> Any | None:
+    try:
+        from InquirerPy.separator import Separator
+    except ImportError:
+        return None
+
+    return Separator(MENU_SEPARATOR_LABEL)
+
+
+def _build_select_choices(
+    options: list[tuple[T, str]],
+    *,
+    allow_exit: bool,
+    separator_before_values: Iterable[T] = (),
+    separator_before_exit: bool = True,
+) -> list[object]:
+    separator_values = set(separator_before_values)
+    separator = _get_menu_separator()
+    choices: list[object] = []
+
+    for value, label in options:
+        if value in separator_values and separator is not None:
+            choices.append(separator)
+        choices.append({"value": value, "name": label})
+
+    if allow_exit:
+        if choices and separator_before_exit and separator is not None:
+            choices.append(separator)
+        choices.append({"value": EXIT_OPTION, "name": "Exit MikanCli"})
+
+    return choices
+
+
+def select_option(
+    message: str,
+    options: list[tuple[T, str]],
+    *,
+    default: T | None = None,
+    allow_exit: bool = False,
+    separator_before_values: Iterable[T] = (),
+    separator_before_exit: bool = True,
+) -> T:
+    """Show an InquirerPy selection menu and return the selected option value. Raises ExitRequested when exit is allowed and the user chooses the exit option."""
+    inquirer = _get_inquirer()
+
+    choices = _build_select_choices(
+        options,
+        allow_exit=allow_exit,
+        separator_before_values=separator_before_values,
+        separator_before_exit=separator_before_exit,
+    )
+    prompt = inquirer.select(
+        message=_prepare_prompt_message(message),
+        choices=choices,
+        default=default,
+        pointer=">",
+        instruction="Use arrow keys",
+        max_height="70%",
+        cycle=True,
+    )
+    selected = prompt.execute()
+    if allow_exit and selected == EXIT_OPTION:
+        raise ExitRequested()
+    return selected
+
+
+def prompt_text(message: str, *, default: str | None = None, allow_exit: bool = False) -> str:
+    """Prompt for text, collapse surrounding whitespace, and return the cleaned value. Raises ExitRequested when exit words are allowed and entered."""
+
+    inquirer = _get_inquirer()
+
+    prompt = inquirer.text(
+        message=_prepare_prompt_message(message),
+        default=default or "",
+    )
+    entered = collapse_spaces(prompt.execute())
+    if allow_exit and entered.casefold() in EXIT_TEXT_VALUES:
+        raise ExitRequested()
+    return entered
+
+
+def prompt_password(message: str, *, allow_exit: bool = False) -> str:
+    """Prompt for hidden password input and return the raw entered value. Raises ExitRequested when exit words are allowed and entered."""
+    
+    inquirer = _get_inquirer()
+    prompt_factory = getattr(inquirer, "secret", None)
+    if prompt_factory is not None:
+        prompt = prompt_factory(message=_prepare_prompt_message(message))
+    else:  # pragma: no cover - fallback for alternate InquirerPy versions
+        prompt = inquirer.text(message=_prepare_prompt_message(message), secret=True)
+
+    entered = prompt.execute()
+    if allow_exit and entered.strip().casefold() in EXIT_TEXT_VALUES:
+        raise ExitRequested()
+    return entered
+
+
+def confirm_choice(message: str, *, default: bool = True, allow_exit: bool = False) -> bool:
+    """Ask a yes/no question using the same menu style as other prompts. Returns True for Yes and False for No."""
+
+    default_value = "yes" if default else "no"
+    selected = select_option(
+        message,
+        [
+            ("yes", "Yes"),
+            ("no", "No"),
+        ],
+        default=default_value,
+        allow_exit=allow_exit,
+    )
+    return selected == "yes"

mikancli/cli/qbittorrent_flow.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from mikancli.cli.prompts import confirm_choice, prompt_password, prompt_text
+from mikancli.config import save_config
+from mikancli.core.models import AppConfig, QBittorrentSettings, RuleDraft
+from mikancli.core.normalize import collapse_spaces
+from mikancli.integrations.qbittorrent import (
+    QBittorrentError,
+    check_connection,
+    normalize_qbittorrent_url,
+    submit_rule_draft,
+)
+
+QBITTORRENT_SUBMISSION_SKIPPED = 2
+
+
+def setup_qbittorrent(config: AppConfig, config_path: Path) -> int:
+    """Prompt for qBittorrent WebUI settings, verify the connection, and save them on success. Returns 0 when verification succeeds and 1 when qBittorrent rejects or cannot be reached."""
+    print()
+    print("----- qBittorrent setup instructions -----")
+    print("1. Install qBittorrent and open its settings.")
+    print("2. Enable WebUI / remote control if it is not enabled yet.")
+    print("3. Copy the WebUI address, username, and password from qBittorrent.")
+    print("4. Enter those values below.")
+    print("5. After successful verification, the values will be saved to the config file for future runs.")
+    print("------------------------------------------")
+    print()
+
+    default_url = config.qbittorrent_url or "http://localhost:8080"
+    entered_url = (
+        collapse_spaces(
+            prompt_text(
+                "Enter qBittorrent WebUI URL (http://localhost:8080 is the usual default)",
+                default=default_url,
+                allow_exit=True,
+            )
+        )
+        or "http://localhost:8080"
+    )
+
+    print()
+    print('If you have "Bypass authentication for clients on localhost" enabled in qBittorrent settings, you can just press Enter for the next two prompts.')
+    username = (
+        collapse_spaces(
+            prompt_text(
+                "Enter qBittorrent WebUI username (press Enter to leave blank)",
+                default=config.qbittorrent_username or "",
+                allow_exit=True,
+            )
+        )
+        or None
+    )
+    password = prompt_password(
+        "Enter qBittorrent WebUI password (press Enter to leave blank)",
+        allow_exit=True,
+    ) or None
+
+    settings = QBittorrentSettings(
+        url=entered_url,
+        username=username,
+        password=password,
+    )
+
+    try:
+        print("Verifying qBittorrent connection...")
+        version = check_connection(settings)
+    except QBittorrentError as exc:
+        print(str(exc))
+        return 1
+
+    save_config(
+        config_path,
+        AppConfig(
+            default_save_path=config.default_save_path,
+            qbittorrent_url=normalize_qbittorrent_url(entered_url),
+            qbittorrent_username=username,
+            qbittorrent_password=password,
+            qbittorrent_category=config.qbittorrent_category,
+            qbittorrent_add_paused=config.qbittorrent_add_paused,
+        ),
+    )
+    print(
+        "qBittorrent connection verified successfully "
+        f"(version: {version})."
+    )
+    return 0
+
+
+def prompt_for_qbittorrent_setup_if_needed(config: AppConfig, config_path: Path) -> int:
+    """Offer first-run qBittorrent setup when no WebUI URL is configured. Returns 0 when setup is skipped, already configured, or completed successfully."""
+
+    if config.qbittorrent_url:
+        return 0
+
+    should_setup = confirm_choice(
+        "qBittorrent is not set up yet. Set up qBittorrent WebUI now?",
+        default=True,
+        allow_exit=True,
+    )
+    if not should_setup:
+        return 0
+
+    while True:
+        exit_code = setup_qbittorrent(config, config_path)
+        if exit_code == 0:
+            return 0
+
+        continue_without_setup = confirm_choice(
+            "Continue without qBittorrent setup for now?",
+            default=False,
+            allow_exit=True,
+        )
+        if continue_without_setup:
+            return 0
+
+
+def run_qbittorrent_configuration_flow(config: AppConfig, config_path: Path) -> int:
+    """Run the qBittorrent setup route and allow retrying after failed verification. Returns 0 after a successful setup or when the user stops retrying."""
+
+    while True:
+        exit_code = setup_qbittorrent(config, config_path)
+        if exit_code == 0:
+            return 0
+
+        retry_setup = confirm_choice(
+            "Retry qBittorrent setup?",
+            default=True,
+            allow_exit=True,
+        )
+        if not retry_setup:
+            return 0
+
+
+def prompt_to_submit_rule_to_qbittorrent(config: AppConfig, draft: RuleDraft,) -> int:
+    """Ask whether to submit a confirmed rule draft to qBittorrent and report the result. Returns 0 on success, 1 on submission failure, or QBITTORRENT_SUBMISSION_SKIPPED when declined."""
+    
+    if not config.qbittorrent_url:
+        return 0
+
+    should_submit = confirm_choice(
+        "Submit this RSS feed and download rule to qBittorrent now?",
+        default=True,
+        allow_exit=True,
+    )
+    if not should_submit:
+        return QBITTORRENT_SUBMISSION_SKIPPED
+
+    settings = QBittorrentSettings(
+        url=config.qbittorrent_url,
+        username=config.qbittorrent_username,
+        password=config.qbittorrent_password,
+    )
+
+    try:
+        print("Submitting RSS feed and download rule to qBittorrent...")
+        submit_rule_draft(
+            settings,
+            draft,
+            add_paused=config.qbittorrent_add_paused,
+            assigned_category=config.qbittorrent_category,
+        )
+    except QBittorrentError as exc:
+        print(str(exc))
+        return 1
+
+    print("qBittorrent feed and download rule submitted and verified successfully.")
+    return 0