cli-command-parser 2023.4.15__tar.gz → 2023.4.16__tar.gz

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cli_command_parser
-Version: 2023.4.15
+Version: 2023.4.16
 Summary: CLI Command Parser
 Home-page: https://github.com/dskrypa/cli_command_parser
 Author: Doug Skrypa
@@ -110,6 +110,16 @@ with optional dependencies::
 
     $ pip install -U cli-command-parser[wcwidth]
 
+
+Python Version Compatibility
+============================
+
+Python versions 3.7 and above are currently supported.  CLI Command Parser will no longer support 3.7 after 2023-04-30,
+ahead of the `official end of support for 3.7 on 2023-06-27 <https://devguide.python.org/versions/>`__.
+
+When using 3.7 or 3.8, some additional packages that backport functionality that was added in later Python versions
+are required for compatibility.
+
 To use the argparse to cli-command-parser conversion script with Python 3.7 or 3.8, there is a dependency on
 `astunparse <https://astunparse.readthedocs.io>`__.  If you are using Python 3.9 or above, then ``astunparse`` is not
 necessary because the relevant code was added to the stdlib ``ast`` module.  If you're unsure, you can install

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/__version__.py

@@ -1,7 +1,7 @@
 __title__ = 'cli_command_parser'
 __description__ = 'CLI Command Parser'
 __url__ = 'https://github.com/dskrypa/cli_command_parser'
-__version__ = '2023.04.15'
+__version__ = '2023.04.16'
 __author__ = 'Doug Skrypa'
 __author_email__ = 'dskrypa@gmail.com'
 __license__ = 'Apache 2.0'

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/command_parameters.py

@@ -50,6 +50,7 @@ class CommandParameters:
     combo_option_map: OptionMap                          #: Mapping of {short opt: Parameter} (no dash characters)
     groups: List[ParamGroup]                             #: List of ParamGroup objects
     positionals: List[BasePositional]                    #: List of positional Parameters
+    _deferred_positionals: List[BasePositional] = ()     #: Positional Parameters that are deferred to sub commands
     option_map: OptionMap                                #: Mapping of {--opt / -opt: Parameter}
 
     def __init__(self, command: CommandCls, command_parent: Optional[CommandCls], config: CommandConfig):
@@ -169,6 +170,7 @@ class CommandParameters:
                 options.append(param)
             elif isinstance(param, ParamGroup):
                 # Groups will only be discovered here when defined with `as` - ex: `with ParamGroup(...) as foo:`
+                # Group members will always be discovered at the top level since context managers share the outer scope
                 groups.add(param)
             elif isinstance(param, PassThru):
                 if self.pass_thru:
@@ -200,36 +202,37 @@ class CommandParameters:
         self.groups = sorted(groups)
 
     def _process_positionals(self, params: List[BasePositional]):
-        var_nargs_param = None
-        for param in params:
-            if self.sub_command:
-                raise CommandDefinitionError(
-                    f'Positional param={param!r} may not follow the sub command {self.sub_command} - re-order the'
-                    ' positionals, move it into the sub command(s), or convert it to an optional parameter'
-                )
-            elif var_nargs_param:
+        var_nargs_param = action_or_sub_cmd = split_index = None
+        for i, param in enumerate(params):
+            if var_nargs_param:
                 raise CommandDefinitionError(
                     f'Additional Positional parameters cannot follow {var_nargs_param} because it accepts'
                     f' a variable number of arguments with no specific choices defined - param={param!r} is invalid'
                 )
-
-            if isinstance(param, (SubCommand, Action)):
-                if self.action:  # self.sub_command being already defined is handled above
+            elif isinstance(param, (SubCommand, Action)):
+                if action_or_sub_cmd:
                     raise CommandDefinitionError(
                         f'Only 1 Action xor SubCommand is allowed in a given Command - {self.command.__name__} cannot'
-                        f' contain both {self.action} and {param}'
+                        f' contain both {action_or_sub_cmd} and {param}'
                     )
                 elif isinstance(param, SubCommand):
-                    self.sub_command = param
+                    self.sub_command = action_or_sub_cmd = param
+                    split_index = i + 1
                 else:
-                    self.action = param
+                    self.action = action_or_sub_cmd = param
                     if not param.has_choices:
                         raise CommandDefinitionError(f'No choices were registered for {self.action}')
-
-            if param.nargs.variable and not param.has_choices:
+            elif param.nargs.variable and not param.has_choices:
                 var_nargs_param = param
 
-        self.positionals = params
+        if split_index:
+            params, self._deferred_positionals = params[:split_index], params[split_index:]
+
+        parent = self.parent
+        if parent and parent._deferred_positionals:
+            self.positionals = parent._deferred_positionals + params
+        else:
+            self.positionals = params
 
     def _process_options(self, params: Collection[BaseOption]):
         parent = self.parent
@@ -459,6 +462,7 @@ class CommandParameters:
             raise exc
 
     def try_env_params(self, ctx: Context) -> Iterator[Option]:
+        """Yields Option parameters that have an environment variable configured, and did not have any CLI values."""
         for param in self.options:
             try:
                 param.env_var  # noqa

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/commands.py

@@ -108,11 +108,11 @@ class Command(ABC, metaclass=CommandMeta):
         cmd_cls = cls
         with ExitStack() as stack:
             stack.enter_context(ctx)
-            sub_cmd = CommandParser.parse_args(ctx)
+            sub_cmd = CommandParser.parse_args_and_get_next_cmd(ctx)
             while sub_cmd:
                 cmd_cls = sub_cmd
                 ctx = stack.enter_context(ctx._sub_context(cmd_cls))
-                sub_cmd = CommandParser.parse_args(ctx)
+                sub_cmd = CommandParser.parse_args_and_get_next_cmd(ctx)
 
             return cmd_cls()
 

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/context.py

@@ -32,31 +32,12 @@ if TYPE_CHECKING:
     from .parameters import Parameter, ActionFlag
     from .typing import Bool, ParamOrGroup, CommandType, AnyConfig, OptStr, PathLike
 
-__all__ = [
-    'Context',
-    'ctx',
-    'get_current_context',
-    'get_or_create_context',
-    'get_context',
-    'get_parsed',
-    'get_raw_arg',
-    'ParseState',
-]
+__all__ = ['Context', 'ctx', 'get_current_context', 'get_or_create_context', 'get_context', 'get_parsed', 'get_raw_arg']
 
 _context_stack = ContextVar('cli_command_parser.context.stack', default=[])
 _TERMINAL = Terminal()
 
 
-class ParseState(Enum):
-    INITIAL = 1
-    COMPLETE = 2
-    FAILED = 3
-
-    @property
-    def done(self) -> bool:
-        return self._value_ > 1
-
-
 class Context(AbstractContextManager):  # Extending AbstractContextManager to make PyCharm's type checker happy
     """
     The parsing context.
@@ -69,6 +50,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
     prog: OptStr = None
     _terminal_width: Optional[int]
     allow_argv_prog: Bool = True
+    _provided: Dict[ParamOrGroup, int]
 
     def __init__(
         self,
@@ -82,7 +64,6 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
     ):
         self.command = command
         self.parent = parent
-        self.state = ParseState.INITIAL
         self.config = _normalize_config(config, kwargs, parent, command)
         if parent is not None:
             self._set_argv(parent.prog, argv)
@@ -128,8 +109,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         return self.__class__(argv, command, parent=self, **kwargs)
 
     def __repr__(self) -> str:
-        cmd_name = getattr(self.command, '__name__', None)
-        return f'<{self.__class__.__name__}[state={self.state}, command={cmd_name}]>'
+        return f'<{self.__class__.__name__}[command={getattr(self.command, "__name__", None)}]>'
 
     def __enter__(self) -> Context:
         _context_stack.get().append(self)
@@ -220,7 +200,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         try:
             return self._parsed[param]
         except KeyError:
-            self._parsed[param] = value = param._init_value_factory(self.state)
+            self._parsed[param] = value = param._init_value_factory()
             return value
 
     def set_parsed_value(self, param: Parameter, value: Any):
@@ -237,6 +217,9 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         """Not intended to be called by users.  Used by Parameters during parsing to handle nargs."""
         return self._provided[param]
 
+    def get_missing(self) -> List[Parameter]:
+        return [p for p in self.params.required_check_params() if self._provided[p] == 0]
+
     # endregion
 
     # region Actions

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/metadata.py

@@ -7,12 +7,20 @@ Program metadata introspection for use in usage, help text, and documentation.
 
 from __future__ import annotations
 
+from collections import defaultdict
 from inspect import getmodule
 from pathlib import Path
+from sys import modules
 from textwrap import dedent
 from typing import TYPE_CHECKING, Any, Type, Optional, Union, Tuple, Dict
 from urllib.parse import urlparse
 
+try:
+    from importlib.metadata import entry_points, EntryPoint
+except ImportError:  # Python 3.7
+    from importlib_metadata import entry_points, EntryPoint
+
+from .compat import cached_property
 from .context import ctx, NoActiveContext
 
 if TYPE_CHECKING:
@@ -61,7 +69,7 @@ class ProgramMetadata:
     module: str = Metadata(None)
     command: str = Metadata(None)
     prog: str = Metadata(None)
-    prog_from_sys_argv: bool = Metadata(None)
+    prog_src: str = Metadata(None)
     url: str = Metadata(None)
     docs_url: str = Metadata(None)
     email: str = Metadata(None)
@@ -111,7 +119,7 @@ class ProgramMetadata:
         else:
             doc = doc_str = None
 
-        prog, prog_from_sys_argv = _prog(prog, path, parent, no_sys_argv)
+        prog, prog_src = _prog_finder.normalize(prog, path, parent, no_sys_argv, command)
         return cls(
             parent=parent,
             path=path,
@@ -119,7 +127,7 @@ class ProgramMetadata:
             module=g.get('__module__'),
             command=command.__qualname__,
             prog=prog,
-            prog_from_sys_argv=prog_from_sys_argv,
+            prog_src=prog_src,
             url=url or g.get('__url__'),
             docs_url=docs_url or _docs_url_from_repo_url(url) or _docs_url_from_repo_url(g.get('__url__')),
             email=email or g.get('__author_email__'),
@@ -164,7 +172,7 @@ def _repr(obj, indent=0) -> str:
     if not isinstance(obj, ProgramMetadata):
         return repr(obj)
 
-    field_dict = {field: getattr(obj, field) for field in obj._fields}
+    field_dict = {field: getattr(obj, field) for field in sorted(obj._fields)}
     prev_str = ' ' * indent
     indent += 4
     indent_str = ' ' * indent
@@ -172,32 +180,99 @@ def _repr(obj, indent=0) -> str:
     return f'<{obj.__class__.__name__}(\n{fields_str}\n{prev_str})>'
 
 
-def _prog(prog: OptStr, cmd_path: Path, parent: Optional[ProgramMetadata], no_sys_argv: Bool) -> Tuple[OptStr, bool]:
-    # TODO: Attempt to detect the name to use via importlib.metadata.entry_points?  3.8+, with return value changes
-    #  after 3.9
-    if prog:
-        return prog, False
-    if no_sys_argv is None:
+class ProgFinder:
+    @cached_property
+    def mod_obj_prog_map(self) -> Dict[str, Dict[str, str]]:
+        mod_obj_prog_map = defaultdict(dict)
+        for entry_point in self._get_console_scripts():
+            module, obj = map(str.strip, entry_point.value.split(':', 1))
+            obj = obj.split('[', 1)[0].strip()  # Strip extras, if any
+            mod_obj_prog_map[module][obj] = entry_point.name
+
+        mod_obj_prog_map.default_factory = None  # Disable automatic defaults
+        return mod_obj_prog_map
+
+    @classmethod
+    def _get_console_scripts(cls) -> Tuple[EntryPoint, ...]:
         try:
-            no_sys_argv = not ctx.allow_argv_prog
-        except NoActiveContext:
-            no_sys_argv = False
+            return entry_points(group='console_scripts')
+        except TypeError:  # Python 3.8 or 3.9
+            return entry_points()['console_scripts']
+
+    def normalize(
+        self,
+        prog: OptStr,
+        cmd_path: Path,
+        parent: Optional[ProgramMetadata],
+        no_sys_argv: Bool,
+        command: CommandType,
+    ) -> Tuple[OptStr, str]:
+        if prog:
+            return prog, 'class kwargs'
+
+        ep_name = self._from_entry_point(command)
+        if ep_name:
+            return ep_name, 'entry_points'
+
+        if no_sys_argv is None:
+            try:
+                no_sys_argv = not ctx.allow_argv_prog
+            except NoActiveContext:
+                no_sys_argv = False
+
+        # if parent and parent.prog != parent.path.name and (not no_sys_argv or not parent.prog_from_sys_argv):
+        #     return parent.prog, parent.prog_from_sys_argv
+        if parent and parent.prog != parent.path.name and (not no_sys_argv or parent.prog_src != 'sys.argv'):
+            return parent.prog, parent.prog_src
+        elif not no_sys_argv:
+            argv_name = self._from_sys_argv()
+            if argv_name:
+                return argv_name, 'sys.argv'
+
+        return cmd_path.name, 'path'
+
+    def _from_entry_point(self, command: CommandType) -> OptStr:
+        main_mod = 'cli_command_parser.commands'
+        for prog, obj, obj_mod, obj_name in self._iter_entry_point_candidates(command):
+            if obj is command or (obj_mod == main_mod and obj_name == 'main'):
+                return prog
+
+        return None
 
-    if parent and parent.prog != parent.path.name and (not no_sys_argv or not parent.prog_from_sys_argv):
-        return parent.prog, parent.prog_from_sys_argv
-    elif not no_sys_argv:
+    def _iter_entry_point_candidates(self, command: CommandType):
+        try:
+            # TODO: This likely won't work for a base command in one module, sub commands defined in separate modules,
+            #  and main imported from cli_command_parser in the package's __init__/__main__ module...
+            obj_prog_map = self.mod_obj_prog_map[command.__module__]
+            module = modules[command.__module__]
+        except KeyError as e:
+            pass
+        else:
+            for obj_name, prog in obj_prog_map.items():
+                base_name = obj_name.split('.', 1)[0]
+                try:
+                    obj = getattr(module, base_name)
+                except AttributeError:
+                    pass
+                else:
+                    yield prog, obj, getattr(obj, '__module__', ''), getattr(obj, '__name__', '')
+
+    def _from_sys_argv(self) -> OptStr:
         try:
             ctx_prog = ctx.prog
         except NoActiveContext:
-            ctx_prog = None
+            return None
 
         if ctx_prog:
             path = Path(ctx_prog)
             # Windows allows invocation without .exe - assume a file with an extension is a match
             if path.exists() or next(path.parent.glob(f'{path.name}.???'), None) is not None:
-                return path.name, True
+                return path.name
+
+        return None
+
 
-    return cmd_path.name, False
+_prog_finder = ProgFinder()
 
 
 def _path_and_globals(command: CommandType, path: Path = None) -> Tuple[Path, Dict[str, Any]]:

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/parameters/base.py

@@ -22,7 +22,7 @@ except ImportError:
 
 from ..annotations import get_descriptor_value_type
 from ..config import CommandConfig, OptionNameMode, AllowLeadingDash
-from ..context import Context, ctx, get_current_context, ParseState
+from ..context import Context, ctx, get_current_context
 from ..exceptions import ParameterDefinitionError, BadArgument, MissingArgument, InvalidChoice
 from ..exceptions import ParamUsageError, NoActiveContext, UnsupportedAction
 from ..inputs import InputType, normalize_input_type
@@ -277,7 +277,7 @@ class Parameter(ParamBase, Generic[T_co], ABC):
         if show_default is not None:
             self.show_default = show_default
 
-    def _init_value_factory(self, state: ParseState):
+    def _init_value_factory(self):
         return _NotSet
 
     def __set_name__(self, command: CommandCls, name: str):
@@ -489,10 +489,10 @@ class BasicActionMixin:
     nargs: Nargs
     type: Optional[Callable]
 
-    def _init_value_factory(self, state: ParseState):
+    def _init_value_factory(self):
         if self.action == 'append':
             return []
-        return super()._init_value_factory(state)  # noqa
+        return super()._init_value_factory()  # noqa
 
     @parameter_action
     def store(self: Parameter, value: T_co):
@@ -524,7 +524,7 @@ class BasicActionMixin:
         if not values:
             return values
 
-        ctx.set_parsed_value(self, self._init_value_factory(ctx.state))
+        ctx.set_parsed_value(self, self._init_value_factory())
         ctx._provided[self] = 0
         return values
 

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/parameters/choice_map.py

@@ -8,10 +8,10 @@ from __future__ import annotations
 
 from functools import partial
 from string import whitespace, printable
-from typing import Type, TypeVar, Generic, Optional, Callable, Union, Collection, Mapping, Dict
+from typing import Type, TypeVar, Generic, Optional, Callable, Union, Collection, Mapping, NoReturn, Dict
 from types import MethodType
 
-from ..context import ctx, ParseState
+from ..context import ctx
 from ..exceptions import ParameterDefinitionError, BadArgument, MissingArgument, InvalidChoice, CommandDefinitionError
 from ..formatting.utils import format_help_entry
 from ..nargs import Nargs
@@ -100,7 +100,7 @@ class ChoiceMap(BasePositional[str], Generic[T]):
         self.description = description
         self.choices = {}
 
-    def _init_value_factory(self, state: ParseState):
+    def _init_value_factory(self):
         return []
 
     # region Choice Registration
@@ -134,6 +134,9 @@ class ChoiceMap(BasePositional[str], Generic[T]):
             prefix = 'Invalid default' if choice is None else f'Invalid choice={choice!r} for'
             raise CommandDefinitionError(f'{prefix} target={target!r} - already assigned to {existing}')
 
+    def _no_choices_error(self) -> NoReturn:
+        raise CommandDefinitionError(f'No choices were registered for {self}')
+
     # endregion
 
     # region Argument Handling
@@ -151,33 +154,34 @@ class ChoiceMap(BasePositional[str], Generic[T]):
 
     def validate(self, value: str):
         choices = self.choices
-        if choices:
-            values = (*ctx.get_parsed_value(self), value)
-            choice = ' '.join(values)
-            if choice in choices:
-                return
-            elif len(values) > self.nargs.max:
-                raise BadArgument(self, 'too many values')
-            prefix = choice + ' '
-            if not any(c.startswith(prefix) for c in choices if c):
-                raise InvalidChoice(self, prefix[:-1], choices)
-        elif value.startswith('-'):
-            # Note: choices with a leading dash are rejected by `_validate_positional`
-            raise BadArgument(self, f'invalid value={value!r}')
+        if not choices:
+            self._no_choices_error()
+
+        values = (*ctx.get_parsed_value(self), value)
+        choice = ' '.join(values)
+        if choice in choices:
+            return
+        elif len(values) > self.nargs.max:
+            raise BadArgument(self, 'too many values')
+        prefix = choice + ' '
+        if not any(c.startswith(prefix) for c in choices if c):
+            raise InvalidChoice(self, prefix[:-1], choices)
 
     def result_value(self) -> OptStr:
         choices = self.choices
         if not choices:
-            raise CommandDefinitionError(f'No choices were registered for {self}')
+            self._no_choices_error()
 
         values = ctx.get_parsed_value(self)
         if not values:
             if None in choices:
                 return None
             raise MissingArgument(self)
+
         val_count = len(values)
         if val_count not in self.nargs:
             raise BadArgument(self, f'expected nargs={self.nargs} values but found {val_count}')
+
         choice = ' '.join(values)
         if choice not in choices:
             raise InvalidChoice(self, choice, choices)
@@ -293,6 +297,9 @@ class SubCommand(ChoiceMap[CommandCls], title='Subcommands', choice_validation_e
         else:
             return self.register_command(choice, command_or_choice, help=help)  # noqa
 
+    def _no_choices_error(self) -> NoReturn:
+        raise CommandDefinitionError(f'{ctx.command}.{self.name} = {self} has no sub Commands')
+
 
 class Action(ChoiceMap[MethodType], title='Actions'):
     """

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/parameters/options.py

@@ -10,7 +10,7 @@ from abc import ABC
 from functools import partial, update_wrapper
 from typing import Any, Optional, Callable, Sequence, Iterator, Union, TypeVar, Tuple
 
-from ..context import ctx, ParseState
+from ..context import ctx
 from ..exceptions import ParameterDefinitionError, BadArgument, CommandDefinitionError, ParamUsageError
 from ..inputs import normalize_input_type
 from ..nargs import Nargs, NargsValue
@@ -116,7 +116,7 @@ class _Flag(BaseOption[T_co], ABC):
             raise TypeError(f"{self.__class__.__name__}.__init__() got an unexpected keyword argument: 'metavar'")
         super().__init__(*option_strs, **kwargs)
 
-    def _init_value_factory(self, state: ParseState):
+    def _init_value_factory(self):
         if self.action == 'store_const':
             return self.default
         else:
@@ -397,7 +397,7 @@ class Counter(BaseOption[int], accepts_values=True, accepts_none=True):
         super().__init__(*option_strs, action=action, default=default, **kwargs)
         self.const = const
 
-    def _init_value_factory(self, state: ParseState):
+    def _init_value_factory(self):
         return self.default
 
     def prepare_value(self, value: Optional[str], short_combo: bool = False, pre_action: bool = False) -> int:

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser/parser.py

@@ -11,15 +11,16 @@ from collections import deque
 from os import environ
 from typing import TYPE_CHECKING, Optional, Union, Any, Deque, List
 
-from .context import ActionPhase, Context, ParseState
+from .context import ActionPhase, Context
 from .exceptions import UsageError, ParamUsageError, NoSuchOption, MissingArgument, ParamsMissing
-from .exceptions import CommandDefinitionError, Backtrack, UnsupportedAction
+from .exceptions import Backtrack, UnsupportedAction
 from .nargs import REMAINDER, nargs_max_sum, nargs_min_sum
 from .parse_tree import PosNode
 from .parameters.base import BasicActionMixin, Parameter, BasePositional, BaseOption
 
 if TYPE_CHECKING:
     from .command_parameters import CommandParameters
+    from .config import CommandConfig
     from .typing import CommandType
 
 __all__ = ['CommandParser']
@@ -29,72 +30,48 @@ __all__ = ['CommandParser']
 class CommandParser:
     """Stateful parser used for a single pass of argument parsing"""
 
-    __slots__ = ('_last', 'arg_deque', 'ctx', 'deferred', 'params', 'positionals')
+    __slots__ = ('_last', 'arg_deque', 'config', 'deferred', 'params', 'positionals')
 
     arg_deque: Optional[Deque[str]]
+    config: CommandConfig
     deferred: Optional[List[str]]
     params: CommandParameters
     positionals: List[BasePositional]
     _last: Optional[Parameter]
 
-    def __init__(self, ctx: Context):
+    def __init__(self, ctx: Context, params: CommandParameters, config: CommandConfig):
         self._last = None
-        self.ctx = ctx
-        self.params = ctx.params
-        self.positionals = ctx.params.all_positionals.copy()
-        if ctx.config.reject_ambiguous_pos_combos:
+        self.params = params
+        self.positionals = params.all_positionals.copy()
+        self.config = config
+        if config.reject_ambiguous_pos_combos:
             PosNode.build_tree(ctx.command)
 
     @classmethod
-    def parse_args(cls, ctx: Context) -> Optional[CommandType]:
+    def parse_args_and_get_next_cmd(cls, ctx: Context) -> Optional[CommandType]:
         try:
-            parsed = cls.__parse_args(ctx)
+            return cls(ctx, ctx.params, ctx.config).get_next_cmd(ctx)
         except UsageError:
-            ctx.state = ParseState.FAILED
             if not ctx.categorized_action_flags[ActionPhase.PRE_INIT]:
                 raise
             return None
-        except Exception:
-            ctx.state = ParseState.FAILED
-            raise
-        else:
-            if ctx.state == ParseState.INITIAL:
-                ctx.state = ParseState.COMPLETE
-            return parsed
-
-    @classmethod
-    def __parse_args(cls, ctx: Context) -> Optional[CommandType]:
-        params = ctx.params
-        sub_cmd_param = params.sub_command
-        if sub_cmd_param and not sub_cmd_param.choices:
-            raise CommandDefinitionError(f'{ctx.command}.{sub_cmd_param.name} = {sub_cmd_param} has no sub Commands')
 
-        cls(ctx)._parse_args(ctx)
+    def get_next_cmd(self, ctx: Context) -> Optional[CommandType]:
+        self._parse_args(ctx)
+        params = self.params
         params.validate_groups()
-
-        if sub_cmd_param:
-            next_cmd = sub_cmd_param.target()  # type: CommandType
-            missing = cls._missing(params, ctx)
-            if missing and next_cmd.__class__.parent(next_cmd) is not ctx.command:
-                ctx.state = ParseState.FAILED
-                if ctx.categorized_action_flags[ActionPhase.PRE_INIT]:
-                    return None
+        missing = ctx.get_missing()
+        no_pre_init_action = not ctx.categorized_action_flags[ActionPhase.PRE_INIT]
+        next_cmd = params.sub_command.target() if params.sub_command else None
+        if next_cmd is not None:
+            if missing and no_pre_init_action and next_cmd.__class__.parent(next_cmd) is not ctx.command:
                 raise ParamsMissing(missing)
-            return next_cmd
-
-        missing = cls._missing(params, ctx)
-        if missing and not ctx.config.allow_missing and (not params.action or params.action not in missing):
-            # Action is excluded because it provides a better error message
-            if not ctx.categorized_action_flags[ActionPhase.PRE_INIT]:
+        elif missing and not ctx.config.allow_missing and (not params.action or params.action not in missing):
+            if no_pre_init_action:
                 raise ParamsMissing(missing)
         elif ctx.remaining and not ctx.config.ignore_unknown:
-            raise NoSuchOption('unrecognized arguments: {}'.format(' '.join(ctx.remaining)))
-
-        return None
-
-    @classmethod
-    def _missing(cls, params: CommandParameters, ctx: Context) -> List[Parameter]:
-        return [p for p in params.required_check_params() if ctx.num_provided(p) == 0]
+            raise NoSuchOption(f'unrecognized arguments: {" ".join(ctx.remaining)}') from None
+        return next_cmd
 
     def _parse_args(self, ctx: Context):
         self.arg_deque = arg_deque = self.handle_pass_thru(ctx)
@@ -254,7 +231,7 @@ class CommandParser:
         :param found: The number of values that were consumed by the given Parameter
         :return: The updated found count, if backtracking was possible, otherwise the unmodified found count
         """
-        if not self.ctx.config.allow_backtrack or not self.positionals or found < 2:
+        if not self.config.allow_backtrack or not self.positionals or found < 2:
             return found
 
         can_pop = param.can_pop_counts()
@@ -269,7 +246,7 @@ class CommandParser:
         """
         Similar to :meth:`._maybe_backtrack`, but allows backtracking even after starting to process a Positional.
         """
-        if not self.ctx.config.allow_backtrack:
+        if not self.config.allow_backtrack:
             return
 
         can_pop = self._last.can_pop_counts()

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cli-command-parser
-Version: 2023.4.15
+Version: 2023.4.16
 Summary: CLI Command Parser
 Home-page: https://github.com/dskrypa/cli_command_parser
 Author: Doug Skrypa
@@ -110,6 +110,16 @@ with optional dependencies::
 
     $ pip install -U cli-command-parser[wcwidth]
 
+
+Python Version Compatibility
+============================
+
+Python versions 3.7 and above are currently supported.  CLI Command Parser will no longer support 3.7 after 2023-04-30,
+ahead of the `official end of support for 3.7 on 2023-06-27 <https://devguide.python.org/versions/>`__.
+
+When using 3.7 or 3.8, some additional packages that backport functionality that was added in later Python versions
+are required for compatibility.
+
 To use the argparse to cli-command-parser conversion script with Python 3.7 or 3.8, there is a dependency on
 `astunparse <https://astunparse.readthedocs.io>`__.  If you are using Python 3.9 or above, then ``astunparse`` is not
 necessary because the relevant code was added to the stdlib ``ast`` module.  If you're unsure, you can install

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/lib/cli_command_parser.egg-info/requires.txt

@@ -1,4 +1,7 @@
 
+[:python_version < "3.8"]
+importlib_metadata
+
 [conversion]
 
 [conversion:python_version < "3.9"]

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/readme.rst

@@ -81,6 +81,16 @@ with optional dependencies::
 
     $ pip install -U cli-command-parser[wcwidth]
 
+
+Python Version Compatibility
+============================
+
+Python versions 3.7 and above are currently supported.  CLI Command Parser will no longer support 3.7 after 2023-04-30,
+ahead of the `official end of support for 3.7 on 2023-06-27 <https://devguide.python.org/versions/>`__.
+
+When using 3.7 or 3.8, some additional packages that backport functionality that was added in later Python versions
+are required for compatibility.
+
 To use the argparse to cli-command-parser conversion script with Python 3.7 or 3.8, there is a dependency on
 `astunparse <https://astunparse.readthedocs.io>`__.  If you are using Python 3.9 or above, then ``astunparse`` is not
 necessary because the relevant code was added to the stdlib ``ast`` module.  If you're unsure, you can install

{cli_command_parser-2023.4.15 → cli_command_parser-2023.4.16}/setup.cfg

@@ -33,6 +33,8 @@ packages = find:
 package_dir = = lib
 python_requires = >=3.7
 tests_require = testtools; coverage
+install_requires = 
+	importlib_metadata; python_version<"3.8"
 
 [options.packages.find]
 where = lib