falyx 0.1.58__py3-none-any.whl → 0.1.60__py3-none-any.whl

falyx/action/action_types.py

@@ -1,5 +1,5 @@
 # Falyx CLI Framework — (c) 2025 rtj.dev LLC — MIT Licensed
-"""types.py"""
+"""action_types.py"""
 from __future__ import annotations
 
 from enum import Enum

falyx/action/chained_action.py

@@ -17,6 +17,7 @@ from falyx.execution_registry import ExecutionRegistry as er
 from falyx.hook_manager import Hook, HookManager, HookType
 from falyx.logger import logger
 from falyx.options_manager import OptionsManager
+from falyx.signals import BreakChainSignal
 from falyx.themes import OneColors
 
 
@@ -106,7 +107,7 @@ class ChainedAction(BaseAction, ActionListMixin):
     def _clear_args(self):
         return (), {}
 
-    async def _run(self, *args, **kwargs) -> list[Any]:
+    async def _run(self, *args, **kwargs) -> Any:
         if not self.actions:
             raise EmptyChainError(f"[{self.name}] No actions to execute.")
 
@@ -166,7 +167,11 @@ class ChainedAction(BaseAction, ActionListMixin):
             context.result = all_results if self.return_list else all_results[-1]
             await self.hooks.trigger(HookType.ON_SUCCESS, context)
             return context.result
-
+        except BreakChainSignal as error:
+            logger.info("[%s] Chain broken: %s", self.name, error)
+            context.exception = error
+            shared_context.add_error(shared_context.current_index, error)
+            await self._rollback(context.extra["rollback_stack"], *args, **kwargs)
         except Exception as error:
             context.exception = error
             shared_context.add_error(shared_context.current_index, error)

falyx/action/confirm_action.py

@@ -56,13 +56,14 @@ class ConfirmAction(BaseAction):
         prompt_session (PromptSession | None): The session to use for input.
         confirm (bool): Whether to prompt the user for confirmation.
         word (str): The word to type for TYPE_WORD confirmation.
-        return_last_result (bool): Whether to return the last result of the action.
+        return_last_result (bool): Whether to return the last result of the action
+                                   instead of a boolean.
     """
 
     def __init__(
         self,
         name: str,
-        message: str = "Continue",
+        message: str = "Confirm?",
         confirm_type: ConfirmType | str = ConfirmType.YES_NO,
         prompt_session: PromptSession | None = None,
         confirm: bool = True,
@@ -114,16 +115,19 @@ class ConfirmAction(BaseAction):
                     session=self.prompt_session,
                 )
             case ConfirmType.YES_NO_CANCEL:
+                error_message = "Enter 'Y', 'y' to confirm, 'N', 'n' to decline, or 'C', 'c' to abort."
                 answer = await self.prompt_session.prompt_async(
-                    f"❓ {self.message} ([Y]es, [N]o, or [C]ancel to abort): ",
-                    validator=words_validator(["Y", "N", "C"]),
+                    f"❓ {self.message} [Y]es, [N]o, or [C]ancel to abort > ",
+                    validator=words_validator(
+                        ["Y", "N", "C"], error_message=error_message
+                    ),
                 )
                 if answer.upper() == "C":
                     raise CancelSignal(f"Action '{self.name}' was cancelled by the user.")
                 return answer.upper() == "Y"
             case ConfirmType.TYPE_WORD:
                 answer = await self.prompt_session.prompt_async(
-                    f"❓ {self.message} (type '{self.word}' to confirm or N/n): ",
+                    f"❓ {self.message} [{self.word}] to confirm or [N/n] > ",
                     validator=word_validator(self.word),
                 )
                 return answer.upper().strip() != "N"
@@ -138,9 +142,10 @@ class ConfirmAction(BaseAction):
                     raise CancelSignal(f"Action '{self.name}' was cancelled by the user.")
                 return answer
             case ConfirmType.OK_CANCEL:
+                error_message = "Enter 'O', 'o' to confirm or 'C', 'c' to abort."
                 answer = await self.prompt_session.prompt_async(
-                    f"❓ {self.message} ([O]k to continue, [C]ancel to abort): ",
-                    validator=words_validator(["O", "C"]),
+                    f"❓ {self.message} [O]k to confirm, [C]ancel to abort > ",
+                    validator=words_validator(["O", "C"], error_message=error_message),
                 )
                 if answer.upper() == "C":
                     raise CancelSignal(f"Action '{self.name}' was cancelled by the user.")
@@ -213,5 +218,5 @@ class ConfirmAction(BaseAction):
     def __str__(self) -> str:
         return (
             f"ConfirmAction(name={self.name}, message={self.message}, "
-            f"confirm_type={self.confirm_type})"
+            f"confirm_type={self.confirm_type}, return_last_result={self.return_last_result})"
         )

falyx/action/signal_action.py

@@ -14,7 +14,7 @@ class SignalAction(Action):
     Useful for exiting a menu, going back, or halting execution gracefully.
     """
 
-    def __init__(self, name: str, signal: Exception):
+    def __init__(self, name: str, signal: FlowSignal):
         self.signal = signal
         super().__init__(name, action=self.raise_signal)
 

falyx/bottom_bar.py

@@ -5,6 +5,7 @@ from typing import Any, Callable
 
 from prompt_toolkit.formatted_text import HTML, merge_formatted_text
 from prompt_toolkit.key_binding import KeyBindings
+from rich.console import Console
 
 from falyx.console import console
 from falyx.options_manager import OptionsManager

falyx/context.py

@@ -42,7 +42,7 @@ class ExecutionContext(BaseModel):
         kwargs (dict): Keyword arguments passed to the action.
         action (BaseAction | Callable): The action instance being executed.
         result (Any | None): The result of the action, if successful.
-        exception (Exception | None): The exception raised, if execution failed.
+        exception (BaseException | None): The exception raised, if execution failed.
         start_time (float | None): High-resolution performance start time.
         end_time (float | None): High-resolution performance end time.
         start_wall (datetime | None): Wall-clock timestamp when execution began.
@@ -75,7 +75,7 @@ class ExecutionContext(BaseModel):
     kwargs: dict = Field(default_factory=dict)
     action: Any
     result: Any | None = None
-    exception: Exception | None = None
+    exception: BaseException | None = None
 
     start_time: float | None = None
     end_time: float | None = None
@@ -207,7 +207,7 @@ class SharedContext(BaseModel):
     Attributes:
         name (str): Identifier for the context (usually the parent action name).
         results (list[Any]): Captures results from each action, in order of execution.
-        errors (list[tuple[int, Exception]]): Indexed list of errors from failed actions.
+        errors (list[tuple[int, BaseException]]): Indexed list of errors from failed actions.
         current_index (int): Index of the currently executing action (used in chains).
         is_parallel (bool): Whether the context is used in parallel mode (ActionGroup).
         shared_result (Any | None): Optional shared value available to all actions in
@@ -232,7 +232,7 @@ class SharedContext(BaseModel):
     name: str
     action: Any
     results: list[Any] = Field(default_factory=list)
-    errors: list[tuple[int, Exception]] = Field(default_factory=list)
+    errors: list[tuple[int, BaseException]] = Field(default_factory=list)
     current_index: int = -1
     is_parallel: bool = False
     shared_result: Any | None = None
@@ -244,7 +244,7 @@ class SharedContext(BaseModel):
     def add_result(self, result: Any) -> None:
         self.results.append(result)
 
-    def add_error(self, index: int, error: Exception) -> None:
+    def add_error(self, index: int, error: BaseException) -> None:
         self.errors.append((index, error))
 
     def set_shared_result(self, result: Any) -> None:

falyx/falyx.py

@@ -1,7 +1,5 @@
 # Falyx CLI Framework — (c) 2025 rtj.dev LLC — MIT Licensed
-"""falyx.py
-
-Main class for constructing and running Falyx CLI menus.
+"""Main class for constructing and running Falyx CLI menus.
 
 Falyx provides a structured, customizable interactive menu system
 for running commands, actions, and workflows. It supports:

falyx/parser/argument_action.py

@@ -12,6 +12,7 @@ class ArgumentAction(Enum):
     STORE = "store"
     STORE_TRUE = "store_true"
     STORE_FALSE = "store_false"
+    STORE_BOOL_OPTIONAL = "store_bool_optional"
     APPEND = "append"
     EXTEND = "extend"
     COUNT = "count"

falyx/parser/command_argument_parser.py

@@ -2,6 +2,7 @@
 """command_argument_parser.py"""
 from __future__ import annotations
 
+from collections import defaultdict
 from copy import deepcopy
 from typing import Any, Iterable
 
@@ -13,6 +14,7 @@ from falyx.console import console
 from falyx.exceptions import CommandArgumentError
 from falyx.parser.argument import Argument
 from falyx.parser.argument_action import ArgumentAction
+from falyx.parser.parser_types import false_none, true_none
 from falyx.parser.utils import coerce_value
 from falyx.signals import HelpSignal
 
@@ -33,6 +35,7 @@ class CommandArgumentParser:
     - Support for positional and keyword arguments.
     - Support for default values.
     - Support for boolean flags.
+    - Support for optional boolean flags.
     - Exception handling for invalid arguments.
     - Render Help using Rich library.
     """
@@ -111,10 +114,23 @@ class CommandArgumentParser:
         return dest
 
     def _determine_required(
-        self, required: bool, positional: bool, nargs: int | str | None
+        self,
+        required: bool,
+        positional: bool,
+        nargs: int | str | None,
+        action: ArgumentAction,
     ) -> bool:
         """Determine if the argument is required."""
         if required:
+            if action in (
+                ArgumentAction.STORE_TRUE,
+                ArgumentAction.STORE_FALSE,
+                ArgumentAction.STORE_BOOL_OPTIONAL,
+                ArgumentAction.HELP,
+            ):
+                raise CommandArgumentError(
+                    f"Argument with action {action} cannot be required"
+                )
             return True
         if positional:
             assert (
@@ -143,6 +159,7 @@ class CommandArgumentParser:
             ArgumentAction.STORE_TRUE,
             ArgumentAction.COUNT,
             ArgumentAction.HELP,
+            ArgumentAction.STORE_BOOL_OPTIONAL,
         ):
             if nargs is not None:
                 raise CommandArgumentError(
@@ -163,9 +180,17 @@ class CommandArgumentParser:
         return nargs
 
     def _normalize_choices(
-        self, choices: Iterable | None, expected_type: Any
+        self, choices: Iterable | None, expected_type: Any, action: ArgumentAction
     ) -> list[Any]:
         if choices is not None:
+            if action in (
+                ArgumentAction.STORE_TRUE,
+                ArgumentAction.STORE_FALSE,
+                ArgumentAction.STORE_BOOL_OPTIONAL,
+            ):
+                raise CommandArgumentError(
+                    f"choices cannot be specified for {action} actions"
+                )
             if isinstance(choices, dict):
                 raise CommandArgumentError("choices cannot be a dict")
             try:
@@ -239,6 +264,7 @@ class CommandArgumentParser:
         if action in (
             ArgumentAction.STORE_TRUE,
             ArgumentAction.STORE_FALSE,
+            ArgumentAction.STORE_BOOL_OPTIONAL,
             ArgumentAction.COUNT,
             ArgumentAction.HELP,
         ):
@@ -271,6 +297,14 @@ class CommandArgumentParser:
                 return []
             else:
                 return None
+        elif action in (
+            ArgumentAction.STORE_TRUE,
+            ArgumentAction.STORE_FALSE,
+            ArgumentAction.STORE_BOOL_OPTIONAL,
+        ):
+            raise CommandArgumentError(
+                f"Default value cannot be set for action {action}. It is a boolean flag."
+            )
         return default
 
     def _validate_flags(self, flags: tuple[str, ...]) -> None:
@@ -289,6 +323,66 @@ class CommandArgumentParser:
                     f"Flag '{flag}' must be a single character or start with '--'"
                 )
 
+    def _register_store_bool_optional(
+        self,
+        flags: tuple[str, ...],
+        dest: str,
+        help: str,
+    ) -> None:
+        if len(flags) != 1:
+            raise CommandArgumentError(
+                "store_bool_optional action can only have a single flag"
+            )
+        if not flags[0].startswith("--"):
+            raise CommandArgumentError(
+                "store_bool_optional action must use a long flag (e.g. --flag)"
+            )
+        base_flag = flags[0]
+        negated_flag = f"--no-{base_flag.lstrip('-')}"
+
+        argument = Argument(
+            flags=flags,
+            dest=dest,
+            action=ArgumentAction.STORE_BOOL_OPTIONAL,
+            type=true_none,
+            default=None,
+            help=help,
+        )
+
+        negated_argument = Argument(
+            flags=(negated_flag,),
+            dest=dest,
+            action=ArgumentAction.STORE_BOOL_OPTIONAL,
+            type=false_none,
+            default=None,
+            help=help,
+        )
+
+        self._register_argument(argument)
+        self._register_argument(negated_argument)
+
+    def _register_argument(self, argument: Argument):
+
+        for flag in argument.flags:
+            if (
+                flag in self._flag_map
+                and not argument.action == ArgumentAction.STORE_BOOL_OPTIONAL
+            ):
+                existing = self._flag_map[flag]
+                raise CommandArgumentError(
+                    f"Flag '{flag}' is already used by argument '{existing.dest}'"
+                )
+        for flag in argument.flags:
+            self._flag_map[flag] = argument
+            if not argument.positional:
+                self._keyword[flag] = argument
+        self._dest_set.add(argument.dest)
+        self._arguments.append(argument)
+        if argument.positional:
+            self._positional[argument.dest] = argument
+        else:
+            self._keyword_list.append(argument)
+
     def add_argument(
         self,
         *flags,
@@ -334,6 +428,7 @@ class CommandArgumentParser:
             )
         action = self._validate_action(action, positional)
         resolver = self._validate_resolver(action, resolver)
+
         nargs = self._validate_nargs(nargs, action)
         default = self._resolve_default(default, action, nargs)
         if (
@@ -344,46 +439,34 @@ class CommandArgumentParser:
                 self._validate_default_list_type(default, expected_type, dest)
             else:
                 self._validate_default_type(default, expected_type, dest)
-        choices = self._normalize_choices(choices, expected_type)
+        choices = self._normalize_choices(choices, expected_type, action)
         if default is not None and choices and default not in choices:
             raise CommandArgumentError(
                 f"Default value '{default}' not in allowed choices: {choices}"
             )
-        required = self._determine_required(required, positional, nargs)
+        required = self._determine_required(required, positional, nargs, action)
         if not isinstance(lazy_resolver, bool):
             raise CommandArgumentError(
                 f"lazy_resolver must be a boolean, got {type(lazy_resolver)}"
             )
-        argument = Argument(
-            flags=flags,
-            dest=dest,
-            action=action,
-            type=expected_type,
-            default=default,
-            choices=choices,
-            required=required,
-            help=help,
-            nargs=nargs,
-            positional=positional,
-            resolver=resolver,
-            lazy_resolver=lazy_resolver,
-        )
-        for flag in flags:
-            if flag in self._flag_map:
-                existing = self._flag_map[flag]
-                raise CommandArgumentError(
-                    f"Flag '{flag}' is already used by argument '{existing.dest}'"
-                )
-        for flag in flags:
-            self._flag_map[flag] = argument
-            if not positional:
-                self._keyword[flag] = argument
-        self._dest_set.add(dest)
-        self._arguments.append(argument)
-        if positional:
-            self._positional[dest] = argument
+        if action == ArgumentAction.STORE_BOOL_OPTIONAL:
+            self._register_store_bool_optional(flags, dest, help)
         else:
-            self._keyword_list.append(argument)
+            argument = Argument(
+                flags=flags,
+                dest=dest,
+                action=action,
+                type=expected_type,
+                default=default,
+                choices=choices,
+                required=required,
+                help=help,
+                nargs=nargs,
+                positional=positional,
+                resolver=resolver,
+                lazy_resolver=lazy_resolver,
+            )
+            self._register_argument(argument)
 
     def get_argument(self, dest: str) -> Argument | None:
         return next((a for a in self._arguments if a.dest == dest), None)
@@ -624,6 +707,10 @@ class CommandArgumentParser:
                 result[spec.dest] = False
                 consumed_indices.add(i)
                 i += 1
+            elif action == ArgumentAction.STORE_BOOL_OPTIONAL:
+                result[spec.dest] = spec.type(True)
+                consumed_indices.add(i)
+                i += 1
             elif action == ArgumentAction.COUNT:
                 result[spec.dest] = result.get(spec.dest, 0) + 1
                 consumed_indices.add(i)
@@ -889,11 +976,28 @@ class CommandArgumentParser:
                         help_text = f"\n{'':<33}{help_text}"
                     self.console.print(f"{arg_line}{help_text}")
             self.console.print("[bold]options:[/bold]")
+            arg_groups = defaultdict(list)
             for arg in self._keyword_list:
-                flags = ", ".join(arg.flags)
-                flags_choice = f"{flags} {arg.get_choice_text()}"
+                arg_groups[arg.dest].append(arg)
+
+            for group in arg_groups.values():
+                if len(group) == 2 and all(
+                    arg.action == ArgumentAction.STORE_BOOL_OPTIONAL for arg in group
+                ):
+                    # Merge --flag / --no-flag pair into single help line for STORE_BOOL_OPTIONAL
+                    all_flags = tuple(
+                        sorted(
+                            (arg.flags[0] for arg in group),
+                            key=lambda f: f.startswith("--no-"),
+                        )
+                    )
+                else:
+                    all_flags = group[0].flags
+
+                flags = ", ".join(all_flags)
+                flags_choice = f"{flags} {group[0].get_choice_text()}"
                 arg_line = f"  {flags_choice:<30} "
-                help_text = arg.help or ""
+                help_text = group[0].help or ""
                 if help_text and len(flags_choice) > 30:
                     help_text = f"\n{'':<33}{help_text}"
                 self.console.print(f"{arg_line}{help_text}")

falyx/parser/parser_types.py

@@ -0,0 +1,15 @@
+# Falyx CLI Framework — (c) 2025 rtj.dev LLC — MIT Licensed
+"""parser_types.py"""
+from typing import Any
+
+
+def true_none(value: Any) -> bool | None:
+    if value is None:
+        return None
+    return True
+
+
+def false_none(value: Any) -> bool | None:
+    if value is None:
+        return None
+    return False

falyx/parser/parsers.py

@@ -56,6 +56,39 @@ def get_root_parser(
     allow_abbrev: bool = True,
     exit_on_error: bool = True,
 ) -> ArgumentParser:
+    """
+    Construct the root-level ArgumentParser for the Falyx CLI.
+
+    This parser handles global arguments shared across subcommands and can serve
+    as the base parser for the Falyx CLI or standalone applications. It includes
+    options for verbosity, debug logging, and version output.
+
+    Args:
+        prog (str | None): Name of the program (e.g., 'falyx').
+        usage (str | None): Optional custom usage string.
+        description (str | None): Description shown in the CLI help.
+        epilog (str | None): Message displayed at the end of help output.
+        parents (Sequence[ArgumentParser] | None): Optional parent parsers.
+        prefix_chars (str): Characters to denote optional arguments (default: "-").
+        fromfile_prefix_chars (str | None): Prefix to indicate argument file input.
+        argument_default (Any): Global default value for arguments.
+        conflict_handler (str): Strategy to resolve conflicting argument names.
+        add_help (bool): Whether to include help (`-h/--help`) in this parser.
+        allow_abbrev (bool): Allow abbreviated long options.
+        exit_on_error (bool): Exit immediately on error or raise an exception.
+
+    Returns:
+        ArgumentParser: The root parser with global options attached.
+
+    Notes:
+        ```
+        Includes the following arguments:
+            --never-prompt       : Run in non-interactive mode.
+            -v / --verbose       : Enable debug logging.
+            --debug-hooks        : Enable hook lifecycle debug logs.
+            --version            : Print the Falyx version.
+        ```
+    """
     parser = ArgumentParser(
         prog=prog,
         usage=usage,
@@ -92,7 +125,30 @@ def get_subparsers(
     title: str = "Falyx Commands",
     description: str | None = "Available commands for the Falyx CLI.",
 ) -> _SubParsersAction:
-    """Create and return a subparsers action for the given parser."""
+    """
+    Create and return a subparsers object for registering Falyx CLI subcommands.
+
+    This function adds a `subparsers` block to the given root parser, enabling
+    structured subcommands such as `run`, `run-all`, `preview`, etc.
+
+    Args:
+        parser (ArgumentParser): The root parser to attach the subparsers to.
+        title (str): Title used in help output to group subcommands.
+        description (str | None): Optional text describing the group of subcommands.
+
+    Returns:
+        _SubParsersAction: The subparsers object that can be used to add new CLI subcommands.
+
+    Raises:
+        TypeError: If `parser` is not an instance of `ArgumentParser`.
+
+    Example:
+        ```python
+        >>> parser = get_root_parser()
+        >>> subparsers = get_subparsers(parser, title="Available Commands")
+        >>> subparsers.add_parser("run", help="Run a Falyx command")
+        ```
+    """
     if not isinstance(parser, ArgumentParser):
         raise TypeError("parser must be an instance of ArgumentParser")
     subparsers = parser.add_subparsers(
@@ -122,7 +178,54 @@ def get_arg_parsers(
     root_parser: ArgumentParser | None = None,
     subparsers: _SubParsersAction | None = None,
 ) -> FalyxParsers:
-    """Returns the argument parser for the CLI."""
+    """
+    Create and return the full suite of argument parsers used by the Falyx CLI.
+
+    This function builds the root parser and all subcommand parsers used for structured
+    CLI workflows in Falyx. It supports standard subcommands including `run`, `run-all`,
+    `preview`, `list`, and `version`, and integrates with registered `Command` objects
+    to populate dynamic help and usage documentation.
+
+    Args:
+        prog (str | None): Program name to display in help and usage messages.
+        usage (str | None): Optional usage message to override the default.
+        description (str | None): Description for the CLI root parser.
+        epilog (str | None): Epilog message shown after the help text.
+        parents (Sequence[ArgumentParser] | None): Optional parent parsers.
+        prefix_chars (str): Characters that prefix optional arguments.
+        fromfile_prefix_chars (str | None): Prefix character for reading args from file.
+        argument_default (Any): Default value for arguments if not specified.
+        conflict_handler (str): Strategy for resolving conflicting arguments.
+        add_help (bool): Whether to add the `-h/--help` option to the root parser.
+        allow_abbrev (bool): Whether to allow abbreviated long options.
+        exit_on_error (bool): Whether the parser exits on error or raises.
+        commands (dict[str, Command] | None): Optional dictionary of registered commands
+            to populate help and subcommand descriptions dynamically.
+        root_parser (ArgumentParser | None): Custom root parser to use instead of building one.
+        subparsers (_SubParsersAction | None): Optional existing subparser object to extend.
+
+    Returns:
+        FalyxParsers: A structured container of all parsers, including `run`, `run-all`,
+                      `preview`, `list`, `version`, and the root parser.
+
+    Raises:
+        TypeError: If `root_parser` is not an instance of ArgumentParser or
+                   `subparsers` is not an instance of _SubParsersAction.
+
+    Example:
+        ```python
+        >>> parsers = get_arg_parsers(commands=my_command_dict)
+        >>> args = parsers.root.parse_args()
+        ```
+
+    Notes:
+        - This function integrates dynamic command usage and descriptions if the
+          `commands` argument is provided.
+        - The `run` parser supports additional options for retry logic and confirmation
+          prompts.
+        - The `run-all` parser executes all commands matching a tag.
+        - Use `falyx run ?[COMMAND]` from the CLI to preview a command.
+    """
     if epilog is None:
         epilog = f"Tip: Use '{prog} run ?[COMMAND]' to preview any command from the CLI."
     if root_parser is None:

falyx/parser/utils.py

@@ -15,9 +15,9 @@ def coerce_bool(value: str) -> bool:
     if isinstance(value, bool):
         return value
     value = value.strip().lower()
-    if value in {"true", "1", "yes", "on"}:
+    if value in {"true", "t", "1", "yes", "on"}:
         return True
-    elif value in {"false", "0", "no", "off"}:
+    elif value in {"false", "f", "0", "no", "off"}:
         return False
     return bool(value)
 

falyx/signals.py

@@ -10,6 +10,13 @@ class FlowSignal(BaseException):
     """
 
 
+class BreakChainSignal(FlowSignal):
+    """Raised to break the current action chain and return to the previous context."""
+
+    def __init__(self, message: str = "Break chain signal received."):
+        super().__init__(message)
+
+
 class QuitSignal(FlowSignal):
     """Raised to signal an immediate exit from the CLI framework."""
 

falyx/validators.py

@@ -44,10 +44,12 @@ def yes_no_validator() -> Validator:
             return False
         return True
 
-    return Validator.from_callable(validate, error_message="Enter 'Y' or 'n'.")
+    return Validator.from_callable(validate, error_message="Enter 'Y', 'y' or 'N', 'n'.")
 
 
-def words_validator(keys: Sequence[str] | KeysView[str]) -> Validator:
+def words_validator(
+    keys: Sequence[str] | KeysView[str], error_message: str | None = None
+) -> Validator:
     """Validator for specific word inputs."""
 
     def validate(text: str) -> bool:
@@ -55,9 +57,10 @@ def words_validator(keys: Sequence[str] | KeysView[str]) -> Validator:
             return False
         return True
 
-    return Validator.from_callable(
-        validate, error_message=f"Invalid input. Choices: {{{', '.join(keys)}}}."
-    )
+    if error_message is None:
+        error_message = f"Invalid input. Choices: {{{', '.join(keys)}}}."
+
+    return Validator.from_callable(validate, error_message=error_message)
 
 
 def word_validator(word: str) -> Validator:
@@ -68,7 +71,7 @@ def word_validator(word: str) -> Validator:
             return True
         return text.upper().strip() == word.upper()
 
-    return Validator.from_callable(validate, error_message=f"Enter '{word}' or 'N'.")
+    return Validator.from_callable(validate, error_message=f"Enter '{word}' or 'N', 'n'.")
 
 
 class MultiIndexValidator(Validator):

falyx/version.py

@@ -1 +1 @@
-__version__ = "0.1.58"
+__version__ = "0.1.60"

{falyx-0.1.58.dist-info → falyx-0.1.60.dist-info}/METADATA

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

{falyx-0.1.58.dist-info → falyx-0.1.60.dist-info}/RECORD

@@ -7,10 +7,10 @@ falyx/action/action.py,sha256=Pm9lnxKhJoI1vs-fadAJrXkcDGYcBCMwvQ81HHxd0HA,5879
 falyx/action/action_factory.py,sha256=WosLeaYf79e83XHAAkxKi62zi8jJEiVlzvgOC84Z7t0,4840
 falyx/action/action_group.py,sha256=RQdHOWCa8XRUme3S5YGJTICLozIApAlIpRUgEeFaiyw,7728
 falyx/action/action_mixins.py,sha256=oUrjbweCeateshg3tqtbQiGuV8u4GvlioIZCUr9D1m4,1244
-falyx/action/action_types.py,sha256=oG8qIFObZdiU1VZQlnWzR8uBDq8rcxzkCli9A31_tMI,1460
+falyx/action/action_types.py,sha256=TfzZ8y560h9RWu8Sh1HAbQVRlSAWJZcTdBMbQ-STbQY,1467
 falyx/action/base_action.py,sha256=o9Nml70-SEVTXnu9J0-VYnO-t5wZZM0o59lYDth24Po,5829
-falyx/action/chained_action.py,sha256=oknG4ACr79Yf7jb4jvpp6Au7VJLz3PRqABzUKJLn_eY,9274
-falyx/action/confirm_action.py,sha256=HCzDBQMX1I_cquV_26ppKPfB0GJjr24v12kaZ4Q6bSU,8700
+falyx/action/chained_action.py,sha256=TNJz25jnzQQAIwXM6uaK8mzhq4bgRks5n7IZ2nDQM6Q,9614
+falyx/action/confirm_action.py,sha256=oXPnZswkQFJ-F-s73vddpF-BRg1wJeVnHjR4K2yN7ow,9085
 falyx/action/fallback_action.py,sha256=3FGWfoR1MIgY0ZkDNOpKu8p3JqPWzh5ON3943mfgDGs,1708
 falyx/action/http_action.py,sha256=DNeSBWh58UTFGlfFyTk2GnhS54hpLAJLC0QNbq2cYic,5799
 falyx/action/io_action.py,sha256=V888tQgAynqsVvkhICnEeE4wRs2vvdTcdlEpDSEbHqo,6128
@@ -24,18 +24,18 @@ falyx/action/save_file_action.py,sha256=Pe_j0hZjDNsO14bykzVYM0gkWB3zmpB1cExSN01I
 falyx/action/select_file_action.py,sha256=PcV22_wiPeDoJLIhHRiEUmW8N3pYeqQZMVTscQKXuas,9867
 falyx/action/selection_action.py,sha256=L1evMm7oAQFGMviZ8nMwFKhWKWe8X7wW6dJPHGxpqAE,15398
 falyx/action/shell_action.py,sha256=0A_kvZLsYmeLHInMM_4Jpe8GCSnXzGBm7H9PnXPvbAs,4055
-falyx/action/signal_action.py,sha256=5UMqvzy7fBnLANGwYUWoe1VRhrr7e-yOVeLdOnCBiJo,1350
+falyx/action/signal_action.py,sha256=GxV-0zqYqODOQUa3-tvFTZ2AS1W1QpW6ExonxmWNWbs,1351
 falyx/action/user_input_action.py,sha256=Up47lumscxnhORMvaft0X-NWpxTXc2GmMZMua__pGhA,3524
-falyx/bottom_bar.py,sha256=QYAuWWOM_FVObuRrGrZWOYvuvL45cnYDtV34s5B1qFU,7372
+falyx/bottom_bar.py,sha256=B62N3YCQF_h2Rw_hpc2_FUuLNARI-XIGbQkg-1XvaYE,7405
 falyx/command.py,sha256=QdcwLEFIaq3a4Lfot4cV3zHbVJNQxwSpShprBgLBkh8,16891
 falyx/completer.py,sha256=EODbakx5PFAwjNcfuUZPFuSx2Q9MXBlWRZJ2LejF6DI,1686
 falyx/config.py,sha256=OFEq9pFhV39o6_D7dP_QUDjqEusSQNpgomRsh5AAZYY,9621
 falyx/console.py,sha256=WIZ004R9x6DJp2g3onBQ4DOJ7iDeTOr8HqJCwRt30Rc,143
-falyx/context.py,sha256=SuQxxYuv1cb__EieJyRHp7opO-9T5KsMPxruEjVN36Q,10784
+falyx/context.py,sha256=M7iWEKto_NwI3GM-VCDPwXT0dBpFPf1Y_RvHQKodZgI,10804
 falyx/debug.py,sha256=pguI0XQcZ-7jte5YUPexAufa1oxxalYO1JgmO6GU3rI,1557
 falyx/exceptions.py,sha256=58D4BYkyJ7PlpZoNk37GsUsFThm_gIlb2Ex2XXhLklI,1099
 falyx/execution_registry.py,sha256=RLRMOEmfDElFy4tuC8L9tRyNToX7GJ4GoEBh2Iri8zo,7662
-falyx/falyx.py,sha256=5pOpYHuw6VZqjC9tszA6wgvahOfxmmIPDtzphcVOVi4,49342
+falyx/falyx.py,sha256=6hKcD1RC-jTPA0WiF9JJ31QkacNJAJwqoqO1zhegwoM,49332
 falyx/falyx_completer.py,sha256=MsfuZXpfGwbsGG-4Zp-j-vNsNnaote-UAJkJh0s2NZI,5236
 falyx/hook_manager.py,sha256=TFuHQnAncS_rk6vuw-VSx8bnAppLuHfrZCrzLwqcO9o,2979
 falyx/hooks.py,sha256=xMfQROib0BNsaQF4AXJpmCiGePoE1f1xpcdibgnVZWM,2913
@@ -46,25 +46,26 @@ falyx/options_manager.py,sha256=dFAnQw543tQ6Xupvh1PwBrhiSWlSACHw8K-sHP_lUh4,2842
 falyx/parser/.pytyped,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 falyx/parser/__init__.py,sha256=NbxAovKIY-duFTs6DAsdM_OzL7s3VIu19KMOmltX9ts,512
 falyx/parser/argument.py,sha256=MIKUj-hrdLDUK8xuW84_l9ms_t5CoNFpVDmxMZIbW-I,4105
-falyx/parser/argument_action.py,sha256=rNVeth0eMpkZRU_eT1RPVxOGzD4pbdAMx9Kq07T4mG4,709
-falyx/parser/command_argument_parser.py,sha256=Ej4gYOxSUOYfLr5b0KkZkC0OkuSUrj54JpuI0D0C6h4,37504
-falyx/parser/parsers.py,sha256=X3eEltxBbwRwWG5Q1A1GqSdQCJZAYN5Eub0_U6dlBN4,9159
+falyx/parser/argument_action.py,sha256=Lcpb9siYr_q2T8qU-jXVtqFb11bFPPKEGH3gurJv2NM,757
+falyx/parser/command_argument_parser.py,sha256=lWPeoYj0NUMbBsXrf-Z3KUo4osYrRERoXA_Uu3HmF9w,41264
+falyx/parser/parser_types.py,sha256=DLLuIXE8cAVLS41trfsNy-XJmtqSa1HfnJVAYIIc42w,315
+falyx/parser/parsers.py,sha256=vb-l_NNh5O9L98Lcafhz91flRLxC1BnW6U8JdeabRCw,14118
 falyx/parser/signature.py,sha256=fSltLEr8ctj1qpbU-OvTMnREjlb8OTG5t-guJFR7j4E,2529
-falyx/parser/utils.py,sha256=km6WvoPUgVdoIpPwDfr6axyjyy8iZy8xndwBNprI2Lk,2996
+falyx/parser/utils.py,sha256=GlxB1WORwoJ5XUtmmAVBUPaDV2nF9Hio7TbvNJvd8oY,3006
 falyx/prompt_utils.py,sha256=qgk0bXs7mwzflqzWyFhEOTpKQ_ZtMIqGhKeg-ocwNnE,1542
 falyx/protocols.py,sha256=vd9JL-TXdLEiAQXLw2UKLd3MUMivoG7iMLo08ZggwYQ,539
 falyx/retry.py,sha256=sGRE9QhdZK98M99G8F15WUsJ_fYLNyLlCgu3UANaSQs,3744
 falyx/retry_utils.py,sha256=IqvEy_F0dXG8Yl2UoEJVLX-6OXk-dh-D72_SWv4w-p0,730
 falyx/selection.py,sha256=Q2GrpiRyuV8KwVrZGuK2WZvihZ0VIylyvckJKYwrC-A,14629
-falyx/signals.py,sha256=Y_neFXpfHs7qY0syw9XcfR9WeAGRcRw1nG_2L1JJqKE,1083
+falyx/signals.py,sha256=at_COqTdDQIqzDY05nc5BChU1R_lJ28ghR5lNLYaDtI,1314
 falyx/tagged_table.py,sha256=4SV-SdXFrAhy1JNToeBCvyxT-iWVf6cWY7XETTys4n8,1067
 falyx/themes/__init__.py,sha256=1CZhEUCin9cUk8IGYBUFkVvdHRNNJBEFXccHwpUKZCA,284
 falyx/themes/colors.py,sha256=4aaeAHJetmeNInI0Zytg4E3YqKfPFelpf04vtjSvsS8,19776
 falyx/utils.py,sha256=U45xnZFUdoFC4xiji_9S1jHS5V7MvxSDtufP8EgB0SM,6732
-falyx/validators.py,sha256=DHq-ELpeYVHvRg9daY4Te6ufAf4ryUAM7i_uF7B15Sc,5919
-falyx/version.py,sha256=ujgZXX_cw13M2UkyXWVg5j1fgdE25Qb3rUzLZVokSKg,23
-falyx-0.1.58.dist-info/LICENSE,sha256=B0yqgaHuSdhN7T3OBmgQSiDTy8HqT5Oe_dLypRe4Ra4,1073
-falyx-0.1.58.dist-info/METADATA,sha256=Kz5boaWHPPVBRUvQEJFrOOnQZdwUcGGTnwwQ5lsTaTg,5561
-falyx-0.1.58.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-falyx-0.1.58.dist-info/entry_points.txt,sha256=j8owOSl2j1Ss8DtGMnKfgehKaolqnIPhVFHaUBLUnMs,45
-falyx-0.1.58.dist-info/RECORD,,
+falyx/validators.py,sha256=AXpMGnk1_7J7MAbbol6pkMAiSIdNHoF5pwtA2-xS6H8,6029
+falyx/version.py,sha256=SH6dBtwKkjChke7DXHi0Y5HbtzV16-5wAfhv91d_D0A,23
+falyx-0.1.60.dist-info/LICENSE,sha256=B0yqgaHuSdhN7T3OBmgQSiDTy8HqT5Oe_dLypRe4Ra4,1073
+falyx-0.1.60.dist-info/METADATA,sha256=8GLh3rrDHvaz6XtiNJCau_CDE9iJGeHVYnlrDlFMXc4,5561
+falyx-0.1.60.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+falyx-0.1.60.dist-info/entry_points.txt,sha256=j8owOSl2j1Ss8DtGMnKfgehKaolqnIPhVFHaUBLUnMs,45
+falyx-0.1.60.dist-info/RECORD,,

{falyx-0.1.58.dist-info → falyx-0.1.60.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any