lockss-pybasic 0.2.0.dev9__py3-none-any.whl → 0.2.0.dev11__py3-none-any.whl

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-dev9'
+__version__ = '0.2.0-dev11'

lockss/pybasic/cliutil.py

@@ -31,225 +31,10 @@
 """
 Command line utilities.
 """
-import pathlib
-from collections.abc import Callable
-import sys
-from typing import Any, Dict, Generic, Optional, TypeVar
 
-import click
-from pydantic.v1 import BaseModel as BaseModel1
-from pydantic_argparse import ArgumentParser
-from pydantic_argparse.argparse.actions import SubParsersAction
-from rich_argparse import RichHelpFormatter
-
-from .fileutil import path
-
-
-class ActionCommand(Callable, BaseModel1):
-    """
-    Base class for a pydantic-argparse style command.
-    """
-    pass
-
-
-class StringCommand(ActionCommand):
-    """
-    A pydantic-argparse style command that prints a string.
-
-    Example of use:
-
-    .. code-block:: python
-
-       class MyCliModel(BaseModel):
-           copyright: Optional[StringCommand.type(my_copyright_string)] = Field(description=COPYRIGHT_DESCRIPTION)
-
-    See also the convenience constants ``COPYRIGHT_DESCRIPTION``,
-    ``LICENSE_DESCRIPTION``, and ``VERSION_DESCRIPTION``.
-    """
-
-    @staticmethod
-    def type(display_str: str):
-        class _StringCommand(StringCommand):
-            def __call__(self, file=sys.stdout, **kwargs):
-                print(display_str, file=file)
-        return _StringCommand
-
-
-COPYRIGHT_DESCRIPTION = 'print the copyright and exit'
-LICENSE_DESCRIPTION = 'print the software license and exit'
-VERSION_DESCRIPTION = 'print the version number and exit'
-
-
-BaseModelT = TypeVar('BaseModelT', bound=BaseModel1)
-
-
-class BaseCli(Generic[BaseModelT]):
-    """
-    Base class for general CLI functionality.
-
-    ``BaseModelT`` represents a Pydantic-Argparse model type deriving from
-    ``BaseModel``.
-
-    For each command ``x-y-z`` induced by a Pydantic-Argparse field named
-    ``x_y_z`` deriving from ``BaseModel`` , the ``dispatch()`` method expects a
-    method named ``_x_y_z``.
-    """
-
-    def __init__(self, **kwargs):
-        """
-        Constructs a new ``BaseCli`` instance.
-
-        :param kwargs: Keyword arguments. Must include ``model``, the
-                       ``BaseModel`` type corresponding to ``BaseModelT``. Must
-                       include ``prog``, the command-line name of the program.
-                       Must include ``description``, the description string of
-                       the program.
-        :type kwargs: Dict[str, Any]
-        """
-        super().__init__()
-        self._args: Optional[BaseModelT] = None
-        self._parser: Optional[ArgumentParser] = None
-        self.extra: Dict[str, Any] = dict(**kwargs)
-
-    def run(self) -> None:
-        """
-        Runs the command line tool:
-
-        *  Creates a Pydantic-Argparse ``ArgumentParser`` with ``model``,
-           ``prog`` and ``description`` from the constructor keyword
-           arguments in ``self.parser``.
-
-        *  Stores the Pydantic-Argparse parsed arguments in ``self.args``.
+from typing import Optional
 
-        *  Calls ``dispatch()``.
-        """
-        self._parser: ArgumentParser = ArgumentParser(model=self.extra.get('model'),
-                                                      prog=self.extra.get('prog'),
-                                                      description=self.extra.get('description'))
-        self._initialize_rich_argparse()
-        self._args = self._parser.parse_typed_args()
-        self.dispatch()
-
-    def dispatch(self) -> None:
-        """
-        Dispatches from the first field ``x_y_z`` in ``self._args`` that is a
-        command (i.e. whose value derives from ``BaseModel``) to a method
-        called ``_x_y_z``.
-        """
-        self._dispatch_recursive(self._args, [])
-
-    def _dispatch_recursive(self, base_model: BaseModel1, subcommands: list[str]) -> None:
-        field_names = base_model.__class__.__fields__.keys()
-        for field_name in field_names:
-            field_value = getattr(base_model, field_name)
-            if issubclass(type(field_value), BaseModel1):
-                self._dispatch_recursive(field_value, [*subcommands, field_name])
-                return
-        func_name = ''.join(f'_{sub}' for sub in subcommands)
-        func = getattr(self, func_name)
-        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)} command')
-
-    def _initialize_rich_argparse(self) -> None:
-        """
-        Initializes `rich-argparse <https://pypi.org/project/rich-argparse/>`_
-        for this instance.
-        """
-        self._initialize_rich_argparse_styles()
-        def __add_formatter_class(container):
-            container.formatter_class = RichHelpFormatter
-            if hasattr(container, '_actions'):
-                for action in container._actions:
-                    if issubclass(type(action), SubParsersAction):
-                        for subaction in action.choices.values():
-                            __add_formatter_class(subaction)
-        __add_formatter_class(self._parser)
-
-    def _initialize_rich_argparse_styles(self) -> None:
-        # See https://github.com/hamdanal/rich-argparse#customize-the-colors
-        for cls in [RichHelpFormatter]:
-            cls.styles.update({
-                'argparse.args': 'bold cyan',  # for positional-arguments and --options (e.g "--help")
-                'argparse.groups': 'underline dark_orange',  # for group names (e.g. "positional arguments")
-                'argparse.help': 'default',  # for argument's help text (e.g. "show this help message and exit")
-                'argparse.metavar': 'italic dark_cyan',  # for metavariables (e.g. "FILE" in "--file FILE")
-                'argparse.prog': 'bold grey50',  # for %(prog)s in the usage (e.g. "foo" in "Usage: foo [options]")
-                'argparse.syntax': 'bold',  # for highlights of back-tick quoted text (e.g. "`some text`")
-                'argparse.text': 'default',  # for descriptions, epilog, and --version (e.g. "A program to foo")
-                'argparse.default': 'italic',  # for %(default)s in the help (e.g. "Value" in "(default: Value)")
-            })
-
-
-def at_most_one_from_enum(model_cls, 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
-    that at most one of them has a true value in the given Pydantic-Argparse
-    validator ``values``, or raises a ``ValueError`` otherwise.
-
-    :param model_cls: A Pydantic-Argparse model class.
-    :param values:    The Pydantic-Argparse validator ``values``.
-    :param enum_cls:  The ``Enum`` class the fields of the Pydantic-Argparse
-                      model are tagged with (using the ``enum`` keyword).
-    :return: The ``values`` argument, if no ``ValueError`` has been raised.
-    """
-    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])})')
-    return values
-
-
-def get_from_enum(model_inst, enum_cls, default=None):
-    """
-    Among the fields of a Pydantic-Argparse model whose ``Field`` definition is
-    tagged with the ``enum`` keyword set to the given ``Enum`` type, gets the
-    corresponding enum value of the first with a true value in the model, or
-    returns the given default value. Assumes the existence of a
-    ``from_member()`` static method in the ``Enum`` class.
-
-    :param model_inst:
-    :param enum_cls:
-    :param default:
-    :return:
-    """
-    enum_names = [field_name for field_name, model_field in type(model_inst).__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[field_name]
-    return default
-
-
-def at_most_one(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}')
-    return values
-
-
-def exactly_one(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}')
-    return values
-
-
-def one_or_more(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')
-    return values
-
-
-def option_name(model_cls: type[BaseModel1], 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("_", "-")}'
-
-
-def _matchy_length(values: Dict[str, Any], *names: str) -> int:
-    return len([name for name in names if values.get(name)])
+import click
 
 
 def click_path(spec: Optional[str]) -> click.Path:
@@ -271,25 +56,27 @@ def click_path(spec: Optional[str]) -> click.Path:
             dir_okay = True
             file_okay = False
         elif char == 'e':
+            if 'E' in spec:
+                raise ValueError(f'"e" and "E" are mutually exclusive: {spec}')
+            exists = True
+        elif char == 'E':
+            if 'e' in spec:
+                raise ValueError(f'"E" and "e" are mutually exclusive: {spec}')
             exists = True
         elif char == 'f':
             if 'd' in spec:
                 raise ValueError(f'"f" and "d" are mutually exclusive: {spec}')
             dir_okay = False
             file_okay = True
-        # elif char == 'p':
-        #     if 'P' in spec or 's' in spec:
-        #         raise ValueError(f'"p", "P", and "s" are mutually exclusive: {spec}')
-        #     path_type = path
-        elif char == 'P':
-            if 'p' in spec or 's' in spec:
-                raise ValueError(f'"P", "p", and "s" are mutually exclusive: {spec}')
+        elif char == 'p':
+            if 's' in spec:
+                raise ValueError(f'"p" and "s" are mutually exclusive: {spec}')
             path_type = pathlib.Path
         elif char == 'r':
             readable = True
         elif char == 's':
-            if 'p' in spec or 'P' in spec:
-                raise ValueError(f'"s", "p", and "P" are mutually exclusive: {spec}')
+            if 'p' in spec:
+                raise ValueError(f'"s" and "p" are mutually exclusive: {spec}')
             path_type = str
         elif char == 'w':
             writable = True
@@ -301,12 +88,12 @@ def click_path(spec: Optional[str]) -> click.Path:
             allow_dash = True
         else:
             raise ValueError(f'unknown specification character "{char}": {spec}')
-        return click.Path(allow_dash=allow_dash,
-                          dir_okay=dir_okay,
-                          executable=executable,
-                          exists=exists,
-                          file_okay=file_okay,
-                          path_type=path_type,
-                          readable=readable,
-                          resolve_path=resolve_path,
-                          writable=writable)
+    return click.Path(allow_dash=allow_dash,
+                      dir_okay=dir_okay,
+                      executable=executable,
+                      exists=exists,
+                      file_okay=file_okay,
+                      path_type=path_type,
+                      readable=readable,
+                      resolve_path=resolve_path,
+                      writable=writable)

{lockss_pybasic-0.2.0.dev9.dist-info → lockss_pybasic-0.2.0.dev11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lockss-pybasic
-Version: 0.2.0.dev9
+Version: 0.2.0.dev11
 Summary: Basic Python utilities
 License: BSD-3-Clause
 License-File: LICENSE
@@ -17,10 +17,6 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries
 Requires-Dist: click-extra (>=7.5.0,<7.6.0)
-Requires-Dist: pydantic (>=2.11.0,<2.12.0)
-Requires-Dist: pydantic-argparse (>=0.10.0,<0.11.0)
-Requires-Dist: rich-argparse (>=1.7.0,<1.8.0)
-Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Project-URL: Repository, https://github.com/lockss/lockss-pybasic
 Description-Content-Type: text/x-rst
 
@@ -28,7 +24,7 @@ Description-Content-Type: text/x-rst
 lockss-pybasic
 ==============
 
-.. |RELEASE| replace:: 0.2.0-dev9
+.. |RELEASE| replace:: 0.2.0-dev11
 .. |RELEASE_DATE| replace:: NOT YET RELEASED
 
 **Latest release:** |RELEASE| (|RELEASE_DATE|)

lockss_pybasic-0.2.0.dev11.dist-info/RECORD

@@ -0,0 +1,9 @@
+lockss/pybasic/__init__.py,sha256=v88nAXWCPkYyXSKwoJyGBE9un55PDsUvOjDsQyFGl4k,1679
+lockss/pybasic/auidutil.py,sha256=o5IsRLEYROXRVS6oTO1VFtdzw7SImYSR5VcqAMHY4To,13921
+lockss/pybasic/cliutil.py,sha256=7WjxKy97kZYLzWv6rvLeBisR1AxV2SdlJ1dkxM7lneg,3764
+lockss/pybasic/errorutil.py,sha256=XI84PScZ851_-gfoazivJ8ceieMYWaxQr7qih5ltga0,1951
+lockss/pybasic/fileutil.py,sha256=BpdoPWL70xYTuhyQRBEurScRVnPQg0mX-XW8yyKPGjw,2958
+lockss_pybasic-0.2.0.dev11.dist-info/METADATA,sha256=kbpWDzqZQxTirLvtlQIub64AIIY9_Q7iFDlUMm45MOU,4145
+lockss_pybasic-0.2.0.dev11.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+lockss_pybasic-0.2.0.dev11.dist-info/licenses/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
+lockss_pybasic-0.2.0.dev11.dist-info/RECORD,,

lockss/pybasic/outpututil.py

@@ -1,57 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2000-2025, Board of Trustees of Leland Stanford Jr. University
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# 1. Redistributions of source code must retain the above copyright notice,
-# this list of conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright notice,
-# this list of conditions and the following disclaimer in the documentation
-# and/or other materials provided with the distribution.
-#
-# 3. Neither the name of the copyright holder nor the names of its contributors
-# may be used to endorse or promote products derived from this software without
-# specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-
-"""
-Utilities to work with 'tabulate'.
-"""
-
-from enum import Enum
-
-from pydantic.v1 import BaseModel, Field, validator
-import tabulate
-from typing import Optional
-
-
-OutputFormat = Enum('OutputFormat', tabulate.tabulate_formats)
-
-
-DEFAULT_OUTPUT_FORMAT = 'simple' # from tabulate
-
-
-class OutputFormatOptions(BaseModel):
-    output_format: Optional[str] = Field(DEFAULT_OUTPUT_FORMAT, description=f'[output] set the output format; choices: {", ".join(OutputFormat.__members__.keys())}')
-
-    @validator('output_format')
-    def _validate_output_format(cls, val: str):
-        try:
-            _ = OutputFormat[val]
-            return val
-        except KeyError:
-            raise ValueError(f'must be one of {", ".join(OutputFormat.__members__.keys())}; got {val}')

lockss_pybasic-0.2.0.dev9.dist-info/RECORD

@@ -1,10 +0,0 @@
-lockss/pybasic/__init__.py,sha256=w19js6dIeUAH99jh-rFzKKjiv0Jsex8m3GD2WU-cDwA,1678
-lockss/pybasic/auidutil.py,sha256=o5IsRLEYROXRVS6oTO1VFtdzw7SImYSR5VcqAMHY4To,13921
-lockss/pybasic/cliutil.py,sha256=Mstw3CqDMlFX2HoWmoD7pnjS-VDfcNEsdjb3XSFWKFw,12882
-lockss/pybasic/errorutil.py,sha256=XI84PScZ851_-gfoazivJ8ceieMYWaxQr7qih5ltga0,1951
-lockss/pybasic/fileutil.py,sha256=BpdoPWL70xYTuhyQRBEurScRVnPQg0mX-XW8yyKPGjw,2958
-lockss/pybasic/outpututil.py,sha256=8naQEZ1rM6vOFNL-9mWoK4dMBWokHmzQ0FkHaz8dyuM,2345
-lockss_pybasic-0.2.0.dev9.dist-info/METADATA,sha256=RMTTw6WSWW6q9Kl-ayqnuMWVbzt--UlP_Wg-Cxgfmpo,4326
-lockss_pybasic-0.2.0.dev9.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-lockss_pybasic-0.2.0.dev9.dist-info/licenses/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
-lockss_pybasic-0.2.0.dev9.dist-info/RECORD,,