lockss-pybasic 0.1.0.dev11__tar.gz → 0.1.0.dev13__tar.gz

{lockss_pybasic-0.1.0.dev11 → lockss_pybasic-0.1.0.dev13}/PKG-INFO

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

{lockss_pybasic-0.1.0.dev11 → lockss_pybasic-0.1.0.dev13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lockss-pybasic"
-version = "0.1.0-dev11"
+version = "0.1.0-dev13"
 description = "Basic Python utilities"
 authors = [
     { name = "Thib Guicherd-Callin", email = "thib@cs.stanford.edu" }

{lockss_pybasic-0.1.0.dev11 → lockss_pybasic-0.1.0.dev13}/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.1.0-dev11'
+__version__ = '0.1.0-dev13'

{lockss_pybasic-0.1.0.dev11 → lockss_pybasic-0.1.0.dev13}/src/lockss/pybasic/cliutil.py

@@ -34,73 +34,43 @@ Command line utilities.
 
 from abc import ABC, abstractmethod
 import sys
-from typing import Any, Dict, Generic, List, Optional, TypeVar
+from typing import Any, Dict, Generic, Optional, TypeVar
 
 from pydantic.v1 import BaseModel, Field
 from pydantic_argparse import ArgumentParser
 
 
-class Printable(ABC):
-
-    def print(self, file=sys.stdout):
-        print(self.get_display(), file=file)
+class ActionCommand(ABC, BaseModel):
 
     @abstractmethod
-    def get_display(self):
+    def action(self):
         pass
 
 
-class CopyrightCommand:
-
-    @staticmethod
-    def make(copyright):
-        class CopyrightModel(Printable, BaseModel):
-            def get_display(self):
-                return copyright
-        return CopyrightModel
-
-    @staticmethod
-    def field():
-        return Field(description='print the copyright and exit')
-
-
-class LicenseCommand:
+class StringCommand(ActionCommand):
 
     @staticmethod
-    def make(license):
-        class LicenseModel(Printable, BaseModel):
-            def get_display(self):
-                return license
-        return LicenseModel
-
-    @staticmethod
-    def field():
-        return Field(description='print the software license and exit')
-
+    def type(display_str: str):
+        class _StringCommand(StringCommand):
+            def action(self, file=sys.stdout):
+                print(display_str, file=file)
+        return _StringCommand
 
-class VersionCommand:
 
-    @staticmethod
-    def make(version):
-        class VersionModel(Printable, BaseModel):
-            def get_display(self):
-                return version
-        return VersionModel
-
-    @staticmethod
-    def field():
-        return Field(description='print the version number and exit')
+COPYRIGHT_DESCRIPTION = 'print the copyright and exit'
+LICENSE_DESCRIPTION = 'print the software license and exit'
+VERSION_DESCRIPTION = 'print the version number and exit'
 
 
-ModelT = TypeVar('ModelT')
+BaseModelT = TypeVar('BaseModelT', bound=BaseModel)
 
 
-class BaseCli(Generic[ModelT], ABC):
+class BaseCli(Generic[BaseModelT]):
 
     def __init__(self, **extra):
         super().__init__()
-        self.args: ModelT = None
-        self.parser: ArgumentParser = None
+        self.args: Optional[BaseModelT] = None
+        self.parser: Optional[ArgumentParser] = None
         self.extra: Dict[str, Any] = dict(**extra)
 
     def run(self):
@@ -110,32 +80,58 @@ class BaseCli(Generic[ModelT], ABC):
         self.args = self.parser.parse_typed_args()
         self.dispatch()
 
-    @abstractmethod
     def dispatch(self):
-        pass
+        field_names = self.args.__class__.__fields__.keys()
+        for field_name in field_names:
+            field_value = getattr(self.args, field_name)
+            if issubclass(type(field_value), BaseModel):
+                func = getattr(self, f'_{field_name}')
+                func(field_value)
+                break
+        else:
+            self.parser.error(f'unknown command; expected one of {', '.join(field_names)}')
+
+
+def at_most_one_from_enum(model_cls, values: Dict[str, Any], enum_cls):
+    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 = list()
+    for field_name in enum_names:
+        if values.get(field_name):
+            ret.append(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 {', '.join([option_name(enum_name) for enum_name in ret])}')
+    return values
 
 
-def _matchy_length(values: Dict[str, Any], *names: str) -> int:
-    return len(name for name in names if values.get(name)])
+def get_from_enum(model_inst, enum_cls, default=None):
+    enum_names = [field_name for field_name, model_field in model_inst.__class__.__fields__.items() if model_field.field_info.extra.get('enum') == enum_cls]
+    for field_name in enum_names:
+        if getattr(model_inst, field_name):
+            return enum_cls.from_member(field_name)
+    return default
 
 
 def at_most_one(values: Dict[str, Any], *names: str):
-    if (length := _matchy_length(values, names)) > 1:
+    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}')
     return values
 
 
 def exactly_one(values: Dict[str, Any], *names: str):
-    if (length := _matchy_length(values, names)) != 1:
+    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}')
     return values
 
 
 def one_or_more(values: Dict[str, Any], *names: str):
-    if _matchy_length(values, names) == 0:
+    if _matchy_length(values, *names) == 0:
         raise ValueError(f'one or more of {', '.join([option_name(name) for name in names])} is required')
     return values
 
 
 def option_name(name: str):
     return f'{('-' if len(name) == 1 else '--')}{name.replace('_', '-')}'
+
+
+def _matchy_length(values: Dict[str, Any], *names: str) -> int:
+    return len([name for name in names if values.get(name)])