falyx 0.1.55__py3-none-any.whl → 0.1.56__py3-none-any.whl

falyx/action/select_file_action.py

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

falyx/command.py

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

falyx/completer.py

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

falyx/falyx.py

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

falyx/falyx_completer.py

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

falyx/parser/command_argument_parser.py

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

falyx/version.py

@@ -1 +1 @@
-__version__ = "0.1.55"
+__version__ = "0.1.56"

{falyx-0.1.55.dist-info → falyx-0.1.56.dist-info}/METADATA

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

{falyx-0.1.55.dist-info → falyx-0.1.56.dist-info}/RECORD

@@ -10,6 +10,7 @@ falyx/action/action_mixins.py,sha256=oUrjbweCeateshg3tqtbQiGuV8u4GvlioIZCUr9D1m4
 falyx/action/action_types.py,sha256=oG8qIFObZdiU1VZQlnWzR8uBDq8rcxzkCli9A31_tMI,1460
 falyx/action/base_action.py,sha256=vnbcB3807eHFILy1z7RaIlGKDKnLG6XFQWJ8_B-3dcE,5812
 falyx/action/chained_action.py,sha256=ARbyPm2AZLsqmap8aFuZuliSSuRtR4_4PXTS2aeILF0,8988
+falyx/action/confirm_action.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 falyx/action/fallback_action.py,sha256=3FGWfoR1MIgY0ZkDNOpKu8p3JqPWzh5ON3943mfgDGs,1708
 falyx/action/http_action.py,sha256=DNeSBWh58UTFGlfFyTk2GnhS54hpLAJLC0QNbq2cYic,5799
 falyx/action/io_action.py,sha256=V888tQgAynqsVvkhICnEeE4wRs2vvdTcdlEpDSEbHqo,6128
@@ -20,20 +21,21 @@ falyx/action/process_action.py,sha256=nUNcJD6Ms34vmj8njWzv1R1P9xJTyJmelnyJksHcp7
 falyx/action/process_pool_action.py,sha256=XeL6e7vsy4OkOWGQHD0ET14CzuyJ0TL-c1W5VIgdCP8,6204
 falyx/action/prompt_menu_action.py,sha256=SYgSDURsyjeQbEm_lbJCEVjVGPSGN59-xtT_VDyJqVY,5293
 falyx/action/save_file_action.py,sha256=Ji5ND_zXGo82LkyEfyKGNK3x1nrhgu2oMLXV-aZ0Om4,1331
-falyx/action/select_file_action.py,sha256=6zEG_AlmVR4RX6tpOEHxyM_QgxblZYcEbqcd961Q7_o,9967
+falyx/action/select_file_action.py,sha256=cX4vxWribwGd5cQU25KgZWPdbruIR2bTNVkY2xtGakM,10227
 falyx/action/selection_action.py,sha256=f3m4sYpGVu6nwydtx76OMvp7HFMZqSEr_nL9lwaPd_A,15749
 falyx/action/shell_action.py,sha256=0A_kvZLsYmeLHInMM_4Jpe8GCSnXzGBm7H9PnXPvbAs,4055
 falyx/action/signal_action.py,sha256=5UMqvzy7fBnLANGwYUWoe1VRhrr7e-yOVeLdOnCBiJo,1350
 falyx/action/user_input_action.py,sha256=DnIYy4Bwl3dPbNSiM4ojuv-Y3WDYgIF2cUE3YPu-xCE,3848
 falyx/bottom_bar.py,sha256=KPACb9VC0I3dv_pYZLqy7e4uA_KT5dSfwnvuknyV0FI,7388
-falyx/command.py,sha256=9eRSPJGP7oNzwZPdSr3KV_KZe4nVVZCx-uzqvL03w3Q,16482
+falyx/command.py,sha256=b35L0ZcmC_HYZUC19gVOAz3j0wMrY7p22JsqQZ4Orbk,16935
+falyx/completer.py,sha256=EODbakx5PFAwjNcfuUZPFuSx2Q9MXBlWRZJ2LejF6DI,1686
 falyx/config.py,sha256=JkGLssxRYgSOFqGhLT19q4dqyLdLQj_NAtzZpcYSU2M,9665
 falyx/context.py,sha256=b9PGkIfhc1BbFUmaqmr4AojzONfKG1c9WP2uixzCJGQ,10806
 falyx/debug.py,sha256=pguI0XQcZ-7jte5YUPexAufa1oxxalYO1JgmO6GU3rI,1557
 falyx/exceptions.py,sha256=58D4BYkyJ7PlpZoNk37GsUsFThm_gIlb2Ex2XXhLklI,1099
 falyx/execution_registry.py,sha256=7t_96-Q7R7MAJBvWwAt5IAERp0TjbGZPGeeJ1s24ey8,7628
-falyx/falyx.py,sha256=IGNgkaSgrF0jydQQulJUl0hJZT56tmy2UCDmC9DSWB8,49773
-falyx/falyx_completer.py,sha256=DH6SIkRU1dVdhzJ2NdKRhWaAhdlDe8xLm5aMgWih_oA,1836
+falyx/falyx.py,sha256=G-jg0eEgZtjE07OxoMgvF9U6sOpdyZeRghPhyCyJnKU,49284
+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
 falyx/init.py,sha256=F9jg7mLPoBWXdJnc_fyWG7zVQSnrAO8ueDiP8AJxDWE,3331
@@ -44,7 +46,7 @@ falyx/parser/.pytyped,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 falyx/parser/__init__.py,sha256=NbxAovKIY-duFTs6DAsdM_OzL7s3VIu19KMOmltX9ts,512
 falyx/parser/argument.py,sha256=25fyytWj6sH5UROSL-MEEKlDYXm-LwONCBTsn6pbzZ0,3443
 falyx/parser/argument_action.py,sha256=rNVeth0eMpkZRU_eT1RPVxOGzD4pbdAMx9Kq07T4mG4,709
-falyx/parser/command_argument_parser.py,sha256=ajd2_coCZKU37VWXEZGFN1qp54gnjiw1ziCa6FHKUpY,33907
+falyx/parser/command_argument_parser.py,sha256=h0XvjmolJyuJZ7Wj87BwFRmD_yqJI2M8y7Up1EArJ3A,36569
 falyx/parser/parsers.py,sha256=X3eEltxBbwRwWG5Q1A1GqSdQCJZAYN5Eub0_U6dlBN4,9159
 falyx/parser/signature.py,sha256=fSltLEr8ctj1qpbU-OvTMnREjlb8OTG5t-guJFR7j4E,2529
 falyx/parser/utils.py,sha256=HYoTRR9-XbuzV2cz2BCfcHaGlzzFj4j3tlfuAx6-9t4,2942
@@ -59,9 +61,9 @@ 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=Pbdxh5777Y03HxyArAh2ApeVSx23in4w4K38G43Vt98,5197
-falyx/version.py,sha256=mSfkicuxJWIsRzwvWTgXF6azCtmLwU9PYRQ4CHsYpxE,23
-falyx-0.1.55.dist-info/LICENSE,sha256=B0yqgaHuSdhN7T3OBmgQSiDTy8HqT5Oe_dLypRe4Ra4,1073
-falyx-0.1.55.dist-info/METADATA,sha256=MSU6PxGHEDBtNBDvI1irbtRBFf1Sf-SqgfRpZxTjjDM,5561
-falyx-0.1.55.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-falyx-0.1.55.dist-info/entry_points.txt,sha256=j8owOSl2j1Ss8DtGMnKfgehKaolqnIPhVFHaUBLUnMs,45
-falyx-0.1.55.dist-info/RECORD,,
+falyx/version.py,sha256=sAxmq9B-f2SmXYi2UsleAKRrYxtQcxVilh7UIDB0-yM,23
+falyx-0.1.56.dist-info/LICENSE,sha256=B0yqgaHuSdhN7T3OBmgQSiDTy8HqT5Oe_dLypRe4Ra4,1073
+falyx-0.1.56.dist-info/METADATA,sha256=uFba42NmAeHlTQoZ3gDNMnIBOQFFYvad1YtrfhDjg9M,5561
+falyx-0.1.56.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+falyx-0.1.56.dist-info/entry_points.txt,sha256=j8owOSl2j1Ss8DtGMnKfgehKaolqnIPhVFHaUBLUnMs,45
+falyx-0.1.56.dist-info/RECORD,,