cli-command-parser 2025.11.1__tar.gz → 2026.2.1__tar.gz

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_command_parser
-Version: 2025.11.1
+Version: 2026.2.1
 Summary: CLI Command Parser
 Author-email: Doug Skrypa <dskrypa@gmail.com>
 Project-URL: Source, https://github.com/dskrypa/cli_command_parser

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/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__ = '2025.11.01'
+__version__ = '2026.02.01'
 __author__ = 'Doug Skrypa'
 __author_email__ = 'dskrypa@gmail.com'
 __license__ = 'Apache 2.0'

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser/command_parameters.py

@@ -34,7 +34,6 @@ class CommandParameters:
     # fmt: off
     command: CommandCls                                  #: The Command associated with this CommandParameters object
     formatter: CommandHelpFormatter                      #: The formatter used for this Command's help text
-    command_parent: CommandCls | None                    #: The parent Command, if any
     parent: CommandParameters | None                     #: The parent Command's CommandParameters
     action: Action | None = None                         #: An Action Parameter, if specified
     _pass_thru: PassThru | None = None                   #: A PassThru Parameter, if specified
@@ -49,15 +48,8 @@ class CommandParameters:
     option_map: OptionMap                                #: Mapping of {--opt / -opt: Parameter}
     # fmt: on
 
-    def __init__(
-        self,
-        command: CommandCls,
-        command_parent: CommandCls | None,
-        parent_params: CommandParameters | None,
-        config: CommandConfig,
-    ):
+    def __init__(self, command: CommandCls, parent_params: CommandParameters | None, config: CommandConfig):
         self.command = command
-        self.command_parent = command_parent
         self.parent = parent_params
         self.config = config
         self._process_parameters()
@@ -167,7 +159,7 @@ class CommandParameters:
             while param_group := param_group.group:
                 groups.add(param_group)
 
-        if self.config.add_help and self.command_parent is not None and (not self.parent or not self.parent._has_help):
+        if self.config.add_help and self.parent is not None and not self.parent._has_help:
             options.append(help_action)
 
         self._process_positionals(positionals)

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser/core.py

@@ -211,7 +211,7 @@ class CommandMeta(ABCMeta, type):
                 cls = cls.__class__
             parent = mcs.parent(cls, True)
             parent_params = mcs.params(parent) if parent is not None else None
-            cls.__params = params = CommandParameters(cls, parent, parent_params, mcs.config(cls, DEFAULT_CONFIG))
+            cls.__params = params = CommandParameters(cls, parent_params, mcs.config(cls, DEFAULT_CONFIG))
         return params
 
     @classmethod

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser/inputs/__init__.py

@@ -15,7 +15,7 @@ from .base import InputType
 from .choices import ChoiceMap, Choices, EnumChoices
 from .exceptions import InputValidationError, InvalidChoiceError
 from .files import File, Json, Path, Pickle, Serialized
-from .numeric import NumRange, Range
+from .numeric import Bytes, NumRange, Range
 from .patterns import Glob, Regex, RegexMode
 from .time import Date, DateTime, Day, DTFormatMode, Month, Time, TimeDelta
 from .utils import FileWrapper, StatMode
@@ -26,7 +26,7 @@ if _t.TYPE_CHECKING:
 # fmt: off
 __all__ = [
     'StatMode', 'FileWrapper', 'Path', 'File', 'Serialized', 'Json', 'Pickle',
-    'Range', 'NumRange',
+    'Bytes', 'Range', 'NumRange',
     'Choices', 'ChoiceMap', 'EnumChoices',
     'Regex', 'RegexMode', 'Glob',
     'Day', 'Month', 'TimeDelta', 'DateTime', 'Date', 'Time', 'DTFormatMode',

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser/inputs/base.py

@@ -43,3 +43,12 @@ class InputType(Generic[T], ABC):
     def format_metavar(self, choice_delim: str = ',', sort_choices: bool = False) -> str:
         # TODO: Optional/required arg, or handle wrapping in []/{} in formatter
         return NotImplemented
+
+
+class _FixedInputType(InputType[T], ABC):
+    __slots__ = ()
+
+    def fix_default(self, value: str | T | None) -> T | None:
+        if value is None or not isinstance(value, str) or not self._fix_default:
+            return value
+        return self(value)

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser/inputs/numeric.py

@@ -7,20 +7,25 @@ Custom numeric input handlers for Parameters
 
 from __future__ import annotations
 
+import re
 from abc import ABC, abstractmethod
+from typing import Literal
 
 from ..typing import NT, Bool, Number, NumType, RngType
-from .base import InputType
+from .base import _FixedInputType
 from .exceptions import InputValidationError
 from .utils import RangeMixin, range_str
 
-__all__ = ['Range', 'NumRange']
+__all__ = ['NumericInput', 'Range', 'NumRange', 'Bytes']
 
 _range = range
 
 
-class NumericInput(InputType[NT], ABC):
+class NumericInput(_FixedInputType[NT], ABC):
     __slots__ = ()
+
+
+class _RangeInput(NumericInput[NT], ABC):
     type: NumType
 
     def is_valid_type(self, value: str) -> bool:
@@ -45,13 +50,8 @@ class NumericInput(InputType[NT], ABC):
     def format_metavar(self, choice_delim: str = ',', sort_choices: bool = False) -> str:
         return f'{{{self._range_str()}}}'
 
-    def fix_default(self, value: str | NT | None) -> NT | None:
-        if value is None or not isinstance(value, str) or not self._fix_default:
-            return value
-        return self(value)
-
 
-class Range(NumericInput[NT]):
+class Range(_RangeInput[NT]):
     """
     A range of integers that uses the builtin :class:`python:range`.  If a range object is passed to a
     :class:`.Parameter` as the ``type=`` value, it will automatically be wrapped by this class.
@@ -75,7 +75,7 @@ class Range(NumericInput[NT]):
         if isinstance(range, int):
             self.range = _range(range)
         elif not isinstance(range, _range):
-            self.range = _range(*range)
+            self.range = _range(*range)  # noqa
         else:
             self.range = range
         if type is not None:
@@ -102,7 +102,7 @@ class Range(NumericInput[NT]):
         raise InputValidationError(f'expected a value in the range {self._range_str()}')
 
 
-class NumRange(RangeMixin, NumericInput[NT]):
+class NumRange(RangeMixin, _RangeInput[NT]):
     """
     A range of integers or floats, optionally only bounded on one side.
 
@@ -191,3 +191,118 @@ class NumRange(RangeMixin, NumericInput[NT]):
             return self.handle_invalid(self.max, self.include_max, -1)
         else:
             return value
+
+
+class Bytes(NumericInput[NT]):
+    """
+    A byte count/size.
+
+    Types of user inputs that are accepted:
+
+    - Simple integer representing an exact byte count
+    - Number with a unit (KB, MiB, etc.), which will result in the processed value being the raw byte count after
+      scaling based on the provided unit
+
+    :base: Whether 2-character units (MB, GB, etc.) are treated as base 2 (historical interpretation) or
+      base 10 (the default) (following the International System of Units (SI) definition).  Regardless of the base
+      specified here, user-provided units that explicitly use an ``i`` to indicate binary (MiB, GiB, etc.) will always
+      be treated as base 2.
+    :short: Whether single-letter units (other than ``B``, which is always valid) are accepted (default: True).  When
+      accepted, they use the ``base`` parameter to determine which base to use.
+    :fractions: Whether fractional values are allowed (e.g., ``1.2 MB``).  By default, only integers / whole numbers
+      are accepted.
+    :negative: Whether negative numeric values are accepted.
+    """
+
+    __slots__ = ('base', 'short', 'fractions', 'negative')
+    _pattern = re.compile(r'^(-?\d+(?:\.\d+)?)\s*([KMGTPEZYRQ]?i?B?)$', re.IGNORECASE)
+    _PREFIXES = 'KMGTPEZYRQ'
+
+    def __init__(
+        self,
+        base: Literal[2, 10] = 10,
+        *,
+        short: Bool = True,
+        fractions: Bool = False,
+        negative: Bool = False,
+        fix_default: Bool = True,
+    ):
+        if base not in (2, 10):
+            raise ValueError(f'Invalid 2-character unit {base=} - expected 2 for binary or 10 for SI / decimal')
+        super().__init__(fix_default)
+        self.base = base
+        self.short = short
+        self.fractions = fractions
+        self.negative = negative
+
+    def __repr__(self) -> str:
+        base, short, fractions, negative = self.base, self.short, self.fractions, self.negative
+        return f'<{self.__class__.__name__}(({base=}, {short=}, {fractions=}, {negative=})>'
+
+    @classmethod
+    def is_valid_type(cls, value: str) -> bool:
+        """
+        Called during parsing when :meth:`.ParamAction.would_accept` is called to determine if the value would be
+        accepted later for processing / conversion when called.
+
+        :param value: The parsed argument to validate
+        :return: True if this input would accept it for processing later (where it may still be rejected), False if
+          it should be rejected before attempting to process / convert / store it.
+        """
+        try:
+            return bool(cls._pattern.match(value))
+        except TypeError:
+            return False
+
+    def format_metavar(self, choice_delim: str = ',', sort_choices: bool = False) -> str:
+        return 'BYTES[B|KB|MiB|...]'
+
+    def _type_desc(self) -> str:
+        parts = ['a']
+        if not self.negative:
+            parts.append('positive')
+
+        if not self.fractions:
+            if len(parts) == 1:
+                parts[0] = 'an'
+            parts.append('integer')
+
+        parts.append('byte count/size')
+        return ' '.join(parts)
+
+    def __call__(self, value: str) -> NT:
+        try:
+            num, unit = self._pattern.match(value.strip()).groups()
+        except (TypeError, AttributeError):
+            raise InputValidationError(f'expected {self._type_desc()} with optional unit') from None
+
+        try:
+            num = float(num) if self.fractions else int(num)
+        except ValueError as e:  # This should only be caused when int is expected at this point
+            raise InputValidationError(f'expected {self._type_desc()}, but found {num!r}') from e
+
+        if not self.negative and num < 0:
+            raise InputValidationError(f'expected {self._type_desc()}, but found {num!r}')
+
+        return num * self._get_multiplier(unit)
+
+    def _get_multiplier(self, unit: str | None) -> int:
+        if not unit:
+            return 1
+
+        uc_unit = unit.upper()
+        if uc_unit == 'B':
+            return 1
+        elif uc_unit.endswith('I') or (not self.short and len(uc_unit) == 1):
+            # `i` alone or Ki/Mi/etc, or only a single character was provided
+            raise InputValidationError(f'invalid byte {unit=}')
+
+        try:
+            exp = self._PREFIXES.index(uc_unit[0]) + 1
+        except ValueError:
+            raise InputValidationError(f'invalid byte {unit=}')
+
+        if 'I' in uc_unit or self.base == 2:
+            return 1024**exp
+        else:
+            return 1000**exp

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser/inputs/time.py

@@ -26,7 +26,7 @@ from typing import Collection, Iterator, Literal, Sequence, Type, TypeVar, overl
 
 from ..typing import Bool, Locale, Number, T, TimeBound
 from ..utils import MissingMixin
-from .base import InputType
+from .base import InputType, _FixedInputType
 from .exceptions import InputValidationError, InvalidChoiceError
 from .utils import RangeMixin, range_str
 
@@ -73,7 +73,7 @@ class different_locale:
         self._lock.release()
 
 
-class DTInput(InputType[T], ABC):
+class DTInput(_FixedInputType[T], ABC):
     __slots__ = ('locale',)
     dt_type: str
     locale: Locale | None
@@ -93,11 +93,6 @@ class DTInput(InputType[T], ABC):
     def choice_str(self, choice_delim: str = ',', sort_choices: bool = False) -> str:
         raise NotImplementedError
 
-    def fix_default(self, value: str | T | None) -> T | None:
-        if value is None or not isinstance(value, str) or not self._fix_default:
-            return value
-        return self(value)
-
 
 # region Calendar Unit Inputs
 

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser/parameters/base.py

@@ -20,6 +20,7 @@ from ..exceptions import BadArgument, InvalidChoice, MissingArgument, ParameterD
 from ..inputs import InputType, normalize_input_type
 from ..inputs.choices import _ChoicesBase
 from ..inputs.exceptions import InputValidationError, InvalidChoiceError
+from ..inputs.numeric import NumericInput
 from ..nargs import REMAINDER, Nargs
 from ..typing import CommandMethod, DefaultFunc, T_co
 from ..utils import _NotSet
@@ -360,7 +361,12 @@ class Parameter(ParamBase, Generic[T_co], ABC):
         if not isinstance(value, str) or not value or not value[0] == '-':
             return
         elif self.allow_leading_dash == AllowLeadingDash.NUMERIC:
-            if not joined and len(value) > 1 and not _is_numeric(value):
+            # `joined` indicates the value was provided as --opt=val, so it's explicitly intended for this param.
+            # If the value is obviously numeric, that has been allowed via config.
+            # If this param's type is a numeric input type, it is allowed because `prepare_validation_value` is always
+            # called before this method, and the type is validated there (some of this validation should definitely be
+            # simplified).
+            if not joined and len(value) > 1 and not _is_numeric(value) and not isinstance(self.type, NumericInput):
                 raise BadArgument(self, f'invalid {value=}')
         elif self.allow_leading_dash == AllowLeadingDash.NEVER:
             raise BadArgument(self, f'invalid {value=}')

{cli_command_parser-2025.11.1 → cli_command_parser-2026.2.1}/lib/cli_command_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_command_parser
-Version: 2025.11.1
+Version: 2026.2.1
 Summary: CLI Command Parser
 Author-email: Doug Skrypa <dskrypa@gmail.com>
 Project-URL: Source, https://github.com/dskrypa/cli_command_parser