cmdargparse 0.1.0__tar.gz → 0.3.0__tar.gz

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmdargparse
-Version: 0.1.0
+Version: 0.3.0
 Summary: A declarative way to define `cmd2` argument parsers.
 Home-page: https://github.com/krnd/cmdargparse
 Author: Kilian Kaiping (krnd)
@@ -11,15 +11,14 @@ Classifier: Environment :: Console
 Classifier: Environment :: Plugins
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.13
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cmd2~=2.7
+Requires-Dist: cmd2~=4.2
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -46,7 +45,7 @@ The package provides a declarative way to define `cmd2` argument parsers.
 The core functionality is driven by three components:
 * `cmdargument` for defining an argument parser
 * `cmdfield` for declaring the arguments
-* `cmdcommand` for attatching an argument parser to a command
+* `cmdcommand` for attaching an argument parser to a command
 
 ```py
 
@@ -56,7 +55,7 @@ class MyApplication(cmd2.Cmd):
     class _MyCommandArgs(cmdargument):
         my_argument: str = cmdfield.argument(...)
         my_option: str = cmdfield.option(...)
-        my_flag: str = cmdfield.flag(...)
+        my_flag: bool = cmdfield.flag(...)
 
     @cmdcommand(_MyCommandArgs)
     def do_mycommand(self, args: _MyCommandArgs) -> None:
@@ -77,6 +76,9 @@ class MyApplication(cmd2.Cmd):
 * `default` <br/>
     The arguments default value if not specified.
     <br/> (Providing a default value makes the argument optional.)
+* `nargs` <br/>
+    The number of command-line values to be consumed.
+    <br/> https://docs.python.org/3/library/argparse.html#nargs
 * `type` <br/>
     Explicitly specifies the `type` to be used by `argparse`.
     <br/> https://docs.python.org/3/library/argparse.html#type
@@ -95,6 +97,8 @@ arg: str | None = cmdfield.argument(
     },
     default=None,
 )
+args: list[str] = cmdfield.argument()
+more: list[str] = cmdfield.argument(nargs="+")
 ```
 
 
@@ -117,6 +121,9 @@ arg: str | None = cmdfield.argument(
     Explicitly specifies all option declarations.
 * `more_decls` <br/>
     Specifies additional option declarations.
+* `nargs` <br/>
+    The number of command-line values to be consumed.
+    <br/> https://docs.python.org/3/library/argparse.html#nargs
 * `type` <br/>
     Explicitly specifies the `type` to be used by `argparse`.
     <br/> https://docs.python.org/3/library/argparse.html#type
@@ -132,6 +139,8 @@ arg: str | None = cmdfield.argument(
 xx: str | None = cmdfield.option()
 yy: int | None = cmdfield.option([1, 2, 3])
 zz: str = cmdfield.option(required=True)
+hh: list[str] | None = cmdfield.option(default=None)
+qq: list[int] | None = cmdfield.option(nargs=2, default=None)
 ```
 
 #### Declarations
@@ -146,6 +155,7 @@ mm: str | None = cmdfield.option(decls="--mm")           # --mm
 nn: str | None = cmdfield.option(decls="-oo")            # -oo
 pp: str | None = cmdfield.option(decls=("--rr", "-ss"))  # --rr, -ss
 tt: str | None = cmdfield.option(more_decls="-uu")       # -tt, -uu
+vv_ww: str | None = cmdfield.option()                    # -vv-ww  OR  --vv-ww
 ```
 
 
@@ -167,6 +177,7 @@ tt: str | None = cmdfield.option(more_decls="-uu")       # -tt, -uu
     Specifies additional flag declarations.
 * `type` <br/>
     Explicitly specifies the type to be used by argparse.
+    <br/> (Has no effect, as flag values are not type converted.)
     <br/> https://docs.python.org/3/library/argparse.html#type
 * `help` <br/>
     Brief description of the flag.
@@ -192,6 +203,7 @@ mm: bool = cmdfield.flag(decls="--mm")           # --mm
 nn: bool = cmdfield.flag(decls="-oo")            # -oo
 pp: bool = cmdfield.flag(decls=("--rr", "-ss"))  # --rr, -ss
 tt: bool = cmdfield.flag(more_decls="-uu")       # -tt, -uu
+vv_ww: bool = cmdfield.flag()                    # -vv-ww  OR  --vv-ww
 ```
 
 

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/README.md

@@ -12,7 +12,7 @@ The package provides a declarative way to define `cmd2` argument parsers.
 The core functionality is driven by three components:
 * `cmdargument` for defining an argument parser
 * `cmdfield` for declaring the arguments
-* `cmdcommand` for attatching an argument parser to a command
+* `cmdcommand` for attaching an argument parser to a command
 
 ```py
 
@@ -22,7 +22,7 @@ class MyApplication(cmd2.Cmd):
     class _MyCommandArgs(cmdargument):
         my_argument: str = cmdfield.argument(...)
         my_option: str = cmdfield.option(...)
-        my_flag: str = cmdfield.flag(...)
+        my_flag: bool = cmdfield.flag(...)
 
     @cmdcommand(_MyCommandArgs)
     def do_mycommand(self, args: _MyCommandArgs) -> None:
@@ -43,6 +43,9 @@ class MyApplication(cmd2.Cmd):
 * `default` <br/>
     The arguments default value if not specified.
     <br/> (Providing a default value makes the argument optional.)
+* `nargs` <br/>
+    The number of command-line values to be consumed.
+    <br/> https://docs.python.org/3/library/argparse.html#nargs
 * `type` <br/>
     Explicitly specifies the `type` to be used by `argparse`.
     <br/> https://docs.python.org/3/library/argparse.html#type
@@ -61,6 +64,8 @@ arg: str | None = cmdfield.argument(
     },
     default=None,
 )
+args: list[str] = cmdfield.argument()
+more: list[str] = cmdfield.argument(nargs="+")
 ```
 
 
@@ -83,6 +88,9 @@ arg: str | None = cmdfield.argument(
     Explicitly specifies all option declarations.
 * `more_decls` <br/>
     Specifies additional option declarations.
+* `nargs` <br/>
+    The number of command-line values to be consumed.
+    <br/> https://docs.python.org/3/library/argparse.html#nargs
 * `type` <br/>
     Explicitly specifies the `type` to be used by `argparse`.
     <br/> https://docs.python.org/3/library/argparse.html#type
@@ -98,6 +106,8 @@ arg: str | None = cmdfield.argument(
 xx: str | None = cmdfield.option()
 yy: int | None = cmdfield.option([1, 2, 3])
 zz: str = cmdfield.option(required=True)
+hh: list[str] | None = cmdfield.option(default=None)
+qq: list[int] | None = cmdfield.option(nargs=2, default=None)
 ```
 
 #### Declarations
@@ -112,6 +122,7 @@ mm: str | None = cmdfield.option(decls="--mm")           # --mm
 nn: str | None = cmdfield.option(decls="-oo")            # -oo
 pp: str | None = cmdfield.option(decls=("--rr", "-ss"))  # --rr, -ss
 tt: str | None = cmdfield.option(more_decls="-uu")       # -tt, -uu
+vv_ww: str | None = cmdfield.option()                    # -vv-ww  OR  --vv-ww
 ```
 
 
@@ -133,6 +144,7 @@ tt: str | None = cmdfield.option(more_decls="-uu")       # -tt, -uu
     Specifies additional flag declarations.
 * `type` <br/>
     Explicitly specifies the type to be used by argparse.
+    <br/> (Has no effect, as flag values are not type converted.)
     <br/> https://docs.python.org/3/library/argparse.html#type
 * `help` <br/>
     Brief description of the flag.
@@ -158,6 +170,7 @@ mm: bool = cmdfield.flag(decls="--mm")           # --mm
 nn: bool = cmdfield.flag(decls="-oo")            # -oo
 pp: bool = cmdfield.flag(decls=("--rr", "-ss"))  # --rr, -ss
 tt: bool = cmdfield.flag(more_decls="-uu")       # -tt, -uu
+vv_ww: bool = cmdfield.flag()                    # -vv-ww  OR  --vv-ww
 ```
 
 

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse/__init__.py

@@ -7,4 +7,4 @@ from .namespace import Namespace
 from .parser import ArgumentParser
 
 
-_cmd2.set_default_argument_parser_type(ArgumentParser)
+_cmd2.set_default_argument_parser(ArgumentParser)

cmdargparse-0.3.0/cmdargparse/actions/__init__.py

@@ -0,0 +1 @@
+from .store import StoreAction

cmdargparse-0.3.0/cmdargparse/actions/store.py

@@ -0,0 +1,58 @@
+import argparse
+from typing import Annotated, Any, Mapping, Sequence
+
+from cmdargparse.custom import (
+    TANY,
+    ArgumentParser,
+    Namespace,
+    decorator,
+    is_multiple_values,
+)
+
+
+# ################################ ACTION ######################################
+
+
+class StoreAction(argparse._StoreAction):
+
+    def __init__(
+        self,
+        *args: Annotated[Any, "passthrough"],
+        choicesmap: Mapping[TANY, TANY] | None = None,
+        **kwargs: Annotated[Any, "passthrough"],
+    ) -> None:
+        assert not args, (
+            "There should be no positional arguments if not explicitly "
+            "specified. (The `argparse` module passes by keyword.)"
+        )
+
+        if "choices" in kwargs and choicesmap is not None:
+            if any(s not in kwargs["choices"] for s in choicesmap.values()):
+                raise ValueError(
+                    "All mapped values in the choices mapping must be present "
+                    "in the specified choices."
+                )
+            kwargs["choices"] = (
+                *kwargs["choices"],
+                *choicesmap.keys(),
+            )
+
+        super().__init__(*args, **kwargs)
+
+        self.choicesmap = choicesmap
+
+    @decorator.call
+    def __call__(
+        self,
+        parser: ArgumentParser,
+        namespace: Namespace,
+        values: Sequence[TANY] | TANY,
+        option_string: str | None = None,
+    ) -> None:
+        if self.choicesmap is not None:
+            values = (
+                [self.choicesmap.get(v, v) for v in values]
+                if is_multiple_values(values)
+                else self.choicesmap.get(values, values)
+            )
+        setattr(namespace, self.dest, values)

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse/argument.py

@@ -72,7 +72,7 @@ class _cmdargument(type):
         if _cls is None:
             return functools.partial(
                 cls.__call__,
-                default=form,
+                form=form,
             )  # type: ignore
 
         setattr(

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse/command.py

@@ -36,14 +36,15 @@ class _cmdcommand(type):
     ]:
         """Decorate as command function."""
 
-        if hasattr(argtype, "_cmdargparse_command_decorator"):
-            return getattr(argtype, "_cmdargparse_command_decorator")
+        if "_cmdargparse_command_decorator" in argtype.__dict__:
+            return argtype.__dict__["_cmdargparse_command_decorator"]
 
         parser = ArgumentParser()
 
         _dcfields = dataclasses.fields(
             argtype  # pyright: ignore[reportArgumentType]
         )
+        _fieldtypes = typing.get_type_hints(argtype, include_extras=True)
 
         default_form: _DeclFormSpecifier
         default_form = getattr(argtype, "_cmdargparse_default_form")
@@ -63,7 +64,7 @@ class _cmdcommand(type):
             )
 
             args: dict[str, Any]
-            args = field.metadata["args"]
+            args = dict(field.metadata["args"])
 
             assert "dest" not in args, (
                 "Specifying 'dest' directly is not supported."
@@ -86,8 +87,11 @@ class _cmdcommand(type):
                 continue
 
             # Resolve the type from the fields type annotation.
+            (_type, _nargs) = argparse_type(_fieldtypes[field.name])
             if args.get("type", None) is None:
-                args["type"] = argparse_type(field.type)
+                args["type"] = _type
+            if args.get("nargs", None) is None and _nargs is not None:
+                args["nargs"] = _nargs
 
             # Remove custom unspecified arguments.
             if args.get("choicesmap", None) is None:
@@ -168,7 +172,7 @@ def argparse_name_or_flags(
     return tuple(
         _decl
         for _decl in (
-            decl or (form + field),
+            decl or (form + field.replace("_", "-")),
             altdecl,
             *more_decls,
         )
@@ -176,13 +180,10 @@ def argparse_name_or_flags(
     )
 
 
-def argparse_type(type: Any, /) -> Type[Any]:
-    if isinstance(type, str):
-        raise TypeError("forward reference type annotations are not supported")
-
+def argparse_type(type: Any, /) -> Tuple[Type[Any], str | None]:
     origin = typing.get_origin(type)
     if origin is None:
-        return type
+        return (type, None)
 
     if origin is typing.Annotated:
         (argtype, *_) = typing.get_args(type)
@@ -192,9 +193,12 @@ def argparse_type(type: Any, /) -> Type[Any]:
     # should be passed to the `argparse` module.
     if isinstance(type, types.UnionType):
         (argtype, *_) = typing.get_args(type)
-        return argtype
+        return argparse_type(argtype)
     elif origin is typing.Union:
         (argtype, *_) = typing.get_args(type)
-        return argtype
+        return argparse_type(argtype)
+    elif origin is list:
+        (argtype, *_) = typing.get_args(type)
+        return (argparse_type(argtype)[0], "*")
 
     raise TypeError("unsupported type annotation")

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse/field.py

@@ -112,6 +112,8 @@ class _cmdfield(type):
 
     class _ArgumentArgs(TypedDict, total=False):
 
+        nargs: Annotated[int, "N"] | Literal["?", "*", "+"]
+
         type: Annotated[Any, Callable[[str], Annotated[Any, "FieldType"]]]
 
         help: str
@@ -180,6 +182,9 @@ class _cmdfield(type):
             The arguments default value if not specified.
             (Providing a default value makes the argument optional.)
 
+        :param nargs:
+            The number of command-line values to be consumed.
+            <br/> https://docs.python.org/3/library/argparse.html#nargs
         :param type:
             Explicitly specifies the `type` to be used by `argparse`.
             <br/> https://docs.python.org/3/library/argparse.html#type
@@ -192,10 +197,10 @@ class _cmdfield(type):
         """
         return _argparse(
             None,
-            nargs=("?" if not isunset(default) else None),
             choices=choices,
             choicesmap=choicesmap,
             default=on_unset(default, None),
+            nargs=args.get("nargs", ("?" if not isunset(default) else None)),
             type=args.get("type", None),
             help=args.get("help", None),
             metavar=args.get("helpvar", None),
@@ -209,6 +214,8 @@ class _cmdfield(type):
         decls: Tuple[str, str] | str
         more_decls: Sequence[str] | str
 
+        nargs: Annotated[int, "N"] | Literal["?", "*", "+"]
+
         type: Annotated[Any, Callable[[str], Annotated[Any, "FieldType"]]]
 
         required: bool
@@ -388,6 +395,9 @@ class _cmdfield(type):
         :param more_decls:
             Specifies additional option declarations.
 
+        :param nargs:
+            The number of command-line values to be consumed.
+            <br/> https://docs.python.org/3/library/argparse.html#nargs
         :param type:
             Explicitly specifies the `type` to be used by `argparse`.
             <br/> https://docs.python.org/3/library/argparse.html#type
@@ -401,37 +411,37 @@ class _cmdfield(type):
             Reference name of the option value in the help message.
 
         """
-        if decl is None:
-            decl, altdecl, choices = (
-                # 0 arguments
-                (None, None, None)
+        if (
+            choices is None
+            and (decl is None or isinstance(decl, str))
+            and (altdecl is None or isinstance(altdecl, str))
+        ):
+            decl, altdecl, choices, choicesmap = (
+                # option
+                (decl, altdecl, None, None)
             )  # type: ignore
-        elif altdecl is None:
-            decl, altdecl, choices = (
-                # 1 argument
-                (decl, None, None)
-                if isinstance(decl, str)
-                else (None, None, decl)
+        elif decl is not None and not isinstance(decl, str):
+            decl, altdecl, choices, choicesmap = (
+                # choice option [derived]
+                (None, None, decl, altdecl)
             )  # type: ignore
-        elif choices is None:
-            decl, altdecl, choices = (
-                # 2 arguments
-                (decl, altdecl, None)
-                if isinstance(decl, str)
-                else (decl, None, altdecl)
+        elif altdecl is not None and not isinstance(altdecl, str):
+            decl, altdecl, choices, choicesmap = (
+                # choice option [augmented]
+                (decl, None, altdecl, choices)
             )  # type: ignore
         else:
-            decl, altdecl, choices = (
-                # 3 arguments
-                (decl, altdecl, choices)
+            decl, altdecl, choices, choicesmap = (
+                # choice option [augmented]
+                (decl, altdecl, choices, choicesmap)
             )  # type: ignore
         return _argparse(
             _decls(decl, altdecl, args),
-            nargs=("?" if not isunset(default) else None),
             choices=choices,
             choicesmap=choicesmap,
             default=on_unset(default, None),
             required=args.get("required", False),
+            nargs=args.get("nargs", None),
             type=args.get("type", None),
             help=args.get("help", None),
             metavar=args.get("helpvar", None),

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse/namespace.py

@@ -22,16 +22,19 @@ class Namespace(argparse.Namespace):
             )
         )
 
+        cmd.pfeedback("[Namespace]")
+
+        if not fields:
+            cmd.pfeedback("  (no fields)")
+            return
+
         maxlen = max(
             len(attr)
             for attr in fields
             # <format-break>
         )
 
-        cmd.pfeedback("[Namespace]")
         for name in fields:
             cmd.pfeedback(
                 f"  {str.ljust(name, maxlen)!s} :  {self.__dict__[name]!r}"
             )
-        if not fields:
-            cmd.pfeedback("  (no fields)")

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse/parser.py

@@ -9,7 +9,7 @@ import cmd2
 class ArgumentParser(cmd2.Cmd2ArgumentParser):
 
     # Registers a custom argparse argument parameter.
-    #   https://cmd2.readthedocs.io/en/stable/api/argparse_custom/#cmd2.argparse_custom.register_argparse_argument_parameter
+    #   https://cmd2.readthedocs.io/en/stable/api/argparse_utils/#cmd2.argparse_utils.register_argparse_argument_parameter
     #   ```
     #     def register_argparse_argument_parameter(
     #         param_name: str,
@@ -22,7 +22,7 @@ class ArgumentParser(cmd2.Cmd2ArgumentParser):
         *args: Annotated[Any, "passthrough"],
         **kwargs: Annotated[Any, "passthrough"],
     ) -> None:
-        super(cmd2.Cmd2ArgumentParser, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
         from .actions import StoreAction
 

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse/unset.py

@@ -1,11 +1,11 @@
-from typing import Any, Final, TypeAlias, TypeIs, TypeVar
+from typing import Any, Final, TypeAlias, TypeIs, TypeVar, cast
 
 
-# ################################ PACKAGE #####################################
+# ################################ COMPONENT ###################################
 
 
-__sname__ = "unset"
-__version__ = "1.3"
+__component__ = "unset"
+__version__ = "1.5"
 __description__ = ...
 
 __requires__ = ()
@@ -13,7 +13,7 @@ __requires__ = ()
 
 __all__ = (
     # fmt: off
-    "UnsetType", "UNSET", "Unset",
+    "UnsetType", "UNSET", "Unset", "MayUnset",
     "isunset", "on_unset",
     # fmt: on
 )
@@ -24,7 +24,7 @@ __all__ = (
 
 T = TypeVar("T")
 
-TONCE: TypeAlias = Any
+TONCE = TypeVar("TONCE")
 
 
 # ################################ UNSET #######################################
@@ -34,7 +34,6 @@ class _UnsetType(type):
 
     def __invert__(self) -> "UnsetType":
         """Returns the unset value."""
-        global UNSET
         return UNSET
 
 
@@ -60,6 +59,22 @@ It can be used as follows:
 ```
 def function(arg: Type | Unset = ~Unset):
     arg = arg if not isunset(arg) else VALUE
+    # or
+    arg = on_unset(arg, VALUE)
+```
+"""
+
+
+MayUnset: TypeAlias = T | UnsetType
+"""
+The `MayUnset` attribute is a convenience alias for the union of a generic type
+and the `UnsetType`.
+
+It can be used as follows:
+```
+def function(arg: MayUnset[Type] = ~Unset):
+    arg = arg if not isunset(arg) else VALUE
+    # or
     arg = on_unset(arg, VALUE)
 ```
 """
@@ -73,7 +88,7 @@ def isunset(obj: Any, /) -> TypeIs[UnsetType]:
     return obj is UNSET
 
 
-def on_unset(obj: T | Unset, value: TONCE, /) -> T | TONCE:
+def on_unset(obj: T | UnsetType, value: TONCE, /) -> T | TONCE:
     """Returns either the object itself or the specified value if the object is
     unset."""
-    return value if obj is UNSET else obj
+    return value if obj is UNSET else cast(T, obj)

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmdargparse
-Version: 0.1.0
+Version: 0.3.0
 Summary: A declarative way to define `cmd2` argument parsers.
 Home-page: https://github.com/krnd/cmdargparse
 Author: Kilian Kaiping (krnd)
@@ -11,15 +11,14 @@ Classifier: Environment :: Console
 Classifier: Environment :: Plugins
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.13
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cmd2~=2.7
+Requires-Dist: cmd2~=4.2
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -46,7 +45,7 @@ The package provides a declarative way to define `cmd2` argument parsers.
 The core functionality is driven by three components:
 * `cmdargument` for defining an argument parser
 * `cmdfield` for declaring the arguments
-* `cmdcommand` for attatching an argument parser to a command
+* `cmdcommand` for attaching an argument parser to a command
 
 ```py
 
@@ -56,7 +55,7 @@ class MyApplication(cmd2.Cmd):
     class _MyCommandArgs(cmdargument):
         my_argument: str = cmdfield.argument(...)
         my_option: str = cmdfield.option(...)
-        my_flag: str = cmdfield.flag(...)
+        my_flag: bool = cmdfield.flag(...)
 
     @cmdcommand(_MyCommandArgs)
     def do_mycommand(self, args: _MyCommandArgs) -> None:
@@ -77,6 +76,9 @@ class MyApplication(cmd2.Cmd):
 * `default` <br/>
     The arguments default value if not specified.
     <br/> (Providing a default value makes the argument optional.)
+* `nargs` <br/>
+    The number of command-line values to be consumed.
+    <br/> https://docs.python.org/3/library/argparse.html#nargs
 * `type` <br/>
     Explicitly specifies the `type` to be used by `argparse`.
     <br/> https://docs.python.org/3/library/argparse.html#type
@@ -95,6 +97,8 @@ arg: str | None = cmdfield.argument(
     },
     default=None,
 )
+args: list[str] = cmdfield.argument()
+more: list[str] = cmdfield.argument(nargs="+")
 ```
 
 
@@ -117,6 +121,9 @@ arg: str | None = cmdfield.argument(
     Explicitly specifies all option declarations.
 * `more_decls` <br/>
     Specifies additional option declarations.
+* `nargs` <br/>
+    The number of command-line values to be consumed.
+    <br/> https://docs.python.org/3/library/argparse.html#nargs
 * `type` <br/>
     Explicitly specifies the `type` to be used by `argparse`.
     <br/> https://docs.python.org/3/library/argparse.html#type
@@ -132,6 +139,8 @@ arg: str | None = cmdfield.argument(
 xx: str | None = cmdfield.option()
 yy: int | None = cmdfield.option([1, 2, 3])
 zz: str = cmdfield.option(required=True)
+hh: list[str] | None = cmdfield.option(default=None)
+qq: list[int] | None = cmdfield.option(nargs=2, default=None)
 ```
 
 #### Declarations
@@ -146,6 +155,7 @@ mm: str | None = cmdfield.option(decls="--mm")           # --mm
 nn: str | None = cmdfield.option(decls="-oo")            # -oo
 pp: str | None = cmdfield.option(decls=("--rr", "-ss"))  # --rr, -ss
 tt: str | None = cmdfield.option(more_decls="-uu")       # -tt, -uu
+vv_ww: str | None = cmdfield.option()                    # -vv-ww  OR  --vv-ww
 ```
 
 
@@ -167,6 +177,7 @@ tt: str | None = cmdfield.option(more_decls="-uu")       # -tt, -uu
     Specifies additional flag declarations.
 * `type` <br/>
     Explicitly specifies the type to be used by argparse.
+    <br/> (Has no effect, as flag values are not type converted.)
     <br/> https://docs.python.org/3/library/argparse.html#type
 * `help` <br/>
     Brief description of the flag.
@@ -192,6 +203,7 @@ mm: bool = cmdfield.flag(decls="--mm")           # --mm
 nn: bool = cmdfield.flag(decls="-oo")            # -oo
 pp: bool = cmdfield.flag(decls=("--rr", "-ss"))  # --rr, -ss
 tt: bool = cmdfield.flag(more_decls="-uu")       # -tt, -uu
+vv_ww: bool = cmdfield.flag()                    # -vv-ww  OR  --vv-ww
 ```
 
 

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/cmdargparse.egg-info/SOURCES.txt

@@ -14,4 +14,6 @@ cmdargparse.egg-info/PKG-INFO
 cmdargparse.egg-info/SOURCES.txt
 cmdargparse.egg-info/dependency_links.txt
 cmdargparse.egg-info/requires.txt
-cmdargparse.egg-info/top_level.txt
+cmdargparse.egg-info/top_level.txt
+cmdargparse/actions/__init__.py
+cmdargparse/actions/store.py

cmdargparse-0.3.0/cmdargparse.egg-info/requires.txt

@@ -0,0 +1 @@
+cmd2~=4.2

{cmdargparse-0.1.0 → cmdargparse-0.3.0}/setup.py

@@ -1,43 +1,42 @@
-from setuptools import find_packages, setup
-
-
-with open("README.md", "r", encoding="utf-8") as file:
-    README = file.read()
-
-
-setup(
-    name="cmdargparse",
-    version="0.1.0",
-    description="A declarative way to define `cmd2` argument parsers.",
-    long_description=README,
-    long_description_content_type="text/markdown",
-    author="Kilian Kaiping (krnd)",
-    url="https://github.com/krnd/cmdargparse",
-    license="MIT",
-    packages=find_packages(include=["cmdargparse"]),
-    # Tested with Python 3.13 only.
-    python_requires=">=3.13",
-    install_requires=[
-        ("cmd2" "~=2.7"),
-    ],
-    keywords=[
-        "CLI",
-        "cmd",
-        "command",
-        "interactive",
-        "prompt",
-        "Python",
-    ],
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Environment :: Console",
-        "Environment :: Plugins",
-        "Intended Audience :: Developers",
-        "Intended Audience :: System Administrators",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: 3.13",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-    ],
-)
+from setuptools import find_packages, setup
+
+
+with open("README.md", "r", encoding="utf-8") as file:
+    README = file.read()
+
+
+setup(
+    name="cmdargparse",
+    version="0.3.0",
+    description="A declarative way to define `cmd2` argument parsers.",
+    long_description=README,
+    long_description_content_type="text/markdown",
+    author="Kilian Kaiping (krnd)",
+    url="https://github.com/krnd/cmdargparse",
+    license="MIT",
+    packages=find_packages(include=["cmdargparse", "cmdargparse.*"]),
+    # Tested with Python 3.14 only.
+    python_requires=">=3.14",
+    install_requires=[
+        ("cmd2" "~=4.2"),
+    ],
+    keywords=[
+        "CLI",
+        "cmd",
+        "command",
+        "interactive",
+        "prompt",
+        "Python",
+    ],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Environment :: Console",
+        "Environment :: Plugins",
+        "Intended Audience :: Developers",
+        "Intended Audience :: System Administrators",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3 :: Only",
+        "Programming Language :: Python :: 3.14",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+)

cmdargparse-0.1.0/cmdargparse.egg-info/requires.txt

@@ -1 +0,0 @@
-cmd2~=2.7