falyx 0.1.52__py3-none-any.whl → 0.1.54__py3-none-any.whl

falyx/action/select_file_action.py

@@ -14,8 +14,8 @@ from prompt_toolkit import PromptSession
 from rich.console import Console
 from rich.tree import Tree
 
-from falyx.action.base import BaseAction
-from falyx.action.types import FileReturnType
+from falyx.action.action_types import FileType
+from falyx.action.base_action import BaseAction
 from falyx.context import ExecutionContext
 from falyx.execution_registry import ExecutionRegistry as er
 from falyx.hook_manager import HookType
@@ -50,7 +50,7 @@ class SelectFileAction(BaseAction):
         prompt_message (str): Message to display when prompting for selection.
         style (str): Style for the selection options.
         suffix_filter (str | None): Restrict to certain file types.
-        return_type (FileReturnType): What to return (path, content, parsed).
+        return_type (FileType): What to return (path, content, parsed).
         console (Console | None): Console instance for output.
         prompt_session (PromptSession | None): Prompt session for user input.
     """
@@ -65,7 +65,7 @@ class SelectFileAction(BaseAction):
         prompt_message: str = "Choose > ",
         style: str = OneColors.WHITE,
         suffix_filter: str | None = None,
-        return_type: FileReturnType | str = FileReturnType.PATH,
+        return_type: FileType | str = FileType.PATH,
         number_selections: int | str = 1,
         separator: str = ",",
         allow_duplicates: bool = False,
@@ -104,35 +104,38 @@ class SelectFileAction(BaseAction):
         else:
             raise ValueError("number_selections must be a positive integer or one of '*'")
 
-    def _coerce_return_type(self, return_type: FileReturnType | str) -> FileReturnType:
-        if isinstance(return_type, FileReturnType):
+    def _coerce_return_type(self, return_type: FileType | str) -> FileType:
+        if isinstance(return_type, FileType):
             return return_type
-        return FileReturnType(return_type)
+        elif isinstance(return_type, str):
+            return FileType(return_type)
+        else:
+            raise TypeError("return_type must be a FileType enum or string")
 
     def get_options(self, files: list[Path]) -> dict[str, SelectionOption]:
         value: Any
         options = {}
         for index, file in enumerate(files):
             try:
-                if self.return_type == FileReturnType.TEXT:
+                if self.return_type == FileType.TEXT:
                     value = file.read_text(encoding="UTF-8")
-                elif self.return_type == FileReturnType.PATH:
+                elif self.return_type == FileType.PATH:
                     value = file
-                elif self.return_type == FileReturnType.JSON:
+                elif self.return_type == FileType.JSON:
                     value = json.loads(file.read_text(encoding="UTF-8"))
-                elif self.return_type == FileReturnType.TOML:
+                elif self.return_type == FileType.TOML:
                     value = toml.loads(file.read_text(encoding="UTF-8"))
-                elif self.return_type == FileReturnType.YAML:
+                elif self.return_type == FileType.YAML:
                     value = yaml.safe_load(file.read_text(encoding="UTF-8"))
-                elif self.return_type == FileReturnType.CSV:
+                elif self.return_type == FileType.CSV:
                     with open(file, newline="", encoding="UTF-8") as csvfile:
                         reader = csv.reader(csvfile)
                         value = list(reader)
-                elif self.return_type == FileReturnType.TSV:
+                elif self.return_type == FileType.TSV:
                     with open(file, newline="", encoding="UTF-8") as tsvfile:
                         reader = csv.reader(tsvfile, delimiter="\t")
                         value = list(reader)
-                elif self.return_type == FileReturnType.XML:
+                elif self.return_type == FileType.XML:
                     tree = ET.parse(file, parser=ET.XMLParser(encoding="UTF-8"))
                     root = tree.getroot()
                     value = ET.tostring(root, encoding="unicode")

falyx/action/selection_action.py

@@ -6,8 +6,8 @@ from prompt_toolkit import PromptSession
 from rich.console import Console
 from rich.tree import Tree
 
-from falyx.action.base import BaseAction
-from falyx.action.types import SelectionReturnType
+from falyx.action.action_types import SelectionReturnType
+from falyx.action.base_action import BaseAction
 from falyx.context import ExecutionContext
 from falyx.execution_registry import ExecutionRegistry as er
 from falyx.hook_manager import HookType

falyx/action/user_input_action.py

@@ -5,7 +5,7 @@ from prompt_toolkit.validation import Validator
 from rich.console import Console
 from rich.tree import Tree
 
-from falyx.action.base import BaseAction
+from falyx.action.base_action import BaseAction
 from falyx.context import ExecutionContext
 from falyx.execution_registry import ExecutionRegistry as er
 from falyx.hook_manager import HookType

falyx/command.py

@@ -19,7 +19,7 @@ in building robust interactive menus.
 from __future__ import annotations
 
 import shlex
-from typing import Any, Callable
+from typing import Any, Awaitable, Callable
 
 from prompt_toolkit.formatted_text import FormattedText
 from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, field_validator
@@ -27,7 +27,7 @@ from rich.console import Console
 from rich.tree import Tree
 
 from falyx.action.action import Action
-from falyx.action.base import BaseAction
+from falyx.action.base_action import BaseAction
 from falyx.context import ExecutionContext
 from falyx.debug import register_debug_hooks
 from falyx.execution_registry import ExecutionRegistry as er
@@ -105,7 +105,7 @@ class Command(BaseModel):
 
     key: str
     description: str
-    action: BaseAction | Callable[..., Any]
+    action: BaseAction | Callable[..., Any] | Callable[..., Awaitable[Any]]
     args: tuple = ()
     kwargs: dict[str, Any] = Field(default_factory=dict)
     hidden: bool = False

falyx/config.py

@@ -14,7 +14,7 @@ from pydantic import BaseModel, Field, field_validator, model_validator
 from rich.console import Console
 
 from falyx.action.action import Action
-from falyx.action.base import BaseAction
+from falyx.action.base_action import BaseAction
 from falyx.command import Command
 from falyx.falyx import Falyx
 from falyx.logger import logger

falyx/exceptions.py

@@ -30,5 +30,13 @@ class EmptyChainError(FalyxError):
     """Exception raised when the chain is empty."""
 
 
+class EmptyGroupError(FalyxError):
+    """Exception raised when the chain is empty."""
+
+
+class EmptyPoolError(FalyxError):
+    """Exception raised when the chain is empty."""
+
+
 class CommandArgumentError(FalyxError):
     """Exception raised when there is an error in the command argument parser."""

falyx/falyx.py

@@ -43,7 +43,7 @@ from rich.markdown import Markdown
 from rich.table import Table
 
 from falyx.action.action import Action
-from falyx.action.base import BaseAction
+from falyx.action.base_action import BaseAction
 from falyx.bottom_bar import BottomBar
 from falyx.command import Command
 from falyx.context import ExecutionContext
@@ -346,7 +346,6 @@ class Falyx:
             aliases=["HISTORY"],
             action=Action(name="View Execution History", action=er.summary),
             style=OneColors.DARK_YELLOW,
-            simple_help_signature=True,
             arg_parser=parser,
             help_text="View the execution history of commands.",
         )
@@ -1152,7 +1151,7 @@ class Falyx:
             sys.exit(0)
 
         if self.cli_args.command == "version" or self.cli_args.version:
-            self.console.print(f"[{self.version_style}]{self.program} v{__version__}[/]")
+            self.console.print(f"[{self.version_style}]{self.program} v{self.version}[/]")
             sys.exit(0)
 
         if self.cli_args.command == "preview":

falyx/logger.py

@@ -2,4 +2,4 @@
 """logger.py"""
 import logging
 
-logger = logging.getLogger("falyx")
+logger: logging.Logger = logging.getLogger("falyx")

falyx/menu.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 
 from prompt_toolkit.formatted_text import FormattedText
 
-from falyx.action.base import BaseAction
+from falyx.action.base_action import BaseAction
 from falyx.signals import BackSignal, QuitSignal
 from falyx.themes import OneColors
 from falyx.utils import CaseInsensitiveDict

falyx/parser/argument.py

@@ -3,7 +3,7 @@
 from dataclasses import dataclass
 from typing import Any
 
-from falyx.action.base import BaseAction
+from falyx.action.base_action import BaseAction
 from falyx.parser.argument_action import ArgumentAction
 
 
@@ -46,6 +46,7 @@ class Argument:
                 ArgumentAction.STORE,
                 ArgumentAction.APPEND,
                 ArgumentAction.EXTEND,
+                ArgumentAction.ACTION,
             )
             and not self.positional
         ):
@@ -54,6 +55,7 @@ class Argument:
             ArgumentAction.STORE,
             ArgumentAction.APPEND,
             ArgumentAction.EXTEND,
+            ArgumentAction.ACTION,
         ) or isinstance(self.nargs, str):
             choice_text = self.dest
 

falyx/parser/command_argument_parser.py

@@ -9,7 +9,7 @@ from rich.console import Console
 from rich.markup import escape
 from rich.text import Text
 
-from falyx.action.base import BaseAction
+from falyx.action.base_action import BaseAction
 from falyx.exceptions import CommandArgumentError
 from falyx.parser.argument import Argument
 from falyx.parser.argument_action import ArgumentAction
@@ -177,20 +177,19 @@ class CommandArgumentParser:
         else:
             choices = []
         for choice in choices:
-            if not isinstance(choice, expected_type):
-                try:
-                    coerce_value(choice, expected_type)
-                except Exception as error:
-                    raise CommandArgumentError(
-                        f"Invalid choice {choice!r}: not coercible to {expected_type.__name__} error: {error}"
-                    ) from error
+            try:
+                coerce_value(choice, expected_type)
+            except Exception as error:
+                raise CommandArgumentError(
+                    f"Invalid choice {choice!r}: not coercible to {expected_type.__name__} error: {error}"
+                ) from error
         return choices
 
     def _validate_default_type(
         self, default: Any, expected_type: type, dest: str
     ) -> None:
         """Validate the default value type."""
-        if default is not None and not isinstance(default, expected_type):
+        if default is not None:
             try:
                 coerce_value(default, expected_type)
             except Exception as error:
@@ -203,13 +202,12 @@ class CommandArgumentParser:
     ) -> None:
         if isinstance(default, list):
             for item in default:
-                if not isinstance(item, expected_type):
-                    try:
-                        coerce_value(item, expected_type)
-                    except Exception as error:
-                        raise CommandArgumentError(
-                            f"Default list value {default!r} for '{dest}' cannot be coerced to {expected_type.__name__} error: {error}"
-                        ) from error
+                try:
+                    coerce_value(item, expected_type)
+                except Exception as error:
+                    raise CommandArgumentError(
+                        f"Default list value {default!r} for '{dest}' cannot be coerced to {expected_type.__name__} error: {error}"
+                    ) from error
 
     def _validate_resolver(
         self, action: ArgumentAction, resolver: BaseAction | None
@@ -422,22 +420,22 @@ class CommandArgumentParser:
                 raise CommandArgumentError(
                     f"Expected at least one value for '{spec.dest}'"
                 )
-            while i < len(args) and not args[i].startswith("-"):
+            while i < len(args) and args[i] not in self._keyword:
                 values.append(args[i])
                 i += 1
             assert values, "Expected at least one value for '+' nargs: shouldn't happen"
             return values, i
         elif spec.nargs == "*":
-            while i < len(args) and not args[i].startswith("-"):
+            while i < len(args) and args[i] not in self._keyword:
                 values.append(args[i])
                 i += 1
             return values, i
         elif spec.nargs == "?":
-            if i < len(args) and not args[i].startswith("-"):
+            if i < len(args) and args[i] not in self._keyword:
                 return [args[i]], i + 1
             return [], i
         elif spec.nargs is None:
-            if i < len(args) and not args[i].startswith("-"):
+            if i < len(args) and args[i] not in self._keyword:
                 return [args[i]], i + 1
             return [], i
         assert False, "Invalid nargs value: shouldn't happen"
@@ -524,23 +522,142 @@ class CommandArgumentParser:
 
         return i
 
-    def _expand_posix_bundling(self, args: list[str]) -> list[str]:
+    def _expand_posix_bundling(self, token: str) -> list[str] | str:
         """Expand POSIX-style bundled arguments into separate arguments."""
         expanded = []
-        for token in args:
-            if token.startswith("-") and not token.startswith("--") and len(token) > 2:
-                # POSIX bundle
-                # e.g. -abc -> -a -b -c
-                for char in token[1:]:
-                    flag = f"-{char}"
-                    arg = self._flag_map.get(flag)
-                    if not arg:
-                        raise CommandArgumentError(f"Unrecognized option: {flag}")
-                    expanded.append(flag)
-            else:
-                expanded.append(token)
+        if token.startswith("-") and not token.startswith("--") and len(token) > 2:
+            # POSIX bundle
+            # e.g. -abc -> -a -b -c
+            for char in token[1:]:
+                flag = f"-{char}"
+                arg = self._flag_map.get(flag)
+                if not arg:
+                    raise CommandArgumentError(f"Unrecognized option: {flag}")
+                expanded.append(flag)
+        else:
+            return token
         return expanded
 
+    async def _handle_token(
+        self,
+        token: str,
+        args: list[str],
+        i: int,
+        result: dict[str, Any],
+        positional_args: list[Argument],
+        consumed_positional_indices: set[int],
+        consumed_indices: set[int],
+        from_validate: bool = False,
+    ) -> int:
+        if token in self._keyword:
+            spec = self._keyword[token]
+            action = spec.action
+
+            if action == ArgumentAction.HELP:
+                if not from_validate:
+                    self.render_help()
+                raise HelpSignal()
+            elif action == ArgumentAction.ACTION:
+                assert isinstance(
+                    spec.resolver, BaseAction
+                ), "resolver should be an instance of BaseAction"
+                values, new_i = self._consume_nargs(args, i + 1, spec)
+                try:
+                    typed_values = [coerce_value(value, spec.type) for value in values]
+                except ValueError as error:
+                    raise CommandArgumentError(
+                        f"Invalid value for '{spec.dest}': {error}"
+                    ) from error
+                try:
+                    result[spec.dest] = await spec.resolver(*typed_values)
+                except Exception as error:
+                    raise CommandArgumentError(
+                        f"[{spec.dest}] Action failed: {error}"
+                    ) from error
+                consumed_indices.update(range(i, new_i))
+                i = new_i
+            elif action == ArgumentAction.STORE_TRUE:
+                result[spec.dest] = True
+                consumed_indices.add(i)
+                i += 1
+            elif action == ArgumentAction.STORE_FALSE:
+                result[spec.dest] = False
+                consumed_indices.add(i)
+                i += 1
+            elif action == ArgumentAction.COUNT:
+                result[spec.dest] = result.get(spec.dest, 0) + 1
+                consumed_indices.add(i)
+                i += 1
+            elif action == ArgumentAction.APPEND:
+                assert result.get(spec.dest) is not None, "dest should not be None"
+                values, new_i = self._consume_nargs(args, i + 1, spec)
+                try:
+                    typed_values = [coerce_value(value, spec.type) for value in values]
+                except ValueError as error:
+                    raise CommandArgumentError(
+                        f"Invalid value for '{spec.dest}': {error}"
+                    ) from error
+                if spec.nargs is None:
+                    result[spec.dest].append(spec.type(values[0]))
+                else:
+                    result[spec.dest].append(typed_values)
+                consumed_indices.update(range(i, new_i))
+                i = new_i
+            elif action == ArgumentAction.EXTEND:
+                assert result.get(spec.dest) is not None, "dest should not be None"
+                values, new_i = self._consume_nargs(args, i + 1, spec)
+                try:
+                    typed_values = [coerce_value(value, spec.type) for value in values]
+                except ValueError as error:
+                    raise CommandArgumentError(
+                        f"Invalid value for '{spec.dest}': {error}"
+                    ) from error
+                result[spec.dest].extend(typed_values)
+                consumed_indices.update(range(i, new_i))
+                i = new_i
+            else:
+                values, new_i = self._consume_nargs(args, i + 1, spec)
+                try:
+                    typed_values = [coerce_value(value, spec.type) for value in values]
+                except ValueError as error:
+                    raise CommandArgumentError(
+                        f"Invalid value for '{spec.dest}': {error}"
+                    ) from error
+                if not typed_values and spec.nargs not in ("*", "?"):
+                    raise CommandArgumentError(
+                        f"Expected at least one value for '{spec.dest}'"
+                    )
+                if spec.nargs in (None, 1, "?") and spec.action != ArgumentAction.APPEND:
+                    result[spec.dest] = (
+                        typed_values[0] if len(typed_values) == 1 else typed_values
+                    )
+                else:
+                    result[spec.dest] = typed_values
+                consumed_indices.update(range(i, new_i))
+                i = new_i
+        elif token.startswith("-"):
+            # Handle unrecognized option
+            raise CommandArgumentError(f"Unrecognized flag: {token}")
+        else:
+            # Get the next flagged argument index if it exists
+            next_flagged_index = -1
+            for index, arg in enumerate(args[i:], start=i):
+                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(
+                args[i:next_flagged_index],
+                result,
+                positional_args,
+                consumed_positional_indices,
+            )
+            i += args_consumed
+        return i
+
     async def parse_args(
         self, args: list[str] | None = None, from_validate: bool = False
     ) -> dict[str, Any]:
@@ -548,132 +665,29 @@ class CommandArgumentParser:
         if args is None:
             args = []
 
-        args = self._expand_posix_bundling(args)
-
         result = {arg.dest: deepcopy(arg.default) for arg in self._arguments}
-        positional_args = [arg for arg in self._arguments if arg.positional]
+        positional_args: list[Argument] = [
+            arg for arg in self._arguments if arg.positional
+        ]
         consumed_positional_indices: set[int] = set()
         consumed_indices: set[int] = set()
 
         i = 0
         while i < len(args):
-            token = args[i]
-            if token in self._keyword:
-                spec = self._keyword[token]
-                action = spec.action
-
-                if action == ArgumentAction.HELP:
-                    if not from_validate:
-                        self.render_help()
-                    raise HelpSignal()
-                elif action == ArgumentAction.ACTION:
-                    assert isinstance(
-                        spec.resolver, BaseAction
-                    ), "resolver should be an instance of BaseAction"
-                    values, new_i = self._consume_nargs(args, i + 1, spec)
-                    try:
-                        typed_values = [
-                            coerce_value(value, spec.type) for value in values
-                        ]
-                    except ValueError as error:
-                        raise CommandArgumentError(
-                            f"Invalid value for '{spec.dest}': {error}"
-                        ) from error
-                    try:
-                        result[spec.dest] = await spec.resolver(*typed_values)
-                    except Exception as error:
-                        raise CommandArgumentError(
-                            f"[{spec.dest}] Action failed: {error}"
-                        ) from error
-                    consumed_indices.update(range(i, new_i))
-                    i = new_i
-                elif action == ArgumentAction.STORE_TRUE:
-                    result[spec.dest] = True
-                    consumed_indices.add(i)
-                    i += 1
-                elif action == ArgumentAction.STORE_FALSE:
-                    result[spec.dest] = False
-                    consumed_indices.add(i)
-                    i += 1
-                elif action == ArgumentAction.COUNT:
-                    result[spec.dest] = result.get(spec.dest, 0) + 1
-                    consumed_indices.add(i)
-                    i += 1
-                elif action == ArgumentAction.APPEND:
-                    assert result.get(spec.dest) is not None, "dest should not be None"
-                    values, new_i = self._consume_nargs(args, i + 1, spec)
-                    try:
-                        typed_values = [
-                            coerce_value(value, spec.type) for value in values
-                        ]
-                    except ValueError as error:
-                        raise CommandArgumentError(
-                            f"Invalid value for '{spec.dest}': {error}"
-                        ) from error
-                    if spec.nargs is None:
-                        result[spec.dest].append(spec.type(values[0]))
-                    else:
-                        result[spec.dest].append(typed_values)
-                    consumed_indices.update(range(i, new_i))
-                    i = new_i
-                elif action == ArgumentAction.EXTEND:
-                    assert result.get(spec.dest) is not None, "dest should not be None"
-                    values, new_i = self._consume_nargs(args, i + 1, spec)
-                    try:
-                        typed_values = [
-                            coerce_value(value, spec.type) for value in values
-                        ]
-                    except ValueError as error:
-                        raise CommandArgumentError(
-                            f"Invalid value for '{spec.dest}': {error}"
-                        ) from error
-                    result[spec.dest].extend(typed_values)
-                    consumed_indices.update(range(i, new_i))
-                    i = new_i
-                else:
-                    values, new_i = self._consume_nargs(args, i + 1, spec)
-                    try:
-                        typed_values = [
-                            coerce_value(value, spec.type) for value in values
-                        ]
-                    except ValueError as error:
-                        raise CommandArgumentError(
-                            f"Invalid value for '{spec.dest}': {error}"
-                        ) from error
-                    if not typed_values and spec.nargs not in ("*", "?"):
-                        raise CommandArgumentError(
-                            f"Expected at least one value for '{spec.dest}'"
-                        )
-                    if (
-                        spec.nargs in (None, 1, "?")
-                        and spec.action != ArgumentAction.APPEND
-                    ):
-                        result[spec.dest] = (
-                            typed_values[0] if len(typed_values) == 1 else typed_values
-                        )
-                    else:
-                        result[spec.dest] = typed_values
-                    consumed_indices.update(range(i, new_i))
-                    i = new_i
-            elif token.startswith("-"):
-                # Handle unrecognized option
-                raise CommandArgumentError(f"Unrecognized flag: {token}")
-            else:
-                # Get the next flagged argument index if it exists
-                next_flagged_index = -1
-                for index, arg in enumerate(args[i:], start=i):
-                    if arg.startswith("-"):
-                        next_flagged_index = index
-                        break
-                if next_flagged_index == -1:
-                    next_flagged_index = len(args)
-                args_consumed = await self._consume_all_positional_args(
-                    args[i:next_flagged_index],
-                    result,
-                    positional_args,
-                    consumed_positional_indices,
-                )
-                i += args_consumed
+            token = self._expand_posix_bundling(args[i])
+            if isinstance(token, list):
+                args[i : i + 1] = token
+                token = args[i]
+            i = await self._handle_token(
+                token,
+                args,
+                i,
+                result,
+                positional_args,
+                consumed_positional_indices,
+                consumed_indices,
+                from_validate=from_validate,
+            )
 
         # Required validation
         for spec in self._arguments:
@@ -797,6 +811,8 @@ class CommandArgumentParser:
                     flags = arg.get_positional_text()
                     arg_line = Text(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("[bold]options:[/bold]")
@@ -805,6 +821,8 @@ class CommandArgumentParser:
                 flags_choice = f"{flags} {arg.get_choice_text()}"
                 arg_line = Text(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)