lockss-pybasic 0.1.0.dev22__py3-none-any.whl → 0.1.1__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.1.0-dev22'
+__version__ = '0.1.1'

lockss/pybasic/cliutil.py

@@ -41,19 +41,33 @@ 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 command
+    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):
+            def __call__(self, file=sys.stdout, **kwargs):
                 print(display_str, file=file)
         return _StringCommand
 
@@ -78,20 +92,21 @@ class BaseCli(Generic[BaseModelT]):
     method named ``_x_y_z``.
     """
 
-    def __init__(self, **extra):
+    def __init__(self, **kwargs):
         """
-        Makes a new BaseCli instance.
-
-        :param extra: 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.
+        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(**extra)
+        self.extra: Dict[str, Any] = dict(**kwargs)
 
     def run(self) -> None:
         """
@@ -104,8 +119,6 @@ class BaseCli(Generic[BaseModelT]):
         *  Stores the Pydantic-Argparse parsed arguments in ``self.args``.
 
         *  Calls ``dispatch()``.
-
-        :return: Nothing.
         """
         self._parser: ArgumentParser = ArgumentParser(model=self.extra.get('model'),
                                                       prog=self.extra.get('prog'),
@@ -119,8 +132,6 @@ class BaseCli(Generic[BaseModelT]):
         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``.
-
-        :return: Nothing.
         """
         field_names = self._args.__class__.__fields__.keys()
         for field_name in field_names:
@@ -133,16 +144,14 @@ class BaseCli(Generic[BaseModelT]):
                     self._parser.exit(1, f'internal error: no _{field_name} callable for the {field_name} command')
                 break
         else:
-            self._parser.error(f'unknown command; expected one of {', '.join(field_names)}')
+            self._parser.error(f'unknown command; expected one of {", ".join(field_names)}')
 
     def _initialize_rich_argparse(self) -> None:
-        for cls in [RichHelpFormatter]:
-            cls.styles.update({
-                'argparse.args': f'bold {cls.styles["argparse.args"]}',
-                'argparse.groups': f'bold {cls.styles["argparse.groups"]}',
-                'argparse.metavar': f'bold {cls.styles["argparse.metavar"]}',
-                'argparse.prog': f'bold {cls.styles["argparse.prog"]}',
-            })
+        """
+        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'):
@@ -152,6 +161,20 @@ class BaseCli(Generic[BaseModelT]):
                             __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]:
     """
@@ -169,7 +192,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(enum_name) for enum_name in enum_names])} is allowed, got {length} ({", ".join([option_name(enum_name) for enum_name in ret])})')
     return values
 
 
@@ -195,24 +218,24 @@ def get_from_enum(model_inst, enum_cls, default=None):
 
 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}')
+        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}')
+        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')
+        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 option_name(name: str) -> str:
+    return f'{("-" if len(name) == 1 else "--")}{name.replace("_", "-")}'
 
 
 def _matchy_length(values: Dict[str, Any], *names: str) -> int:

lockss/pybasic/errorutil.py

@@ -34,9 +34,12 @@ Error and exception utilities.
 
 class InternalError(RuntimeError):
     """
-    A simple ``RuntimeError`` with the message ``internal error``, intended for
-    situations that should never occur.
+    A simple no-arg ``RuntimeError`` with the message ``internal error``,
+    intended for situations that should never occur.
     """
 
-    def __init__(self, *args: object) -> None:
+    def __init__(self) -> None:
+        """
+        Constructs a new ``InternalError`` instance.
+        """
         super().__init__('internal error')

lockss/pybasic/fileutil.py

@@ -40,10 +40,12 @@ from typing import List, Union
 def file_lines(fpath: Path) -> List[str]:
     """
     Returns a list of lines from the given file, with '#' comments and leading
-    trailing whitespace removed, ignoring empty lines.
+    and trailing whitespace removed, ignoring empty lines.
 
-    :param fpath: A ``Path`` to a file (``-`` for ``sys.stdin``).
-    :return:      A list of lines.
+    :param fpath: A ``Path`` to a file, ``-`` for ``sys.stdin``.
+    :type fpath: Path
+    :return: A list of processed lines.
+    :rtype: List[str]
     """
     f = None
     try:
@@ -62,7 +64,9 @@ def path(purepath_or_string: Union[PurePath, str]) -> Path:
 
     :param purepath_or_string: A ``PurePath`` (or a ``str`` from which to create
                                a ``Path``).
-    :return:                   An expanded and resolved ``Path``.
+    :type purepath_or_string: Union[PurePath, str]
+    :return: An expanded and resolved ``Path``.
+    :rtype: Path
     """
     if not issubclass(type(purepath_or_string), PurePath):
         purepath_or_string = Path(purepath_or_string)

lockss/pybasic/outpututil.py

@@ -32,10 +32,8 @@
 Utilities to work with 'tabulate'.
 """
 
-
 from enum import Enum
 
-
 from pydantic.v1 import BaseModel, Field, validator
 import tabulate
 from typing import Optional
@@ -48,7 +46,7 @@ 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())}')
+    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):
@@ -56,4 +54,4 @@ class OutputFormatOptions(BaseModel):
             _ = OutputFormat[val]
             return val
         except KeyError:
-            raise ValueError(f'must be one of {', '.join(OutputFormat.__members__.keys())}; got {val}')
+            raise ValueError(f'must be one of {", ".join(OutputFormat.__members__.keys())}; got {val}')

lockss_pybasic-0.1.1.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.3
+Name: lockss-pybasic
+Version: 0.1.1
+Summary: Basic Python utilities
+License: BSD-3-Clause
+Author: Thib Guicherd-Callin
+Author-email: thib@cs.stanford.edu
+Maintainer: Thib Guicherd-Callin
+Maintainer-email: thib@cs.stanford.edu
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: pydantic (>=2.11.0,<3.0.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
+
+==============
+lockss-pybasic
+==============
+
+.. |RELEASE| replace:: 0.1.1
+.. |RELEASE_DATE| replace:: 2025-10-02
+
+**Latest release:** |RELEASE| (|RELEASE_DATE|)
+
+``lockss-pybasic`` provides basic utilities for various LOCKSS projects written in Python.
+
+-------
+Modules
+-------
+
+``lockss.pybasic.cliutil``
+   Command line utilities.
+
+   *  ``BaseCli`` is a base class for command line interfaces that uses `pydantic-argparse <https://pypi.org/project/pydantic-argparse/>`_ to define arguments and subcommands, and `rich-argparse <https://pypi.org/project/rich-argparse/>`_ to display help messages. 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``.
+
+   *  ``StringCommand`` provides a `pydantic-argparse <https://pypi.org/project/pydantic-argparse/>`_ way to define a subcommand whose only purpose is printing a string, with ``COPYRIGHT_DESCRIPTION``, ``LICENSE_DESCRIPTION`` and ``VERSION_DESCRIPTION`` constants provided for convenience. Example:
+
+      .. code-block:: python
+
+         class MyCliModel(BaseModel):
+             copyright: Optional[StringCommand.type(my_copyright_string)] = Field(description=COPYRIGHT_DESCRIPTION)
+
+   *  ``at_most_one_from_enum`` and ``get_from_enum`` provide a facility for defining a `pydantic-argparse <https://pypi.org/project/pydantic-argparse/>`_ model that defines one command line option per constant of an ``Enum``, using an ``enum`` keyword argument in the ``Field`` definition. Example:
+
+      .. code-block:: python
+
+         class Orientation(Enum):
+             horizontal = 1
+             vertical = 2
+             diagonal = 3
+
+         DEFAULT_ORIENTATION = Orientation.horizontal
+
+         class MyCliModel(BaseModel):
+             diagonal: Optional[bool] = Field(False, description='display diagonally', enum=Orientation)
+             horizontal: Optional[bool] = Field(False, description='display horizontally', enum=Orientation)
+             unrelated: Optional[bool] = Field(...)
+             vertical: Optional[bool] = Field(False, description='display vertically', enum=Orientation)
+
+             @root_validator
+             def _at_most_one_orientation(cls, values):
+                 return at_most_one_from_enum(cls, values, Orientation)
+
+             def get_orientation(self) -> Orientation:
+                 return get_from_enum(self, Orientation, DEFAULT_ORIENTATION)
+
+``lockss.pybasic.errorutil``
+   Error and exception utilities.
+
+   *  ``InternalError`` is a no-arg subclass of ``RuntimeError``.
+
+``lockss.pybasic.fileutil``
+   File and path utilities.
+
+   *  ``file_lines`` returns the non-empty lines of a file stripped of comments that begin with ``#`` and run to the end of a line.
+
+   *  ``path`` takes a string or ``PurePath`` and returns a ``Path`` for which ``Path.expanduser()`` and ``Path.resolve()`` have been called.
+
+``lockss.pybasic.outpututil``
+   Utilities to work with `tabulate <https://pypi.org/project/tabulate/>`_.
+
+   *  ``OutputFormat`` is an ``Enum`` of all the output formats from ``tabulate.tabulate_formats``.
+
+   *  ``OutputFormatOptions`` defines a `pydantic-argparse <https://pypi.org/project/pydantic-argparse/>`_ model for setting an output format from ``OutputFormat``.
+
+-------------
+Release Notes
+-------------
+
+See `<CHANGELOG.rst>`_.

lockss_pybasic-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+lockss/pybasic/__init__.py,sha256=5NRdbEb_7GIZas3_wlx8I8qoaWR2HaYAgLF-pKKi_nY,1673
+lockss/pybasic/cliutil.py,sha256=zsIU_GJX31UM4XZbMhUxFMS2zVpA09_1q1GQAMW2HOc,10347
+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.1.1.dist-info/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
+lockss_pybasic-0.1.1.dist-info/METADATA,sha256=1FRG9Ulhphoea8-n_lUCnc8oczgxzzgfOutbttcoMQE,4242
+lockss_pybasic-0.1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+lockss_pybasic-0.1.1.dist-info/RECORD,,

lockss_pybasic-0.1.0.dev22.dist-info/METADATA

@@ -1,22 +0,0 @@
-Metadata-Version: 2.3
-Name: lockss-pybasic
-Version: 0.1.0.dev22
-Summary: Basic Python utilities
-License: BSD-3-Clause
-Author: Thib Guicherd-Callin
-Author-email: thib@cs.stanford.edu
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: pydantic (>=2.11.0,<3.0.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)
-Description-Content-Type: text/x-rst
-
-

lockss_pybasic-0.1.0.dev22.dist-info/RECORD

@@ -1,9 +0,0 @@
-lockss/pybasic/__init__.py,sha256=_J-oMvR7ECgXrb8v7tZOObxiHQ-m8qNjpSUbnebj1Bw,1679
-lockss/pybasic/cliutil.py,sha256=aH401DqDLoiXX-Dqgt-tWMbO7N_HfRry0knWG2wZlm8,9024
-lockss/pybasic/errorutil.py,sha256=OJqRGOjzKK8_OTJCq77u0_XZ5ti2BoVidk5jSTMB6xg,1882
-lockss/pybasic/fileutil.py,sha256=O_EcxobrHPLeD7lAlvtYOkd0R2NOIvpGK6mZOZTxyG4,2856
-lockss/pybasic/outpututil.py,sha256=S2Jpcj7IctXoA10OFGueNzcd7fMjj6RARpc6s15_xLY,2347
-lockss_pybasic-0.1.0.dev22.dist-info/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
-lockss_pybasic-0.1.0.dev22.dist-info/METADATA,sha256=9RUVx0yb9j5-0eoNOcGlphRIDSlaJePUx6dRfW3U3ng,784
-lockss_pybasic-0.1.0.dev22.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lockss_pybasic-0.1.0.dev22.dist-info/RECORD,,