falyx 0.1.29__py3-none-any.whl → 0.1.31__py3-none-any.whl

falyx/command.py

@@ -19,7 +19,6 @@ in building robust interactive menus.
 from __future__ import annotations
 
 import shlex
-from functools import cached_property
 from typing import Any, Callable
 
 from prompt_toolkit.formatted_text import FormattedText
@@ -27,25 +26,15 @@ from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, field_validator
 from rich.console import Console
 from rich.tree import Tree
 
-from falyx.action.action import (
-    Action,
-    ActionGroup,
-    BaseAction,
-    ChainedAction,
-    ProcessAction,
-)
-from falyx.action.io_action import BaseIOAction
+from falyx.action.action import Action, BaseAction
 from falyx.context import ExecutionContext
 from falyx.debug import register_debug_hooks
 from falyx.execution_registry import ExecutionRegistry as er
 from falyx.hook_manager import HookManager, HookType
 from falyx.logger import logger
 from falyx.options_manager import OptionsManager
-from falyx.parsers import (
-    CommandArgumentParser,
-    infer_args_from_func,
-    same_argument_definitions,
-)
+from falyx.parsers.argparse import CommandArgumentParser
+from falyx.parsers.signature import infer_args_from_func
 from falyx.prompt_utils import confirm_async, should_prompt_user
 from falyx.protocols import ArgParserProtocol
 from falyx.retry import RetryPolicy
@@ -99,7 +88,6 @@ class Command(BaseModel):
         retry_policy (RetryPolicy): Retry behavior configuration.
         tags (list[str]): Organizational tags for the command.
         logging_hooks (bool): Whether to attach logging hooks automatically.
-        requires_input (bool | None): Indicates if the action needs input.
         options_manager (OptionsManager): Manages global command-line options.
         arg_parser (CommandArgumentParser): Parses command arguments.
         custom_parser (ArgParserProtocol | None): Custom argument parser.
@@ -116,7 +104,7 @@ class Command(BaseModel):
 
     key: str
     description: str
-    action: BaseAction | Callable[[Any], Any]
+    action: BaseAction | Callable[..., Any]
     args: tuple = ()
     kwargs: dict[str, Any] = Field(default_factory=dict)
     hidden: bool = False
@@ -138,14 +126,13 @@ class Command(BaseModel):
     retry_policy: RetryPolicy = Field(default_factory=RetryPolicy)
     tags: list[str] = Field(default_factory=list)
     logging_hooks: bool = False
-    requires_input: bool | None = None
     options_manager: OptionsManager = Field(default_factory=OptionsManager)
     arg_parser: CommandArgumentParser = Field(default_factory=CommandArgumentParser)
     arguments: list[dict[str, Any]] = Field(default_factory=list)
     argument_config: Callable[[CommandArgumentParser], None] | None = None
     custom_parser: ArgParserProtocol | None = None
     custom_help: Callable[[], str | None] | None = None
-    auto_args: bool = False
+    auto_args: bool = True
     arg_metadata: dict[str, str | dict[str, Any]] = Field(default_factory=dict)
 
     _context: ExecutionContext | None = PrivateAttr(default=None)
@@ -155,7 +142,7 @@ class Command(BaseModel):
     def parse_args(
         self, raw_args: list[str] | str, from_validate: bool = False
     ) -> tuple[tuple, dict]:
-        if self.custom_parser:
+        if callable(self.custom_parser):
             if isinstance(raw_args, str):
                 try:
                     raw_args = shlex.split(raw_args)
@@ -192,28 +179,15 @@ class Command(BaseModel):
     def get_argument_definitions(self) -> list[dict[str, Any]]:
         if self.arguments:
             return self.arguments
-        elif self.argument_config:
+        elif callable(self.argument_config):
             self.argument_config(self.arg_parser)
         elif self.auto_args:
-            if isinstance(self.action, (Action, ProcessAction)):
-                return infer_args_from_func(self.action.action, self.arg_metadata)
-            elif isinstance(self.action, ChainedAction):
-                if self.action.actions:
-                    action = self.action.actions[0]
-                    if isinstance(action, Action):
-                        return infer_args_from_func(action.action, self.arg_metadata)
-                    elif callable(action):
-                        return infer_args_from_func(action, self.arg_metadata)
-            elif isinstance(self.action, ActionGroup):
-                arg_defs = same_argument_definitions(
-                    self.action.actions, self.arg_metadata
-                )
-                if arg_defs:
-                    return arg_defs
-                logger.debug(
-                    "[Command:%s] auto_args disabled: mismatched ActionGroup arguments",
-                    self.key,
-                )
+            if isinstance(self.action, BaseAction):
+                infer_target, maybe_metadata = self.action.get_infer_target()
+                # merge metadata with the action's metadata if not already in self.arg_metadata
+                if maybe_metadata:
+                    self.arg_metadata = {**maybe_metadata, **self.arg_metadata}
+                return infer_args_from_func(infer_target, self.arg_metadata)
             elif callable(self.action):
                 return infer_args_from_func(self.action, self.arg_metadata)
         return []
@@ -241,30 +215,9 @@ class Command(BaseModel):
         if self.logging_hooks and isinstance(self.action, BaseAction):
             register_debug_hooks(self.action.hooks)
 
-        if self.requires_input is None and self.detect_requires_input:
-            self.requires_input = True
-            self.hidden = True
-        elif self.requires_input is None:
-            self.requires_input = False
-
         for arg_def in self.get_argument_definitions():
             self.arg_parser.add_argument(*arg_def.pop("flags"), **arg_def)
 
-    @cached_property
-    def detect_requires_input(self) -> bool:
-        """Detect if the action requires input based on its type."""
-        if isinstance(self.action, BaseIOAction):
-            return True
-        elif isinstance(self.action, ChainedAction):
-            return (
-                isinstance(self.action.actions[0], BaseIOAction)
-                if self.action.actions
-                else False
-            )
-        elif isinstance(self.action, ActionGroup):
-            return any(isinstance(action, BaseIOAction) for action in self.action.actions)
-        return False
-
     def _inject_options_manager(self) -> None:
         """Inject the options manager into the action if applicable."""
         if isinstance(self.action, BaseAction):
@@ -357,7 +310,7 @@ class Command(BaseModel):
 
     def show_help(self) -> bool:
         """Display the help message for the command."""
-        if self.custom_help:
+        if callable(self.custom_help):
             output = self.custom_help()
             if output:
                 console.print(output)

falyx/config.py

@@ -98,7 +98,6 @@ class RawCommand(BaseModel):
     retry: bool = False
     retry_all: bool = False
     retry_policy: RetryPolicy = Field(default_factory=RetryPolicy)
-    requires_input: bool | None = None
     hidden: bool = False
     help_text: str = ""
 

falyx/falyx.py

@@ -61,9 +61,9 @@ from falyx.options_manager import OptionsManager
 from falyx.parsers import CommandArgumentParser, get_arg_parsers
 from falyx.protocols import ArgParserProtocol
 from falyx.retry import RetryPolicy
-from falyx.signals import BackSignal, CancelSignal, FlowSignal, HelpSignal, QuitSignal
+from falyx.signals import BackSignal, CancelSignal, HelpSignal, QuitSignal
 from falyx.themes import OneColors, get_nord_theme
-from falyx.utils import CaseInsensitiveDict, _noop, chunks, get_program_invocation
+from falyx.utils import CaseInsensitiveDict, _noop, chunks
 from falyx.version import __version__
 
 
@@ -90,7 +90,7 @@ class CommandValidator(Validator):
         if not choice:
             raise ValidationError(
                 message=self.error_message,
-                cursor_position=document.get_end_of_document_position(),
+                cursor_position=len(text),
             )
 
 
@@ -111,6 +111,8 @@ class Falyx:
     - Submenu nesting and action chaining
     - History tracking, help generation, and run key execution modes
     - Seamless CLI argument parsing and integration via argparse
+    - Declarative option management with OptionsManager
+    - Command level argument parsing and validation
     - Extensible with user-defined hooks, bottom bars, and custom layouts
 
     Args:
@@ -126,7 +128,7 @@ class Falyx:
         never_prompt (bool): Seed default for `OptionsManager["never_prompt"]`
         force_confirm (bool): Seed default for `OptionsManager["force_confirm"]`
         cli_args (Namespace | None): Parsed CLI arguments, usually from argparse.
-        options (OptionsManager | None): Declarative option mappings.
+        options (OptionsManager | None): Declarative option mappings for global state.
         custom_table (Callable[[Falyx], Table] | Table | None): Custom menu table
                                                                 generator.
 
@@ -158,8 +160,9 @@ class Falyx:
         force_confirm: bool = False,
         cli_args: Namespace | None = None,
         options: OptionsManager | None = None,
-        render_menu: Callable[["Falyx"], None] | None = None,
-        custom_table: Callable[["Falyx"], Table] | Table | None = None,
+        render_menu: Callable[[Falyx], None] | None = None,
+        custom_table: Callable[[Falyx], Table] | Table | None = None,
+        hide_menu_table: bool = False,
     ) -> None:
         """Initializes the Falyx object."""
         self.title: str | Markdown = title
@@ -183,8 +186,9 @@ class Falyx:
         self._never_prompt: bool = never_prompt
         self._force_confirm: bool = force_confirm
         self.cli_args: Namespace | None = cli_args
-        self.render_menu: Callable[["Falyx"], None] | None = render_menu
-        self.custom_table: Callable[["Falyx"], Table] | Table | None = custom_table
+        self.render_menu: Callable[[Falyx], None] | None = render_menu
+        self.custom_table: Callable[[Falyx], Table] | Table | None = custom_table
+        self.hide_menu_table: bool = hide_menu_table
         self.validate_options(cli_args, options)
         self._prompt_session: PromptSession | None = None
         self.mode = FalyxMode.MENU
@@ -287,8 +291,6 @@ class Falyx:
 
         for command in self.commands.values():
             help_text = command.help_text or command.description
-            if command.requires_input:
-                help_text += " [dim](requires input)[/dim]"
             table.add_row(
                 f"[{command.style}]{command.key}[/]",
                 ", ".join(command.aliases) if command.aliases else "",
@@ -445,7 +447,6 @@ class Falyx:
                 bottom_toolbar=self._get_bottom_bar_render(),
                 key_bindings=self.key_bindings,
                 validate_while_typing=False,
-                interrupt_exception=FlowSignal,
             )
         return self._prompt_session
 
@@ -526,7 +527,7 @@ class Falyx:
         key: str = "X",
         description: str = "Exit",
         aliases: list[str] | None = None,
-        action: Callable[[Any], Any] | None = None,
+        action: Callable[..., Any] | None = None,
         style: str = OneColors.DARK_RED,
         confirm: bool = False,
         confirm_message: str = "Are you sure?",
@@ -580,7 +581,7 @@ class Falyx:
         self,
         key: str,
         description: str,
-        action: BaseAction | Callable[[Any], Any],
+        action: BaseAction | Callable[..., Any],
         *,
         args: tuple = (),
         kwargs: dict[str, Any] | None = None,
@@ -608,13 +609,12 @@ class Falyx:
         retry: bool = False,
         retry_all: bool = False,
         retry_policy: RetryPolicy | None = None,
-        requires_input: bool | None = None,
         arg_parser: CommandArgumentParser | None = None,
         arguments: list[dict[str, Any]] | None = None,
         argument_config: Callable[[CommandArgumentParser], None] | None = None,
         custom_parser: ArgParserProtocol | None = None,
         custom_help: Callable[[], str | None] | None = None,
-        auto_args: bool = False,
+        auto_args: bool = True,
         arg_metadata: dict[str, str | dict[str, Any]] | None = None,
     ) -> Command:
         """Adds an command to the menu, preventing duplicates."""
@@ -660,7 +660,6 @@ class Falyx:
             retry=retry,
             retry_all=retry_all,
             retry_policy=retry_policy or RetryPolicy(),
-            requires_input=requires_input,
             options_manager=self.options,
             arg_parser=arg_parser,
             arguments=arguments or [],
@@ -768,26 +767,27 @@ class Falyx:
 
         choice = choice.upper()
         name_map = self._name_map
-        if choice in name_map:
+        if name_map.get(choice):
             if not from_validate:
                 logger.info("Command '%s' selected.", choice)
-            if input_args and name_map[choice].arg_parser:
-                try:
-                    args, kwargs = name_map[choice].parse_args(input_args, from_validate)
-                except CommandArgumentError as error:
-                    if not from_validate:
-                        if not name_map[choice].show_help():
-                            self.console.print(
-                                f"[{OneColors.DARK_RED}]❌ Invalid arguments for '{choice}': {error}"
-                            )
-                    else:
-                        name_map[choice].show_help()
-                        raise ValidationError(
-                            message=str(error), cursor_position=len(raw_choices)
+            if is_preview:
+                return True, name_map[choice], args, kwargs
+            try:
+                args, kwargs = name_map[choice].parse_args(input_args, from_validate)
+            except CommandArgumentError as error:
+                if not from_validate:
+                    if not name_map[choice].show_help():
+                        self.console.print(
+                            f"[{OneColors.DARK_RED}]❌ Invalid arguments for '{choice}': {error}"
                         )
-                    return is_preview, None, args, kwargs
-                except HelpSignal:
-                    return True, None, args, kwargs
+                else:
+                    name_map[choice].show_help()
+                    raise ValidationError(
+                        message=str(error), cursor_position=len(raw_choices)
+                    )
+                return is_preview, None, args, kwargs
+            except HelpSignal:
+                return True, None, args, kwargs
             return is_preview, name_map[choice], args, kwargs
 
         prefix_matches = [cmd for key, cmd in name_map.items() if key.startswith(choice)]
@@ -844,15 +844,6 @@ class Falyx:
             await selected_command.preview()
             return True
 
-        if selected_command.requires_input:
-            program = get_program_invocation()
-            self.console.print(
-                f"[{OneColors.LIGHT_YELLOW}]⚠️ Command '{selected_command.key}' requires"
-                f" input and must be run via [{OneColors.MAGENTA}]'{program} run"
-                f"'[{OneColors.LIGHT_YELLOW}] with proper piping or arguments.[/]"
-            )
-            return True
-
         self.last_run_command = selected_command
 
         if selected_command == self.exit_command:
@@ -984,10 +975,11 @@ class Falyx:
             self.print_message(self.welcome_message)
         try:
             while True:
-                if callable(self.render_menu):
-                    self.render_menu(self)
-                else:
-                    self.console.print(self.table, justify="center")
+                if not self.hide_menu_table:
+                    if callable(self.render_menu):
+                        self.render_menu(self)
+                    else:
+                        self.console.print(self.table, justify="center")
                 try:
                     task = asyncio.create_task(self.process_command())
                     should_continue = await task

falyx/hook_manager.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import inspect
 from enum import Enum
-from typing import Awaitable, Callable, Dict, List, Optional, Union
+from typing import Awaitable, Callable, Union
 
 from falyx.context import ExecutionContext
 from falyx.logger import logger
@@ -24,7 +24,7 @@ class HookType(Enum):
     ON_TEARDOWN = "on_teardown"
 
     @classmethod
-    def choices(cls) -> List[HookType]:
+    def choices(cls) -> list[HookType]:
         """Return a list of all hook type choices."""
         return list(cls)
 
@@ -37,16 +37,17 @@ class HookManager:
     """HookManager"""
 
     def __init__(self) -> None:
-        self._hooks: Dict[HookType, List[Hook]] = {
+        self._hooks: dict[HookType, list[Hook]] = {
             hook_type: [] for hook_type in HookType
         }
 
-    def register(self, hook_type: HookType, hook: Hook):
-        if hook_type not in HookType:
-            raise ValueError(f"Unsupported hook type: {hook_type}")
+    def register(self, hook_type: HookType | str, hook: Hook):
+        """Raises ValueError if the hook type is not supported."""
+        if not isinstance(hook_type, HookType):
+            hook_type = HookType(hook_type)
         self._hooks[hook_type].append(hook)
 
-    def clear(self, hook_type: Optional[HookType] = None):
+    def clear(self, hook_type: HookType | None = None):
         if hook_type:
             self._hooks[hook_type] = []
         else:

falyx/menu.py

@@ -33,7 +33,7 @@ class MenuOptionMap(CaseInsensitiveDict):
     and special signal entries like Quit and Back.
     """
 
-    RESERVED_KEYS = {"Q", "B"}
+    RESERVED_KEYS = {"B", "X"}
 
     def __init__(
         self,
@@ -49,14 +49,14 @@ class MenuOptionMap(CaseInsensitiveDict):
     def _inject_reserved_defaults(self):
         from falyx.action import SignalAction
 
-        self._add_reserved(
-            "Q",
-            MenuOption("Exit", SignalAction("Quit", QuitSignal()), OneColors.DARK_RED),
-        )
         self._add_reserved(
             "B",
             MenuOption("Back", SignalAction("Back", BackSignal()), OneColors.DARK_YELLOW),
         )
+        self._add_reserved(
+            "X",
+            MenuOption("Exit", SignalAction("Quit", QuitSignal()), OneColors.DARK_RED),
+        )
 
     def _add_reserved(self, key: str, option: MenuOption) -> None:
         """Add a reserved key, bypassing validation."""
@@ -78,8 +78,20 @@ class MenuOptionMap(CaseInsensitiveDict):
             raise ValueError(f"Cannot delete reserved option '{key}'.")
         super().__delitem__(key)
 
+    def update(self, other=None, **kwargs):
+        """Update the selection options with another dictionary."""
+        if other:
+            for key, option in other.items():
+                if not isinstance(option, MenuOption):
+                    raise TypeError(f"Value for key '{key}' must be a SelectionOption.")
+                self[key] = option
+        for key, option in kwargs.items():
+            if not isinstance(option, MenuOption):
+                raise TypeError(f"Value for key '{key}' must be a SelectionOption.")
+            self[key] = option
+
     def items(self, include_reserved: bool = True):
-        for k, v in super().items():
-            if not include_reserved and k in self.RESERVED_KEYS:
+        for key, option in super().items():
+            if not include_reserved and key in self.RESERVED_KEYS:
                 continue
-            yield k, v
+            yield key, option

falyx/parsers/__init__.py

@@ -7,8 +7,6 @@ Licensed under the MIT License. See LICENSE file for details.
 
 from .argparse import Argument, ArgumentAction, CommandArgumentParser
 from .parsers import FalyxParsers, get_arg_parsers
-from .signature import infer_args_from_func
-from .utils import same_argument_definitions
 
 __all__ = [
     "Argument",
@@ -16,6 +14,4 @@ __all__ = [
     "CommandArgumentParser",
     "get_arg_parsers",
     "FalyxParsers",
-    "infer_args_from_func",
-    "same_argument_definitions",
 ]

falyx/parsers/argparse.py

@@ -1,4 +1,6 @@
 # Falyx CLI Framework — (c) 2025 rtj.dev LLC — MIT Licensed
+from __future__ import annotations
+
 from copy import deepcopy
 from dataclasses import dataclass
 from enum import Enum
@@ -23,6 +25,15 @@ class ArgumentAction(Enum):
     COUNT = "count"
     HELP = "help"
 
+    @classmethod
+    def choices(cls) -> list[ArgumentAction]:
+        """Return a list of all argument actions."""
+        return list(cls)
+
+    def __str__(self) -> str:
+        """Return the string representation of the argument action."""
+        return self.value
+
 
 @dataclass
 class Argument:

falyx/parsers/signature.py

@@ -1,17 +1,20 @@
 import inspect
 from typing import Any, Callable
 
-from falyx import logger
+from falyx.logger import logger
 
 
 def infer_args_from_func(
-    func: Callable[[Any], Any],
+    func: Callable[[Any], Any] | None,
     arg_metadata: dict[str, str | dict[str, Any]] | None = None,
 ) -> list[dict[str, Any]]:
     """
     Infer argument definitions from a callable's signature.
     Returns a list of kwargs suitable for CommandArgumentParser.add_argument.
     """
+    if not callable(func):
+        logger.debug("Provided argument is not callable: %s", func)
+        return []
     arg_metadata = arg_metadata or {}
     signature = inspect.signature(func)
     arg_defs = []

falyx/parsers/utils.py

@@ -1,7 +1,6 @@
 from typing import Any
 
 from falyx import logger
-from falyx.action.action import Action, ChainedAction, ProcessAction
 from falyx.parsers.signature import infer_args_from_func
 
 
@@ -9,17 +8,13 @@ def same_argument_definitions(
     actions: list[Any],
     arg_metadata: dict[str, str | dict[str, Any]] | None = None,
 ) -> list[dict[str, Any]] | None:
+    from falyx.action.action import BaseAction
+
     arg_sets = []
     for action in actions:
-        if isinstance(action, (Action, ProcessAction)):
-            arg_defs = infer_args_from_func(action.action, arg_metadata)
-        elif isinstance(action, ChainedAction):
-            if action.actions:
-                action = action.actions[0]
-                if isinstance(action, Action):
-                    arg_defs = infer_args_from_func(action.action, arg_metadata)
-                elif callable(action):
-                    arg_defs = infer_args_from_func(action, arg_metadata)
+        if isinstance(action, BaseAction):
+            infer_target, _ = action.get_infer_target()
+            arg_defs = infer_args_from_func(infer_target, arg_metadata)
         elif callable(action):
             arg_defs = infer_args_from_func(action, arg_metadata)
         else:

falyx/selection.py

@@ -10,7 +10,7 @@ from rich.markup import escape
 from rich.table import Table
 
 from falyx.themes import OneColors
-from falyx.utils import chunks
+from falyx.utils import CaseInsensitiveDict, chunks
 from falyx.validators import int_range_validator, key_validator
 
 
@@ -32,6 +32,62 @@ class SelectionOption:
         return f"[{OneColors.WHITE}]{key}[/] [{self.style}]{self.description}[/]"
 
 
+class SelectionOptionMap(CaseInsensitiveDict):
+    """
+    Manages selection options including validation and reserved key protection.
+    """
+
+    RESERVED_KEYS: set[str] = set()
+
+    def __init__(
+        self,
+        options: dict[str, SelectionOption] | None = None,
+        allow_reserved: bool = False,
+    ):
+        super().__init__()
+        self.allow_reserved = allow_reserved
+        if options:
+            self.update(options)
+
+    def _add_reserved(self, key: str, option: SelectionOption) -> None:
+        """Add a reserved key, bypassing validation."""
+        norm_key = key.upper()
+        super().__setitem__(norm_key, option)
+
+    def __setitem__(self, key: str, option: SelectionOption) -> None:
+        if not isinstance(option, SelectionOption):
+            raise TypeError(f"Value for key '{key}' must be a SelectionOption.")
+        norm_key = key.upper()
+        if norm_key in self.RESERVED_KEYS and not self.allow_reserved:
+            raise ValueError(
+                f"Key '{key}' is reserved and cannot be used in SelectionOptionMap."
+            )
+        super().__setitem__(norm_key, option)
+
+    def __delitem__(self, key: str) -> None:
+        if key.upper() in self.RESERVED_KEYS and not self.allow_reserved:
+            raise ValueError(f"Cannot delete reserved option '{key}'.")
+        super().__delitem__(key)
+
+    def update(self, other=None, **kwargs):
+        """Update the selection options with another dictionary."""
+        if other:
+            for key, option in other.items():
+                if not isinstance(option, SelectionOption):
+                    raise TypeError(f"Value for key '{key}' must be a SelectionOption.")
+                self[key] = option
+        for key, option in kwargs.items():
+            if not isinstance(option, SelectionOption):
+                raise TypeError(f"Value for key '{key}' must be a SelectionOption.")
+            self[key] = option
+
+    def items(self, include_reserved: bool = True):
+        for k, v in super().items():
+            if not include_reserved and k in self.RESERVED_KEYS:
+                continue
+            yield k, v
+
+
 def render_table_base(
     title: str,
     *,

falyx/version.py

@@ -1 +1 @@
-__version__ = "0.1.29"
+__version__ = "0.1.31"

{falyx-0.1.29.dist-info → falyx-0.1.31.dist-info}/METADATA

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