cli-command-parser 2023.10.20__tar.gz → 2024.4.20__tar.gz

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.1
 Name: cli_command_parser
-Version: 2023.10.20
+Version: 2024.4.20
 Summary: CLI Command Parser
 Home-page: https://github.com/dskrypa/cli_command_parser
 Author: Doug Skrypa
 Author-email: dskrypa@gmail.com
 License: Apache 2.0
 Project-URL: Source, https://github.com/dskrypa/cli_command_parser
+Project-URL: Documentation, https://dskrypa.github.io/cli_command_parser
+Project-URL: Issues, https://github.com/dskrypa/cli_command_parser/issues
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

cli_command_parser-2024.4.20/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+argparse_to_command.py = cli_command_parser.conversion.cli:main

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/__init__.py

@@ -12,7 +12,7 @@ from .config import (
     AmbiguousComboMode,
     AllowLeadingDash,
 )
-from .commands import Command, main
+from .commands import Command, AsyncCommand, main
 from .context import Context, get_current_context, ctx, get_parsed, get_context, get_raw_arg
 from .exceptions import (
     CommandParserException,

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/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.10.20'
+__version__ = '2024.04.20'
 __author__ = 'Doug Skrypa'
 __author_email__ = 'dskrypa@gmail.com'
 __license__ = 'Apache 2.0'

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/annotations.py

@@ -17,6 +17,7 @@ __all__ = ['get_descriptor_value_type']
 
 
 def get_descriptor_value_type(command_cls: type, attr: str) -> Optional[type]:
+    # TODO: Optimize this to cache get_type_hints for a given class?
     try:
         annotation = get_type_hints(command_cls)[attr]
     except (KeyError, NameError):  # KeyError due to attr missing; NameError for forward references

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/command_parameters.py

@@ -92,10 +92,10 @@ class CommandParameters:
         return self.positionals
 
     def get_positionals_to_parse(self, ctx: Context) -> List[BasePositional]:
-        if positionals := self.all_positionals:
-            for i, param in enumerate(positionals):
+        if self.all_positionals:
+            for i, param in enumerate(self.all_positionals):
                 if not ctx.num_provided(param):
-                    return [p for p in positionals[i:]]
+                    return [p for p in self.all_positionals[i:]]
 
         return []
 
@@ -391,15 +391,15 @@ class CommandParameters:
         else:
             yield from self.all_positionals
             yield from self.options
-        if (pass_thru := self.pass_thru) and pass_thru not in exclude:
-            yield pass_thru
+        if self.pass_thru and self.pass_thru not in exclude:
+            yield self.pass_thru
 
     def required_check_params(self) -> Iterator[Parameter]:
         ignore = SubCommand
         yield from (p for p in self.all_positionals if p.required and not p.group and not isinstance(p, ignore))
         yield from (p for p in self.options if p.required and not p.group)
-        if (pass_thru := self._pass_thru) and pass_thru.required and not pass_thru.group:
-            yield pass_thru
+        if self._pass_thru and self._pass_thru.required and not self._pass_thru.group:
+            yield self._pass_thru
 
 
 def _find_ambiguous_combos(

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/commands.py

@@ -15,6 +15,7 @@ from .core import CommandMeta, get_top_level_commands, get_params
 from .context import Context, ActionPhase, get_or_create_context
 from .exceptions import ParamConflict
 from .parser import parse_args_and_get_next_cmd
+from .utils import maybe_await
 
 if TYPE_CHECKING:
     from .typing import Bool, CommandObj
@@ -28,6 +29,9 @@ Argv = Sequence[str]
 class Command(ABC, metaclass=CommandMeta):
     """The main class that other Commands should extend."""
 
+    # TODO: Make the distinction between help/description clearer, or merge them?
+    # TODO: Pull help text from docstring for subcommands if not specified as help=?
+
     #: The parsing Context used for this Command. Provided here for convenience - this reference to it is not used by
     #: any CLI Command Parser internals, so it is safe for subclasses to redefine / overwrite it.
     ctx: Context
@@ -155,17 +159,7 @@ class Command(ABC, metaclass=CommandMeta):
 
         return ctx.actions_taken
 
-    def _pre_init_actions_(self, *args, **kwargs):
-        """
-        The first method called by :meth:`.__call__` (before :meth:`.main` and others).
-
-        Validates the number of ActionFlags that were specified, and calls all of the specified
-        :func:`~.options.before_main` / :obj:`~.options.action_flag` actions such as ``--help`` that were
-        defined with ``before_main=True`` and ``always_available=True`` in their configured order.
-
-        :param args: Positional arguments to pass to the :obj:`~.options.action_flag` methods
-        :param kwargs: Keyword arguments to pass to the :obj:`~.options.action_flag` methods
-        """
+    def _check_param_conflicts_(self):
         # TODO: --help should take precedence over input validation - right now, if a Path input expecting a
         #  non-existent file receives a file that exists, that error is reported instead of showing help text
         ctx = self.__ctx
@@ -178,9 +172,24 @@ class Command(ABC, metaclass=CommandMeta):
             if action is not None and not ctx.config.action_after_action_flags:
                 raise ParamConflict([action, *before], 'combining an action with action flags is disabled')
 
-        for param in ctx.iter_action_flags(ActionPhase.PRE_INIT):
+    def _run_actions_(self, phase: ActionPhase, args: tuple, kwargs: dict):
+        for param in self.__ctx.iter_action_flags(phase):
             param.func(self, *args, **kwargs)
 
+    def _pre_init_actions_(self, *args, **kwargs):
+        """
+        The first method called by :meth:`.__call__` (before :meth:`.main` and others).
+
+        Validates the number of ActionFlags that were specified, and calls all of the specified
+        :func:`~.options.before_main` / :obj:`~.options.action_flag` actions such as ``--help`` that were
+        defined with ``before_main=True`` and ``always_available=True`` in their configured order.
+
+        :param args: Positional arguments to pass to the :obj:`~.options.action_flag` methods
+        :param kwargs: Keyword arguments to pass to the :obj:`~.options.action_flag` methods
+        """
+        self._check_param_conflicts_()
+        self._run_actions_(ActionPhase.PRE_INIT, args, kwargs)
+
     def _init_command_(self, *args, **kwargs):
         """
         Called by :meth:`.__call__` after :meth:`._pre_init_actions_` and before :meth:`._before_main_`.
@@ -208,8 +217,7 @@ class Command(ABC, metaclass=CommandMeta):
         :param args: Positional arguments to pass to the :obj:`~.options.action_flag` methods
         :param kwargs: Keyword arguments to pass to the :obj:`~.options.action_flag` methods
         """
-        for param in self.__ctx.iter_action_flags(ActionPhase.BEFORE_MAIN):
-            param.func(self, *args, **kwargs)
+        self._run_actions_(ActionPhase.BEFORE_MAIN, args, kwargs)
 
     def main(self, *args, **kwargs) -> Optional[int]:
         """
@@ -245,8 +253,111 @@ class Command(ABC, metaclass=CommandMeta):
         :param args: Positional arguments to pass to the :obj:`~.options.action_flag` methods
         :param kwargs: Keyword arguments to pass to the :obj:`~.options.action_flag` methods
         """
-        for param in self.__ctx.iter_action_flags(ActionPhase.AFTER_MAIN):
-            param.func(self, *args, **kwargs)
+        self._run_actions_(ActionPhase.AFTER_MAIN, args, kwargs)
+
+
+class AsyncCommand(Command, ABC):
+    """
+    Asynchronous version of the main class that other Commands should extend.
+
+    To run an AsyncCommand, both :func:`main` and :meth:`.parse_and_run` can be used as if running a synchronous
+    :class:`Command`.  The asynchronous version of :meth:`.parse_and_run` handles calling :func:`python:asyncio.run`.
+
+    For applications that need more direct control over how the event loop is run, :meth:`.parse_and_await` can be
+    used instead.
+
+    All `_sunder_` methods supported by :class:`Command` may be overridden with either synchronous or async versions,
+    and :class:`~.choice_map.Action` target methods may similarly be defined either way as well.
+    """
+
+    @classmethod
+    def parse_and_run(cls, argv=None, **kwargs):
+        """
+        Asynchronous version of :meth:`Command.parse_and_run`.  Argument parsing is handled synchronously, then
+        :func:`python:asyncio.run` is called with the parsed command's :meth:`.__call__` coroutine.
+
+        For applications that need more direct control over how the event loop is run, :meth:`.parse_and_await` can be
+        used instead.
+        """
+        import asyncio
+
+        ctx = get_or_create_context(cls, argv)
+        with ctx.get_error_handler():
+            self = cls.parse(argv)
+
+        try:
+            self
+        except UnboundLocalError:  # There was an error handled during parsing, so self was not defined
+            return None
+        else:
+            asyncio.run(self(**kwargs))
+            return self
+
+    @classmethod
+    async def parse_and_await(cls, argv=None, **kwargs):
+        """
+        Coroutine alternative to :meth:`.parse_and_run`.  This method does NOT call :func:`python:asyncio.run` - it is
+        meant to be used as ``await MyCommand.parse_and_await()`` with an existing event loop.
+
+        Simpler applications can likely use the easier :func:`main` function or :meth:`.parse_and_run` instead.
+        """
+        ctx = get_or_create_context(cls, argv)
+        with ctx.get_error_handler():
+            self = cls.parse(argv)
+
+        try:
+            self
+        except UnboundLocalError:  # There was an error handled during parsing, so self was not defined
+            return None
+        else:
+            await maybe_await(self(**kwargs))
+            return self
+
+    async def __call__(self, *args, **kwargs) -> int:
+        """Asynchronous version of :meth:`Command.__call__`."""
+        with self._Command__ctx as ctx, ctx.get_error_handler():  # noqa
+            await maybe_await(self._pre_init_actions_(*args, **kwargs))
+            await maybe_await(self._init_command_(*args, **kwargs))
+            await maybe_await(self._before_main_(*args, **kwargs))
+            try:
+                await maybe_await(self.main(*args, **kwargs))
+            except BaseException:
+                if ctx.config.always_run_after_main:
+                    log.debug('Caught exception - running _after_main_ before propagating', exc_info=True)
+                    await maybe_await(self._after_main_(*args, **kwargs))
+                raise
+            else:
+                await maybe_await(self._after_main_(*args, **kwargs))
+
+        return ctx.actions_taken
+
+    async def _run_actions_(self, phase: ActionPhase, args: tuple, kwargs: dict):
+        """Asynchronous version of :meth:`Command._run_actions_`."""
+        for param in self._Command__ctx.iter_action_flags(phase):  # noqa
+            await maybe_await(param.func(self, *args, **kwargs))
+
+    async def _pre_init_actions_(self, *args, **kwargs):
+        """Asynchronous version of :meth:`Command._pre_init_actions_`."""
+        self._check_param_conflicts_()
+        await self._run_actions_(ActionPhase.PRE_INIT, args, kwargs)
+
+    async def _before_main_(self, *args, **kwargs):
+        """Asynchronous version of :meth:`Command._before_main_`."""
+        await self._run_actions_(ActionPhase.BEFORE_MAIN, args, kwargs)
+
+    async def main(self, *args, **kwargs) -> Optional[int]:
+        """Asynchronous version of :meth:`Command.main`."""
+        with self._Command__ctx as ctx:  # noqa
+            action = get_params(self).action
+            if action is not None and (ctx.actions_taken == 0 or ctx.config.action_after_action_flags):
+                ctx.actions_taken += 1
+                await maybe_await(action.target()(self, *args, **kwargs))
+
+        return ctx.actions_taken
+
+    async def _after_main_(self, *args, **kwargs):
+        """Asynchronous version of :meth:`Command._after_main_`."""
+        await self._run_actions_(ActionPhase.AFTER_MAIN, args, kwargs)
 
 
 def main(argv: Argv = None, return_command: Bool = False, **kwargs) -> Optional[CommandObj]:

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/config.py

@@ -244,8 +244,8 @@ class ConfigItem(Generic[CV, DV]):
     def __set__(self, instance: CommandConfig, value: ConfigValue):
         if instance._read_only:
             raise AttributeError(f'Unable to set attribute {self.name}={value!r} because {instance} is read-only')
-        elif (type_func := self.type) is not None:
-            value = type_func(value)
+        elif self.type is not None:
+            value = self.type(value)
         instance._data[self.name] = value
 
     def __delete__(self, instance: CommandConfig):

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/context.py

@@ -146,8 +146,8 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
     @property
     def terminal_width(self) -> int:
         """Returns the current terminal width as the number of characters that fit on a single line."""
-        if (width := self._terminal_width) is not None:
-            return width
+        if self._terminal_width is not None:
+            return self._terminal_width
         return _TERMINAL.width
 
     def get_parsed(
@@ -178,18 +178,18 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         if command is None:
             command = self.command
         with self:
-            if recursive and (parent := self.parent):
-                parsed = parent.get_parsed(
+            if recursive and self.parent:
+                parsed = self.parent.get_parsed(
                     command, exclude=exclude, recursive=recursive, default=default, include_defaults=include_defaults
                 )
             else:
                 parsed = {}
 
             # TODO: Add way to get a nested dict with ParamGroup names as the keys of the nested sections?
-            if params := self.params:
-                for param in params.iter_params(exclude):
+            if self.params:
+                for param in self.params.iter_params(exclude):
                     if include_defaults or param in self._parsed:
-                        parsed[param.name] = param.result_value(command, default)
+                        parsed[param.name] = param.result(command, default)
 
         return parsed
 

cli_command_parser-2024.4.20/lib/cli_command_parser/conversion/cli.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import logging
+from functools import cached_property
+from pathlib import Path
+
+from cli_command_parser import Command, Counter, Positional, Flag, ParamGroup, SubCommand, main
+from cli_command_parser.inputs import Path as IPath
+
+log = logging.getLogger(__name__)
+
+arg_parser = 'argparse.ArgumentParser'
+cli_cp_cmd = 'cli-command-parser Command'
+
+
+class ParserConverter(Command, description=f'Tool to convert an {arg_parser} into a {cli_cp_cmd}'):
+    action = SubCommand()
+    input: Path
+    no_smart_for = Flag('-S', help='Disable "smart" for loop handling that attempts to dedupe common subparser params')
+    with ParamGroup('Common'):
+        verbose = Counter('-v', help='Increase logging verbosity (can specify multiple times)')
+        dry_run = Flag('-D', help='Print the actions that would be taken instead of taking them')
+
+    def _init_command_(self):
+        log_fmt = '%(asctime)s %(levelname)s %(name)s %(lineno)d %(message)s' if self.verbose > 1 else '%(message)s'
+        logging.basicConfig(level=logging.DEBUG if self.verbose else logging.INFO, format=log_fmt)
+
+    @cached_property
+    def script(self):
+        from cli_command_parser.conversion import Script
+
+        script = Script(self.input.read_text(), not self.no_smart_for, path=self.input)
+        log.debug(f'Found {script=}')
+        return script
+
+
+class Convert(ParserConverter):
+    input: Path = Positional(type=IPath(type='file', exists=True), help=f'A file containing an {arg_parser}')
+    add_methods = Flag('--no-methods', '-M', default=True, help='Do not include boilerplate methods in Commands')
+
+    def main(self):
+        from cli_command_parser.conversion import convert_script
+
+        print(convert_script(self.script, self.add_methods))
+
+
+class Pprint(ParserConverter):
+    input: Path = Positional(type=IPath(type='file', exists=True), help=f'A file containing an {arg_parser}')
+
+    def main(self):
+        for parser in self.script.parsers:
+            parser.pprint()
+
+
+if __name__ == '__main__':
+    main()

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/conversion/visitor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import re
 from ast import NodeVisitor, AST, Assign, Call, For, Attribute, Name, Import, ImportFrom, expr
 from collections import ChainMap, defaultdict
 from functools import partial, wraps
@@ -43,7 +44,7 @@ class ScriptVisitor(NodeVisitor):
 
     def __init__(self, smart_loop_handling: bool = True, track_refs: Collection[TrackedRef] = ()):
         self.smart_loop_handling = smart_loop_handling
-        self.scopes = ChainMap()
+        self.scopes = ChainMap()  # ChainMap that tracks the var/class/func/etc names available in a given scope
         self._tracked_refs = set()
         self._mod_name_tracked_map = defaultdict(dict)
         for ref in track_refs:
@@ -74,11 +75,32 @@ class ScriptVisitor(NodeVisitor):
                     self.scopes[f'{as_name}.{name}'] = tracked
 
     def visit_ImportFrom(self, node: ImportFrom):
-        if name_tracked_map := self._mod_name_tracked_map.get(node.module):
-            for name, as_name in imp_names(node):
-                if tracked := name_tracked_map.get(name):
-                    log.debug(f'Found tracked import: {node.module}.{name} as {as_name}')
-                    self.scopes[as_name] = tracked
+        """
+        Processes a ``from module import names`` statement.  If the module name matches one from which members were
+        registered to be tracked, then the imported names (and any ``as`` aliases) are processed.  Members with
+        canonical names that match an item that was registered to be tracked are added to the current scope / variable
+        namespace.
+
+        Relative module imports are handled fuzzily - no attempt is made to determine the fully qualified module name
+        for the source file or to resolve what the relative import's fully qualified module name would be.  This may
+        result in incorrect items being tracked if the name matched a tracked name in the matched tracked module.
+        """
+        if level := node.level:
+            # For absolute imports, the level is 0
+            # For relative imports, the level is a positive int, representing the number of relative package levels
+            matches = re.compile(r'[^.]+\.' * level + re.escape(node.module) + '$').search
+            for module, name_tracked_map in self._mod_name_tracked_map.items():
+                if matches(module):
+                    log.debug(f'Found fuzzy relative name match for {"." * level + node.module!r} to {module=}')
+                    self._maybe_track_import_from(node, name_tracked_map)
+        elif name_tracked_map := self._mod_name_tracked_map.get(node.module):
+            self._maybe_track_import_from(node, name_tracked_map)
+
+    def _maybe_track_import_from(self, node: ImportFrom, name_tracked_map):
+        for name, as_name in imp_names(node):
+            if tracked := name_tracked_map.get(name):
+                log.debug(f'Found tracked import: {node.module}.{name} as {as_name}')
+                self.scopes[as_name] = tracked
 
     # endregion
 

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/exceptions.py

@@ -123,6 +123,7 @@ class UsageError(CommandParserException):
     """Base exception for user errors"""
 
     message: str = None
+    # TODO: Document that this is a recommended exception type to use when performing manual input validation
 
 
 class ParamUsageError(UsageError):

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/formatting/commands.py

@@ -70,8 +70,8 @@ class CommandHelpFormatter:
         params = self.params
         yield from params.all_positionals
         yield from params.options
-        if (pass_thru := params.pass_thru) is not None:
-            yield pass_thru
+        if params.pass_thru is not None:
+            yield params.pass_thru
 
     def _usage_parts(self, sub_cmd_choice: str = None, allow_sys_argv: Bool = True) -> Iterator[str]:
         yield 'usage:'
@@ -191,8 +191,8 @@ class CommandHelpFormatter:
             #  each choice value (should probably be configurable to explode or condense)
             choice_str = f'{choice_base} {cmd_name}' if choice_base else cmd_name
             yield from spaced_rst_header(f'Subcommand: {choice_str}', level)
-            if choice_help := choice.help:
-                yield choice_help
+            if choice.help:
+                yield choice.help
                 yield ''
 
             if (command := choice.target) is None:
@@ -200,10 +200,9 @@ class CommandHelpFormatter:
                 yield from self._cmd_rst_lines(config, choice_str, allow_sys_argv)
             else:
                 params = get_params(command)
-                formatter = params.formatter
-                yield from formatter._cmd_rst_lines(config, choice_str, allow_sys_argv)
+                yield from params.formatter._cmd_rst_lines(config, choice_str, allow_sys_argv)
                 if nested_sub_cmd := params.sub_command:
-                    yield from formatter._sub_cmds_rst_lines(
+                    yield from params.formatter._sub_cmds_rst_lines(
                         config, nested_sub_cmd, level, choice_str, depth + 1, allow_sys_argv
                     )
 

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/formatting/params.py

@@ -447,6 +447,7 @@ class GroupHelpFormatter(ParamHelpFormatter, param_cls=ParamGroup):  # noqa  # p
         return f'{adjective} arguments'
 
     def _get_spacer(self) -> str:
+        # TODO: Config option to set these chars OR to have them just be spaces
         if self.param.mutually_exclusive:
             return '\u00A6 '  # BROKEN BAR
         elif self.param.mutually_dependent:

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/inputs/choices.py

@@ -135,6 +135,7 @@ class ChoiceMap(Choices[T]):
 
     def __init__(self, choices: Mapping[Any, T], *args, **kwargs):
         super().__init__(choices, *args, **kwargs)
+        # TODO: Alternate ChoiceMap where values are used as help text, similar to SubCommand with local_choices
 
     def __call__(self, value: str) -> T:
         value = self._normalize(value)

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/inputs/files.py

@@ -200,6 +200,9 @@ class Json(Serialized):
     def __init__(self, *, mode: str = 'rb', **kwargs):
         import json
 
+        # TODO: catch JSONDecodeError and provide a standardized cleaner error message (with a way to disable this error handling)
+        # TODO: Update docs to not suggest importing `inputs as i`
+
         write = allows_write(mode, True)
         kwargs['pass_file'] = write  # json.load just calls loads with f.read()
         super().__init__(json.dump if write else json.loads, mode=mode, **kwargs)

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/inputs/patterns.py

@@ -124,8 +124,8 @@ class Regex(PatternInput[RegexResult]):
         elif mode == RegexMode.GROUP:
             return m.group(self.group)
         elif mode == RegexMode.GROUPS:
-            if groups := self.groups:
-                return tuple(m.group(g) for g in groups)
+            if self.groups:
+                return tuple(m.group(g) for g in self.groups)
             return m.groups()
         else:  # mode == RegexMode.DICT
             return m.groupdict()

{cli_command_parser-2023.10.20 → cli_command_parser-2024.4.20}/lib/cli_command_parser/inputs/time.py

@@ -56,7 +56,7 @@ class different_locale:
 
     def __enter__(self):
         self._lock.acquire()
-        if not (locale := self.locale):
+        if not self.locale:
             return
         # locale.getlocale does not support LC_ALL, but `setlocale(LC_ALL)` with no locale to set will return a str
         # containing all of the current locale settings as `key1=val1;key2=val2;...;keyN=valN`
@@ -65,7 +65,7 @@ class different_locale:
         # to remain set to `English_United States.1252` on Windows 10, which resulted in incorrectly encoded results.
         # Using f'LC_CTYPE={locale};LC_TIME={locale}' seemed cleaner than setting LC_ALL in its entirety, but it
         # resulted in `locale.Error: unsupported locale setting` on Ubuntu/WSL.
-        setlocale(LC_ALL, locale)
+        setlocale(LC_ALL, self.locale)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if self.locale:
@@ -212,13 +212,13 @@ class CalendarUnitInput(DTInput[Union[str, int]], ABC):
         normalized = self.parse(value)
         if normalized < self._min_index:
             raise InvalidChoiceError(value, self.choices(), self.dt_type)
-        elif (out_mode := self.out_format) in (DTFormatMode.NUMERIC, DTFormatMode.NUMERIC_ISO):
-            return self._formats[out_mode][normalized]
-        elif (names_or_abbreviations := self._formats.get(out_mode)) is not None:
+        elif self.out_format in (DTFormatMode.NUMERIC, DTFormatMode.NUMERIC_ISO):
+            return self._formats[self.out_format][normalized]
+        elif (names_or_abbreviations := self._formats.get(self.out_format)) is not None:
             with different_locale(self.out_locale):
                 return names_or_abbreviations[normalized]
 
-        raise ValueError(f'Unexpected output format={out_mode!r} for {self.dt_type}={normalized}')
+        raise ValueError(f'Unexpected output format={self.out_format!r} for {self.dt_type}={normalized}')
 
 
 class Day(CalendarUnitInput, dt_type='day of the week'):