falyx 0.1.41__tar.gz → 0.1.43__tar.gz

{falyx-0.1.41 → falyx-0.1.43}/PKG-INFO

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

{falyx-0.1.41 → falyx-0.1.43}/falyx/__main__.py

@@ -8,12 +8,13 @@ Licensed under the MIT License. See LICENSE file for details.
 import asyncio
 import os
 import sys
+from argparse import ArgumentParser, Namespace, _SubParsersAction
 from pathlib import Path
 from typing import Any
 
 from falyx.config import loader
 from falyx.falyx import Falyx
-from falyx.parsers import CommandArgumentParser
+from falyx.parsers import CommandArgumentParser, get_root_parser, get_subparsers
 
 
 def find_falyx_config() -> Path | None:
@@ -48,6 +49,42 @@ def init_config(parser: CommandArgumentParser) -> None:
     )
 
 
+def init_callback(args: Namespace) -> None:
+    """Callback for the init command."""
+    if args.command == "init":
+        from falyx.init import init_project
+
+        init_project(args.name)
+    elif args.command == "init_global":
+        from falyx.init import init_global
+
+        init_global()
+
+
+def get_parsers() -> tuple[ArgumentParser, _SubParsersAction]:
+    root_parser: ArgumentParser = get_root_parser()
+    subparsers = get_subparsers(root_parser)
+    init_parser = subparsers.add_parser(
+        "init",
+        help="Initialize a new Falyx project",
+        description="Create a new Falyx project with mock configuration files.",
+        epilog="If no name is provided, the current directory will be used.",
+    )
+    init_parser.add_argument(
+        "name",
+        type=str,
+        help="Name of the new Falyx project",
+        default=".",
+        nargs="?",
+    )
+    subparsers.add_parser(
+        "init-global",
+        help="Initialize Falyx global configuration",
+        description="Create a global Falyx configuration at ~/.config/falyx/.",
+    )
+    return root_parser, subparsers
+
+
 def main() -> Any:
     bootstrap_path = bootstrap()
     if not bootstrap_path:
@@ -60,17 +97,23 @@ def main() -> Any:
             init_project,
             aliases=["init"],
             argument_config=init_config,
+            help_epilogue="If no name is provided, the current directory will be used.",
         )
         flx.add_command(
             "G",
             "Initialize Falyx global configuration",
             init_global,
             aliases=["init-global"],
+            help_text="Create a global Falyx configuration at ~/.config/falyx/.",
         )
     else:
         flx = loader(bootstrap_path)
 
-    return asyncio.run(flx.run())
+    root_parser, subparsers = get_parsers()
+
+    return asyncio.run(
+        flx.run(root_parser=root_parser, subparsers=subparsers, callback=init_callback)
+    )
 
 
 if __name__ == "__main__":

{falyx-0.1.41 → falyx-0.1.43}/falyx/command.py

@@ -313,7 +313,9 @@ class Command(BaseModel):
         if not self.arg_parser:
             return "No arguments defined."
 
-        return self.arg_parser.get_usage(plain_text=True)
+        command_keys_text = self.arg_parser.get_command_keys_text(plain_text=True)
+        options_text = self.arg_parser.get_options_text(plain_text=True)
+        return f"  {command_keys_text:<20}  {options_text} "
 
     def log_summary(self) -> None:
         if self._context:

{falyx-0.1.41 → falyx-0.1.43}/falyx/falyx.py

@@ -25,7 +25,7 @@ import asyncio
 import logging
 import shlex
 import sys
-from argparse import Namespace
+from argparse import ArgumentParser, Namespace, _SubParsersAction
 from difflib import get_close_matches
 from enum import Enum
 from functools import cached_property
@@ -830,10 +830,11 @@ class Falyx:
                 self.console.print(
                     f"[{OneColors.LIGHT_YELLOW}]⚠️ Unknown command '{choice}'[/]"
                 )
-            raise ValidationError(
-                message=f"Unknown command '{choice}'.",
-                cursor_position=len(raw_choices),
-            )
+            else:
+                raise ValidationError(
+                    message=f"Unknown command '{choice}'.",
+                    cursor_position=len(raw_choices),
+                )
         return is_preview, None, args, kwargs
 
     def _create_context(self, selected_command: Command) -> ExecutionContext:
@@ -1028,6 +1029,8 @@ class Falyx:
     async def run(
         self,
         falyx_parsers: FalyxParsers | None = None,
+        root_parser: ArgumentParser | None = None,
+        subparsers: _SubParsersAction | None = None,
         callback: Callable[..., Any] | None = None,
     ) -> None:
         """Run Falyx CLI with structured subcommands."""
@@ -1045,6 +1048,8 @@ class Falyx:
                 self.description,
                 self.epilog,
                 commands=self.commands,
+                root_parser=root_parser,
+                subparsers=subparsers,
             )
         self.cli_args = falyx_parsers.parse_args()
         self.options.from_namespace(self.cli_args, "cli_args")
@@ -1149,9 +1154,23 @@ class Falyx:
                 f"[{OneColors.CYAN_b}]🚀 Running all commands with tag:[/] "
                 f"{self.cli_args.tag}"
             )
+
             for cmd in matching:
                 self._set_retry_policy(cmd)
-                await self.run_key(cmd.key)
+                try:
+                    await self.run_key(cmd.key)
+                except FalyxError as error:
+                    self.console.print(f"[{OneColors.DARK_RED}]❌ Error: {error}[/]")
+                    sys.exit(1)
+                except QuitSignal:
+                    logger.info("[QuitSignal]. <- Exiting run.")
+                    sys.exit(0)
+                except BackSignal:
+                    logger.info("[BackSignal]. <- Exiting run.")
+                    sys.exit(0)
+                except CancelSignal:
+                    logger.info("[CancelSignal]. <- Exiting run.")
+                    sys.exit(0)
 
             if self.cli_args.summary:
                 er.summary()

{falyx-0.1.41 → falyx-0.1.43}/falyx/parsers/__init__.py

@@ -6,12 +6,14 @@ Licensed under the MIT License. See LICENSE file for details.
 """
 
 from .argparse import Argument, ArgumentAction, CommandArgumentParser
-from .parsers import FalyxParsers, get_arg_parsers
+from .parsers import FalyxParsers, get_arg_parsers, get_root_parser, get_subparsers
 
 __all__ = [
     "Argument",
     "ArgumentAction",
     "CommandArgumentParser",
     "get_arg_parsers",
+    "get_root_parser",
+    "get_subparsers",
     "FalyxParsers",
 ]

{falyx-0.1.41 → falyx-0.1.43}/falyx/parsers/parsers.py

@@ -40,7 +40,7 @@ class FalyxParsers:
         return self.as_dict().get(name)
 
 
-def get_arg_parsers(
+def get_root_parser(
     prog: str | None = "falyx",
     usage: str | None = None,
     description: str | None = "Falyx CLI - Run structured async command workflows.",
@@ -55,9 +55,7 @@ def get_arg_parsers(
     add_help: bool = True,
     allow_abbrev: bool = True,
     exit_on_error: bool = True,
-    commands: dict[str, Command] | None = None,
-) -> FalyxParsers:
-    """Returns the argument parser for the CLI."""
+) -> ArgumentParser:
     parser = ArgumentParser(
         prog=prog,
         usage=usage,
@@ -86,27 +84,91 @@ def get_arg_parsers(
         help="Enable default lifecycle debug logging",
     )
     parser.add_argument("--version", action="store_true", help="Show Falyx version")
-    subparsers = parser.add_subparsers(dest="command")
+    return parser
+
+
+def get_subparsers(
+    parser: ArgumentParser,
+    title: str = "Falyx Commands",
+    description: str | None = "Available commands for the Falyx CLI.",
+) -> _SubParsersAction:
+    """Create and return a subparsers action for the given parser."""
+    if not isinstance(parser, ArgumentParser):
+        raise TypeError("parser must be an instance of ArgumentParser")
+    subparsers = parser.add_subparsers(
+        title=title,
+        description=description,
+        metavar="COMMAND",
+        dest="command",
+    )
+    return subparsers
 
-    run_description = "Run a command by its key or alias."
-    run_epilog = ["commands:"]
+
+def get_arg_parsers(
+    prog: str | None = "falyx",
+    usage: str | None = None,
+    description: str | None = "Falyx CLI - Run structured async command workflows.",
+    epilog: (
+        str | None
+    ) = "Tip: Use 'falyx run ?[COMMAND]' to preview any command from the CLI.",
+    parents: Sequence[ArgumentParser] | None = None,
+    prefix_chars: str = "-",
+    fromfile_prefix_chars: str | None = None,
+    argument_default: Any = None,
+    conflict_handler: str = "error",
+    add_help: bool = True,
+    allow_abbrev: bool = True,
+    exit_on_error: bool = True,
+    commands: dict[str, Command] | None = None,
+    root_parser: ArgumentParser | None = None,
+    subparsers: _SubParsersAction | None = None,
+) -> FalyxParsers:
+    """Returns the argument parser for the CLI."""
+    if root_parser is None:
+        parser = get_root_parser(
+            prog=prog,
+            usage=usage,
+            description=description,
+            epilog=epilog,
+            parents=parents,
+            prefix_chars=prefix_chars,
+            fromfile_prefix_chars=fromfile_prefix_chars,
+            argument_default=argument_default,
+            conflict_handler=conflict_handler,
+            add_help=add_help,
+            allow_abbrev=allow_abbrev,
+            exit_on_error=exit_on_error,
+        )
+    else:
+        if not isinstance(root_parser, ArgumentParser):
+            raise TypeError("root_parser must be an instance of ArgumentParser")
+        parser = root_parser
+
+    if subparsers is None:
+        subparsers = get_subparsers(parser)
+    if not isinstance(subparsers, _SubParsersAction):
+        raise TypeError("subparsers must be an instance of _SubParsersAction")
+
+    run_description = ["Run a command by its key or alias.\n"]
+    run_description.append("commands:")
     if isinstance(commands, dict):
         for command in commands.values():
-            run_epilog.append(command.usage)
+            run_description.append(command.usage)
             command_description = command.description or command.help_text
-            run_epilog.append(f"  {command_description}")
-            run_epilog.append("  ")
-    run_epilog.append(
+            run_description.append(f"{' '*24}{command_description}")
+    run_epilog = (
         "Tip: Use 'falyx run ?[COMMAND]' to preview commands by their key or alias."
     )
     run_parser = subparsers.add_parser(
         "run",
         help="Run a specific command",
-        description=run_description,
-        epilog="\n".join(run_epilog),
+        description="\n".join(run_description),
+        epilog=run_epilog,
         formatter_class=RawDescriptionHelpFormatter,
     )
-    run_parser.add_argument("name", help="Run a command by its key or alias")
+    run_parser.add_argument(
+        "name", help="Run a command by its key or alias", metavar="COMMAND"
+    )
     run_parser.add_argument(
         "--summary",
         action="store_true",
@@ -144,6 +206,7 @@ def get_arg_parsers(
         "command_args",
         nargs=REMAINDER,
         help="Arguments to pass to the command (if applicable)",
+        metavar="ARGS",
     )
 
     run_all_parser = subparsers.add_parser(

falyx-0.1.43/falyx/version.py

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

{falyx-0.1.41 → falyx-0.1.43}/pyproject.toml

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

falyx-0.1.41/falyx/version.py

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