lockss-pybasic 0.2.0.dev1__tar.gz → 0.2.0.dev3__tar.gz

{lockss_pybasic-0.2.0.dev1 → lockss_pybasic-0.2.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lockss-pybasic
-Version: 0.2.0.dev1
+Version: 0.2.0.dev3
 Summary: Basic Python utilities
 License: BSD-3-Clause
 Author: Thib Guicherd-Callin

{lockss_pybasic-0.2.0.dev1 → lockss_pybasic-0.2.0.dev3}/pyproject.toml

@@ -28,7 +28,7 @@
 
 [project]
 name = "lockss-pybasic"
-version = "0.2.0-dev1" # Always change in __init__.py, and at release time in README.rst and CHANGELOG.rst
+version = "0.2.0-dev3" # Always change in __init__.py, and at release time in README.rst and CHANGELOG.rst
 description = "Basic Python utilities"
 license = { text = "BSD-3-Clause" }
 readme = "README.rst"

{lockss_pybasic-0.2.0.dev1 → lockss_pybasic-0.2.0.dev3}/src/lockss/pybasic/__init__.py

@@ -36,4 +36,4 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 '''.strip()
 
-__version__ = '0.2.0-dev1'
+__version__ = '0.2.0-dev3'

{lockss_pybasic-0.2.0.dev1 → lockss_pybasic-0.2.0.dev3}/src/lockss/pybasic/cliutil.py

@@ -34,47 +34,50 @@ Command line utilities.
 
 from collections.abc import Callable
 import sys
-from typing import Any, Dict, Generic, Optional, TypeVar
+from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar, TYPE_CHECKING
 
-from pydantic.v1 import BaseModel
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+
+from pydantic.v1 import BaseModel, PrivateAttr, create_model
+from pydantic.v1.fields import FieldInfo
 from pydantic_argparse import ArgumentParser
 from pydantic_argparse.argparse.actions import SubParsersAction
 from rich_argparse import RichHelpFormatter
 
 
-class ActionCommand(Callable, BaseModel):
-    """
-    Base class for a pydantic-argparse style command.
-    """
-    pass
+class StringCommand(BaseModel):
 
+    def display(self, file: SupportsWrite[str]=sys.stdout) -> None:
+        print(getattr(self, 'display_string'), file=file)
 
-class StringCommand(ActionCommand):
-    """
-    A pydantic-argparse style command that prints a string.
+    @staticmethod
+    def make(model_name: str, option_name: str, description: str, display_string: str):
+        return create_model(model_name,
+                            __base__=StringCommand,
+                            **{option_name: (Optional[bool], FieldInfo(False, description=description)),
+                               display_string: PrivateAttr(display_string)})
 
-    Example of use:
 
-    .. code-block:: python
+class CopyrightCommand(StringCommand):
 
-       class MyCliModel(BaseModel):
-           copyright: Optional[StringCommand.type(my_copyright_string)] = Field(description=COPYRIGHT_DESCRIPTION)
+    @staticmethod
+    def make(display_string: str):
+        return StringCommand.make('CopyrightCommand', 'copyright', 'print the copyright and exit', display_string)
 
-    See also the convenience constants ``COPYRIGHT_DESCRIPTION``,
-    ``LICENSE_DESCRIPTION``, and ``VERSION_DESCRIPTION``.
-    """
+
+class LicenseCommand(StringCommand):
 
     @staticmethod
-    def type(display_str: str):
-        class _StringCommand(StringCommand):
-            def __call__(self, file=sys.stdout, **kwargs):
-                print(display_str, file=file)
-        return _StringCommand
+    def make(display_string: str):
+        return StringCommand.make('LicenseCommand', 'license', 'print the software license and exit', display_string)
 
 
-COPYRIGHT_DESCRIPTION = 'print the copyright and exit'
-LICENSE_DESCRIPTION = 'print the software license and exit'
-VERSION_DESCRIPTION = 'print the version number and exit'
+class VersionCommand(StringCommand):
+
+    @staticmethod
+    def make(display_string: str):
+        return StringCommand.make('VersionCommand', 'version', 'print the version number and exit', display_string)
 
 
 BaseModelT = TypeVar('BaseModelT', bound=BaseModel)
@@ -147,7 +150,7 @@ class BaseCli(Generic[BaseModelT]):
         if callable(func):
             func(base_model) # FIXME?
         else:
-            self._parser.exit(1, f'internal error: no {func_name} callable for the {" ".join(sub for sub in subcommands)}')
+            self._parser.exit(1, f'internal error: no {func_name} callable for the {" ".join(sub for sub in subcommands)} command')
 
     def _initialize_rich_argparse(self) -> None:
         """
@@ -179,7 +182,7 @@ class BaseCli(Generic[BaseModelT]):
             })
 
 
-def at_most_one_from_enum(model_cls, values: Dict[str, Any], enum_cls) -> Dict[str, Any]:
+def at_most_one_from_enum(model_cls: type[BaseModel], values: Dict[str, Any], enum_cls) -> Dict[str, Any]:
     """
     Among the fields of a Pydantic-Argparse model whose ``Field`` definition is
     tagged with the ``enum`` keyword set to the given ``Enum`` type, ensures
@@ -195,7 +198,7 @@ def at_most_one_from_enum(model_cls, values: Dict[str, Any], enum_cls) -> Dict[s
     enum_names = [field_name for field_name, model_field in model_cls.__fields__.items() if model_field.field_info.extra.get('enum') == enum_cls]
     ret = [field_name for field_name in enum_names if values.get(field_name)]
     if (length := len(ret)) > 1:
-        raise ValueError(f'at most one of {', '.join([option_name(enum_name) for enum_name in enum_names])} is allowed, got {length} ({', '.join([option_name(enum_name) for enum_name in ret])})')
+        raise ValueError(f'at most one of {', '.join([option_name(model_cls, enum_name) for enum_name in enum_names])} allowed; got {length} ({', '.join([option_name(enum_name) for enum_name in ret])})')
     return values
 
 
@@ -219,25 +222,29 @@ def get_from_enum(model_inst, enum_cls, default=None):
     return default
 
 
-def at_most_one(values: Dict[str, Any], *names: str):
+def at_most_one(model_cls: type[BaseModel], values: Dict[str, Any], *names: str):
     if (length := _matchy_length(values, *names)) > 1:
-        raise ValueError(f'at most one of {', '.join([option_name(name) for name in names])} is allowed, got {length}')
+        raise ValueError(f'at most one of {', '.join([option_name(model_cls, name) for name in names])} allowed; got {length}')
     return values
 
 
-def exactly_one(values: Dict[str, Any], *names: str):
+def exactly_one(model_cls: type[BaseModel], values: Dict[str, Any], *names: str):
     if (length := _matchy_length(values, *names)) != 1:
-        raise ValueError(f'exactly one of {', '.join([option_name(name) for name in names])} is required, got {length}')
+        raise ValueError(f'exactly one of {', '.join([option_name(model_cls, name) for name in names])} required; got {length}')
     return values
 
 
-def one_or_more(values: Dict[str, Any], *names: str):
+def one_or_more(model_cls: type[BaseModel], values: Dict[str, Any], *names: str):
     if _matchy_length(values, *names) == 0:
-        raise ValueError(f'one or more of {', '.join([option_name(name) for name in names])} is required')
+        raise ValueError(f'one or more of {', '.join([option_name(model_cls, name) for name in names])} required')
     return values
 
 
-def option_name(name: str) -> str:
+def option_name(model_cls: type[BaseModel], name: str) -> str:
+    if (info := model_cls.__fields__.get(name)) is None:
+        raise RuntimeError(f'invalid name: {name}')
+    if alias := info.alias:
+        name = alias
     return f'{('-' if len(name) == 1 else '--')}{name.replace('_', '-')}'