falyx 0.1.54__tar.gz → 0.1.56__tar.gz

{falyx-0.1.54 → falyx-0.1.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: falyx
-Version: 0.1.54
+Version: 0.1.56
 Summary: Reliable and introspectable async CLI action framework.
 License: MIT
 Author: Roland Thomas Jr

{falyx-0.1.54 → falyx-0.1.56}/falyx/action/select_file_action.py

@@ -165,6 +165,11 @@ class SelectFileAction(BaseAction):
         try:
             await self.hooks.trigger(HookType.BEFORE, context)
 
+            if not self.directory.exists():
+                raise FileNotFoundError(f"Directory {self.directory} does not exist.")
+            elif not self.directory.is_dir():
+                raise NotADirectoryError(f"{self.directory} is not a directory.")
+
             files = [
                 file
                 for file in self.directory.iterdir()

{falyx-0.1.54 → falyx-0.1.56}/falyx/command.py

@@ -91,6 +91,12 @@ class Command(BaseModel):
         logging_hooks (bool): Whether to attach logging hooks automatically.
         options_manager (OptionsManager): Manages global command-line options.
         arg_parser (CommandArgumentParser): Parses command arguments.
+        arguments (list[dict[str, Any]]): Argument definitions for the command.
+        argument_config (Callable[[CommandArgumentParser], None] | None): Function to configure arguments
+            for the command parser.
+        arg_metadata (dict[str, str | dict[str, Any]]): Metadata for arguments,
+            such as help text or choices.
+        simple_help_signature (bool): Whether to use a simplified help signature.
         custom_parser (ArgParserProtocol | None): Custom argument parser.
         custom_help (Callable[[], str | None] | None): Custom help message generator.
         auto_args (bool): Automatically infer arguments from the action.
@@ -227,7 +233,7 @@ class Command(BaseModel):
         if self.logging_hooks and isinstance(self.action, BaseAction):
             register_debug_hooks(self.action.hooks)
 
-        if self.arg_parser is None:
+        if self.arg_parser is None and not self.custom_parser:
             self.arg_parser = CommandArgumentParser(
                 command_key=self.key,
                 command_description=self.description,

falyx-0.1.56/falyx/completer.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import shlex
+from typing import TYPE_CHECKING, Iterable
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+if TYPE_CHECKING:
+    from falyx import Falyx
+
+
+class FalyxCompleter(Completer):
+    """Completer for Falyx commands."""
+
+    def __init__(self, falyx: "Falyx"):
+        self.falyx = falyx
+
+    def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:
+        text = document.text_before_cursor
+        try:
+            tokens = shlex.split(text)
+            cursor_at_end_of_token = document.text_before_cursor.endswith((" ", "\t"))
+        except ValueError:
+            return
+
+        if not tokens or (len(tokens) == 1 and not cursor_at_end_of_token):
+            # Suggest command keys and aliases
+            yield from self._suggest_commands(tokens[0] if tokens else "")
+            return
+
+    def _suggest_commands(self, prefix: str) -> Iterable[Completion]:
+        prefix = prefix.upper()
+        keys = [self.falyx.exit_command.key]
+        keys.extend(self.falyx.exit_command.aliases)
+        if self.falyx.history_command:
+            keys.append(self.falyx.history_command.key)
+            keys.extend(self.falyx.history_command.aliases)
+        if self.falyx.help_command:
+            keys.append(self.falyx.help_command.key)
+            keys.extend(self.falyx.help_command.aliases)
+        for cmd in self.falyx.commands.values():
+            keys.append(cmd.key)
+            keys.extend(cmd.aliases)
+        for key in keys:
+            if key.upper().startswith(prefix):
+                yield Completion(key, start_position=-len(prefix))

{falyx-0.1.54 → falyx-0.1.56}/falyx/falyx.py

@@ -32,7 +32,6 @@ from functools import cached_property
 from typing import Any, Callable
 
 from prompt_toolkit import PromptSession
-from prompt_toolkit.completion import WordCompleter
 from prompt_toolkit.formatted_text import AnyFormattedText
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.patch_stdout import patch_stdout
@@ -46,6 +45,7 @@ from falyx.action.action import Action
 from falyx.action.base_action import BaseAction
 from falyx.bottom_bar import BottomBar
 from falyx.command import Command
+from falyx.completer import FalyxCompleter
 from falyx.context import ExecutionContext
 from falyx.debug import log_after, log_before, log_error, log_success
 from falyx.exceptions import (
@@ -413,20 +413,9 @@ class Falyx:
             arg_parser=parser,
         )
 
-    def _get_completer(self) -> WordCompleter:
+    def _get_completer(self) -> FalyxCompleter:
         """Completer to provide auto-completion for the menu commands."""
-        keys = [self.exit_command.key]
-        keys.extend(self.exit_command.aliases)
-        if self.history_command:
-            keys.append(self.history_command.key)
-            keys.extend(self.history_command.aliases)
-        if self.help_command:
-            keys.append(self.help_command.key)
-            keys.extend(self.help_command.aliases)
-        for cmd in self.commands.values():
-            keys.append(cmd.key)
-            keys.extend(cmd.aliases)
-        return WordCompleter(keys, ignore_case=True)
+        return FalyxCompleter(self)
 
     def _get_validator_error_message(self) -> str:
         """Validator to check if the input is a valid command or toggle key."""

falyx-0.1.56/falyx/falyx_completer.py

@@ -0,0 +1,128 @@
+from collections import Counter
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+from typing import Iterable, Set, Optional
+import shlex
+
+from falyx.command import Command
+from falyx.parser.command_argument_parser import CommandArgumentParser
+from falyx.parser.argument import Argument
+from falyx.parser.argument_action import ArgumentAction
+
+class FalyxCompleter(Completer):
+    """Completer for Falyx commands and their arguments."""
+    def __init__(self, falyx: "Falyx"):
+        self.falyx = falyx
+        self._used_args: Set[str] = set()
+        self._used_args_counter: Counter = Counter()
+
+    def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:
+        text = document.text_before_cursor
+        try:
+            tokens = shlex.split(text)
+            cursor_at_end_of_token = document.text_before_cursor.endswith((' ', '\t'))
+        except ValueError:
+            return
+
+        if not tokens or (len(tokens) == 1 and not cursor_at_end_of_token):
+            # Suggest command keys and aliases
+            yield from self._suggest_commands(tokens[0] if tokens else "")
+            return
+
+        command = self._match_command(tokens[0])
+        if not command:
+            return
+
+        if command.arg_parser is None:
+            return
+
+        self._set_used_args(tokens, command)
+
+        next_arg = self._next_expected_argument(tokens, command.arg_parser)
+
+        if next_arg:
+            # Positional arguments or required flagged arguments
+            yield from self._suggest_argument(next_arg, document)
+        else:
+            # Optional arguments
+            for arg in command.arg_parser._keyword.values():
+                if not self._arg_already_used(arg.dest):
+                    yield from self._suggest_argument(arg, document)
+
+    def _set_used_args(self, tokens: list[str], command: Command) -> None:
+        """Extracts used argument flags from the provided tokens."""
+        if not command.arg_parser:
+            return
+        self._used_args.clear()
+        self._used_args_counter.clear()
+        for token in tokens[1:]:
+            if token.startswith('-'):
+                if keyword_argument := command.arg_parser._keyword.get(token):
+                    self._used_args_counter[keyword_argument.dest] += 1
+                    if isinstance(keyword_argument.nargs, int) and self._used_args_counter[keyword_argument.dest] > keyword_argument.nargs:
+                        continue
+                    elif isinstance(keyword_argument.nargs, str) and keyword_argument.nargs in ("?"):
+                        self._used_args.add(keyword_argument.dest)
+                    else:
+                        self._used_args.add(keyword_argument.dest)
+            else:
+                # Handle positional arguments
+                if command.arg_parser._positional:
+                    for arg in command.arg_parser._positional.values():
+                        if arg.dest not in self._used_args:
+                            self._used_args.add(arg.dest)
+                            break
+        print(f"Used args: {self._used_args}, Counter: {self._used_args_counter}")
+
+    def _suggest_commands(self, prefix: str) -> Iterable[Completion]:
+        prefix = prefix.upper()
+        seen = set()
+        for cmd in self.falyx.commands.values():
+            for key in [cmd.key] + cmd.aliases:
+                if key.upper().startswith(prefix) and key not in seen:
+                    yield Completion(key, start_position=-len(prefix))
+                    seen.add(key)
+
+    def _match_command(self, token: str) -> Optional[Command]:
+        token = token.lstrip("?").upper()
+        return self.falyx._name_map.get(token)
+
+    def _next_expected_argument(
+        self, tokens: list[str], parser: CommandArgumentParser
+    ) -> Optional[Argument]:
+        """Determine the next expected argument based on the current tokens."""
+        # Positional arguments first
+        for arg in parser._positional.values():
+            if arg.dest not in self._used_args:
+                return arg
+
+        # Then required keyword arguments
+        for arg in parser._keyword_list:
+            if arg.required and not self._arg_already_used(arg.dest):
+                return arg
+
+        return None
+
+    def _arg_already_used(self, dest: str) -> bool:
+        print(f"Checking if argument '{dest}' is already used: {dest in self._used_args} - Used args: {self._used_args}")
+        return dest in self._used_args
+
+    def _suggest_argument(self, arg: Argument, document: Document) -> Iterable[Completion]:
+        if not arg.positional:
+            for flag in arg.flags:
+                yield Completion(flag, start_position=0)
+
+        if arg.choices:
+            for choice in arg.choices:
+                yield Completion(
+                    choice,
+                    start_position=0,
+                    display=f"{arg.dest}={choice}"
+                )
+
+        if arg.default is not None and arg.action == ArgumentAction.STORE:
+            yield Completion(
+                str(arg.default),
+                start_position=0,
+                display=f"{arg.dest} (default: {arg.default})"
+            )

{falyx-0.1.54 → falyx-0.1.56}/falyx/parser/command_argument_parser.py

@@ -7,7 +7,6 @@ from typing import Any, Iterable
 
 from rich.console import Console
 from rich.markup import escape
-from rich.text import Text
 
 from falyx.action.base_action import BaseAction
 from falyx.exceptions import CommandArgumentError
@@ -466,6 +465,10 @@ class CommandArgumentParser:
                     or isinstance(next_spec.nargs, str)
                     and next_spec.nargs in ("+", "*", "?")
                 ), f"Invalid nargs value: {spec.nargs}"
+
+                if next_spec.default:
+                    continue
+
                 if next_spec.nargs is None:
                     min_required += 1
                 elif isinstance(next_spec.nargs, int):
@@ -473,9 +476,9 @@ class CommandArgumentParser:
                 elif next_spec.nargs == "+":
                     min_required += 1
                 elif next_spec.nargs == "?":
-                    min_required += 0
+                    continue
                 elif next_spec.nargs == "*":
-                    min_required += 0
+                    continue
 
             slice_args = args[i:] if is_last else args[i : i + (remaining - min_required)]
             values, new_i = self._consume_nargs(slice_args, 0, spec)
@@ -484,9 +487,23 @@ class CommandArgumentParser:
             try:
                 typed = [coerce_value(value, spec.type) for value in values]
             except Exception as error:
-                raise CommandArgumentError(
-                    f"Invalid value for '{spec.dest}': {error}"
-                ) from error
+                if len(args[i - new_i :]) == 1 and args[i - new_i].startswith("-"):
+                    token = args[i - new_i]
+                    valid_flags = [
+                        flag for flag in self._flag_map if flag.startswith(token)
+                    ]
+                    if valid_flags:
+                        raise CommandArgumentError(
+                            f"Unrecognized option '{token}'. Did you mean one of: {', '.join(valid_flags)}?"
+                        ) from error
+                    else:
+                        raise CommandArgumentError(
+                            f"Unrecognized option '{token}'. Use --help to see available options."
+                        ) from error
+                else:
+                    raise CommandArgumentError(
+                        f"Invalid value for '{spec.dest}': {error}"
+                    ) from error
             if spec.action == ArgumentAction.ACTION:
                 assert isinstance(
                     spec.resolver, BaseAction
@@ -497,6 +514,8 @@ class CommandArgumentParser:
                     raise CommandArgumentError(
                         f"[{spec.dest}] Action failed: {error}"
                     ) from error
+            elif not typed and spec.default:
+                result[spec.dest] = spec.default
             elif spec.action == ArgumentAction.APPEND:
                 assert result.get(spec.dest) is not None, "dest should not be None"
                 if spec.nargs is None:
@@ -515,10 +534,22 @@ class CommandArgumentParser:
                 consumed_positional_indicies.add(j)
 
         if i < len(args):
-            plural = "s" if len(args[i:]) > 1 else ""
-            raise CommandArgumentError(
-                f"Unexpected positional argument{plural}: {', '.join(args[i:])}"
-            )
+            if len(args[i:]) == 1 and args[i].startswith("-"):
+                token = args[i]
+                valid_flags = [flag for flag in self._flag_map if flag.startswith(token)]
+                if valid_flags:
+                    raise CommandArgumentError(
+                        f"Unrecognized option '{token}'. Did you mean one of: {', '.join(valid_flags)}?"
+                    )
+                else:
+                    raise CommandArgumentError(
+                        f"Unrecognized option '{token}'. Use --help to see available options."
+                    )
+            else:
+                plural = "s" if len(args[i:]) > 1 else ""
+                raise CommandArgumentError(
+                    f"Unexpected positional argument{plural}: {', '.join(args[i:])}"
+                )
 
         return i
 
@@ -624,8 +655,22 @@ class CommandArgumentParser:
                         f"Invalid value for '{spec.dest}': {error}"
                     ) from error
                 if not typed_values and spec.nargs not in ("*", "?"):
+                    choices = []
+                    if spec.default:
+                        choices.append(f"default={spec.default!r}")
+                    if spec.choices:
+                        choices.append(f"choices={spec.choices!r}")
+                    if choices:
+                        choices_text = ", ".join(choices)
+                        raise CommandArgumentError(
+                            f"Argument '{spec.dest}' requires a value. {choices_text}"
+                        )
+                    if spec.nargs is None:
+                        raise CommandArgumentError(
+                            f"Enter a {spec.type.__name__} value for '{spec.dest}'"
+                        )
                     raise CommandArgumentError(
-                        f"Expected at least one value for '{spec.dest}'"
+                        f"Argument '{spec.dest}' requires a value. Expected {spec.nargs} values."
                     )
                 if spec.nargs in (None, 1, "?") and spec.action != ArgumentAction.APPEND:
                     result[spec.dest] = (
@@ -637,7 +682,15 @@ class CommandArgumentParser:
                 i = new_i
         elif token.startswith("-"):
             # Handle unrecognized option
-            raise CommandArgumentError(f"Unrecognized flag: {token}")
+            valid_flags = [flag for flag in self._flag_map if flag.startswith(token)]
+            if valid_flags:
+                raise CommandArgumentError(
+                    f"Unrecognized option '{token}'. Did you mean one of: {', '.join(valid_flags)}?"
+                )
+            else:
+                raise CommandArgumentError(
+                    f"Unrecognized option '{token}'. Use --help to see available options."
+                )
         else:
             # Get the next flagged argument index if it exists
             next_flagged_index = -1
@@ -645,8 +698,6 @@ class CommandArgumentParser:
                 if arg in self._keyword:
                     next_flagged_index = index
                     break
-            print(f"next_flagged_index: {next_flagged_index}")
-            print(f"{self._keyword_list=}")
             if next_flagged_index == -1:
                 next_flagged_index = len(args)
             args_consumed = await self._consume_all_positional_args(
@@ -694,7 +745,10 @@ class CommandArgumentParser:
             if spec.dest == "help":
                 continue
             if spec.required and not result.get(spec.dest):
-                raise CommandArgumentError(f"Missing required argument: {spec.dest}")
+                help_text = f" help: {spec.help}" if spec.help else ""
+                raise CommandArgumentError(
+                    f"Missing required argument {spec.dest}: {spec.get_choice_text()}{help_text}"
+                )
 
             if spec.choices and result.get(spec.dest) not in spec.choices:
                 raise CommandArgumentError(
@@ -809,22 +863,20 @@ class CommandArgumentParser:
                 self.console.print("[bold]positional:[/bold]")
                 for arg in self._positional.values():
                     flags = arg.get_positional_text()
-                    arg_line = Text(f"  {flags:<30} ")
+                    arg_line = f"  {flags:<30} "
                     help_text = arg.help or ""
                     if help_text and len(flags) > 30:
                         help_text = f"\n{'':<33}{help_text}"
-                    arg_line.append(help_text)
-                    self.console.print(arg_line)
+                    self.console.print(f"{arg_line}{help_text}")
             self.console.print("[bold]options:[/bold]")
             for arg in self._keyword_list:
                 flags = ", ".join(arg.flags)
                 flags_choice = f"{flags} {arg.get_choice_text()}"
-                arg_line = Text(f"  {flags_choice:<30} ")
+                arg_line = f"  {flags_choice:<30} "
                 help_text = arg.help or ""
                 if help_text and len(flags_choice) > 30:
                     help_text = f"\n{'':<33}{help_text}"
-                arg_line.append(help_text)
-                self.console.print(arg_line)
+                self.console.print(f"{arg_line}{help_text}")
 
         # Epilog
         if self.help_epilog:

falyx-0.1.56/falyx/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.56"

{falyx-0.1.54 → falyx-0.1.56}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "falyx"
-version = "0.1.54"
+version = "0.1.56"
 description = "Reliable and introspectable async CLI action framework."
 authors = ["Roland Thomas Jr <roland@rtj.dev>"]
 license = "MIT"

falyx-0.1.54/falyx/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.54"