lockss-pybasic 0.2.0.dev5__py3-none-any.whl → 0.2.0.dev7__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-dev5'
+__version__ = '0.2.0-dev7'

lockss/pybasic/auidutil.py

@@ -0,0 +1,417 @@
+#!/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.
+
+"""
+LOCKSS AUID Generator
+
+Port of the AUID generation logic from org.lockss.plugin.PluginManager
+and related utility classes in the LOCKSS lockss-core library.
+"""
+
+import urllib.parse
+from typing import Dict
+
+
+class InvalidAuidError(ValueError):
+    """Raised when an AUID string is malformed or invalid."""
+    pass
+
+
+class AuidGenerator:
+    """
+    Generator for LOCKSS Archival Unit Identifiers (AUIDs).
+
+    This class provides static methods for generating and parsing AUIDs,
+    which uniquely identify archival units in the LOCKSS system.
+
+    AUID Format: pluginKey&auKey
+    - pluginKey: Plugin class name with dots replaced by pipes
+    - auKey: Canonically encoded definitional parameters
+
+    Example:
+        >>> plugin_id = "org.lockss.plugin.simulated.SimulatedPlugin"
+        >>> params = {"base_url": "http://example.com/", "year": "2023"}
+        >>> auid = AuidGenerator.generate_auid(plugin_id, params)
+        >>> print(auid)
+        org|lockss|plugin|simulated|SimulatedPlugin&base_url~http%3A%2F%2Fexample%2Ecom%2F&year~2023
+    """
+
+    @staticmethod
+    def plugin_key_from_id(plugin_id: str) -> str:
+        """
+        Convert plugin ID to plugin key by replacing dots with pipes.
+
+        Port of PluginManager.pluginKeyFromId()
+
+        Args:
+            plugin_id: Plugin class name (e.g., "org.lockss.plugin.simulated.SimulatedPlugin")
+
+        Returns:
+            Plugin key (e.g., "org|lockss|plugin|simulated|SimulatedPlugin")
+
+        Example:
+            >>> AuidGenerator.plugin_key_from_id("org.lockss.plugin.TestPlugin")
+            'org|lockss|plugin|TestPlugin'
+        """
+        if not plugin_id:
+            raise ValueError("plugin_id cannot be empty")
+        return plugin_id.replace(".", "|")
+
+    @staticmethod
+    def plugin_id_from_key(plugin_key: str) -> str:
+        """
+        Convert plugin key back to plugin ID by replacing pipes with dots.
+
+        Args:
+            plugin_key: Plugin key (e.g., "org|lockss|plugin|simulated|SimulatedPlugin")
+
+        Returns:
+            Plugin ID (e.g., "org.lockss.plugin.simulated.SimulatedPlugin")
+
+        Example:
+            >>> AuidGenerator.plugin_id_from_key("org|lockss|plugin|TestPlugin")
+            'org.lockss.plugin.TestPlugin'
+        """
+        if not plugin_key:
+            raise ValueError("plugin_key cannot be empty")
+        return plugin_key.replace("|", ".")
+
+    # Characters that don't need encoding - matches Java PropKeyEncoder exactly
+    # See lockss-core PropKeyEncoder.java lines 46-62
+    _DONT_NEED_ENCODING = set(
+        'abcdefghijklmnopqrstuvwxyz'
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+        '0123456789'
+        ' '  # Space is converted to '+' in encode()
+        '-'
+        '_'
+        '*'
+    )
+
+    @staticmethod
+    def encode_component(s: str) -> str:
+        """
+        URL-encode a string component for use in AUID.
+
+        Port of PropKeyEncoder.encode() from lockss-core.
+
+        This method encodes strings using URL encoding with the following rules:
+        - Alphanumeric characters (a-z, A-Z, 0-9) are not encoded
+        - Hyphens (-), underscores (_), and asterisks (*) are not encoded
+        - Spaces are encoded as '+'
+        - All other characters (including periods) are percent-encoded with uppercase hex digits
+
+        Note: This differs from standard URL encoding (RFC 3986) which treats
+        periods (.) as unreserved. Java's PropKeyEncoder encodes periods.
+
+        Args:
+            s: String to encode
+
+        Returns:
+            URL-encoded string with spaces as '+' and uppercase hex digits
+
+        Example:
+            >>> AuidGenerator.encode_component("http://example.com/")
+            'http%3A%2F%2Fexample%2Ecom%2F'
+        """
+        if not s:
+            return ""
+
+        result = []
+        # Encode string to UTF-8 bytes, matching Java's OutputStreamWriter behavior
+        for char in s:
+            if char in AuidGenerator._DONT_NEED_ENCODING:
+                if char == ' ':
+                    result.append('+')
+                else:
+                    result.append(char)
+            else:
+                # Encode character to UTF-8 bytes and percent-encode each byte
+                char_bytes = char.encode('utf-8')
+                for byte in char_bytes:
+                    result.append('%')
+                    result.append(format(byte, '02X'))
+
+        return ''.join(result)
+
+    @staticmethod
+    def decode_component(s: str) -> str:
+        """
+        URL-decode a string component from an AUID.
+
+        Args:
+            s: URL-encoded string
+
+        Returns:
+            Decoded string
+
+        Example:
+            >>> AuidGenerator.decode_component('http%3A%2F%2Fexample.com%2F')
+            'http://example.com/'
+        """
+        if not s:
+            return ""
+        return urllib.parse.unquote_plus(s, errors="strict")
+
+    @staticmethod
+    def props_to_canonical_encoded_string(props: Dict[str, str]) -> str:
+        """
+        Convert properties dictionary to canonical encoded string.
+
+        Port of PropUtil.propsToCanonicalEncodedString() from lockss-core.
+
+        The canonical form is created by:
+        1. Sorting keys alphabetically
+        2. Encoding each key and value
+        3. Joining with '~' between key and value, '&' between pairs
+
+        Args:
+            props: Dictionary of AU definitional parameters
+
+        Returns:
+            Canonical encoded string (e.g., "key1~val1&key2~val2")
+
+        Example:
+            >>> props = {"year": "2023", "base_url": "http://example.com/"}
+            >>> AuidGenerator.props_to_canonical_encoded_string(props)
+            'base_url~http%3A%2F%2Fexample.com%2F&year~2023'
+        """
+        if not props:
+            return ""
+
+        # Sort keys for canonical ordering (case-sensitive, like Java TreeSet)
+        sorted_keys = sorted(props.keys())
+
+        parts = []
+        for key in sorted_keys:
+            val = props[key]
+            if val is None:
+                val = ""
+            encoded_key = AuidGenerator.encode_component(str(key))
+            encoded_val = AuidGenerator.encode_component(str(val))
+            parts.append(f"{encoded_key}~{encoded_val}")
+
+        return "&".join(parts)
+
+    @staticmethod
+    def canonical_encoded_string_to_props(encoded: str) -> Dict[str, str]:
+        """
+        Decode a canonical encoded string back to properties dictionary.
+
+        Args:
+            encoded: Canonical encoded string (e.g., "key1~val1&key2~val2")
+
+        Returns:
+            Dictionary of decoded parameters
+
+        Example:
+            >>> encoded = 'base_url~http%3A%2F%2Fexample.com%2F&year~2023'
+            >>> AuidGenerator.canonical_encoded_string_to_props(encoded)
+            {'base_url': 'http://example.com/', 'year': '2023'}
+        """
+        if not encoded:
+            return {}
+
+        props = {}
+        pairs = encoded.split("&")
+
+        for pair in pairs:
+            if "~" not in pair:
+                raise ValueError("Missing tilde in key-value pair")
+            key_encoded, val_encoded = pair.split("~", 1)
+            if "~" in val_encoded:
+                raise ValueError("Additional tilde in key-value pair")
+            key = AuidGenerator.decode_component(key_encoded)
+            val = AuidGenerator.decode_component(val_encoded)
+            props[key] = val
+
+        return props
+
+    @staticmethod
+    def generate_auid(plugin_id: str, au_def_props: Dict[str, str]) -> str:
+        """
+        Generate an AUID from plugin ID and definitional properties.
+
+        Port of PluginManager.generateAuId() from lockss-core.
+
+        Args:
+            plugin_id: Plugin class name (e.g., "org.lockss.plugin.simulated.SimulatedPlugin")
+            au_def_props: Dictionary of AU definitional parameters
+
+        Returns:
+            AUID string (e.g., "org|lockss|plugin|simulated|SimulatedPlugin&base_url~...")
+
+        Raises:
+            ValueError: If plugin_id is empty
+
+        Example:
+            >>> plugin_id = "org.lockss.plugin.simulated.SimulatedPlugin"
+            >>> params = {"base_url": "http://example.com/", "year": "2023"}
+            >>> AuidGenerator.generate_auid(plugin_id, params)
+            'org|lockss|plugin|simulated|SimulatedPlugin&base_url~http%3A%2F%2Fexample.com%2F&year~2023'
+        """
+        if not plugin_id:
+            raise ValueError("plugin_id cannot be empty")
+
+        plugin_key = AuidGenerator.plugin_key_from_id(plugin_id)
+        au_key = AuidGenerator.props_to_canonical_encoded_string(au_def_props)
+        return f"{plugin_key}&{au_key}"
+
+    @staticmethod
+    def plugin_key_from_auid(auid: str) -> str:
+        """
+        Extract plugin key from AUID.
+
+        Port of PluginManager.pluginKeyFromAuId() from lockss-core.
+
+        Args:
+            auid: AUID string
+
+        Returns:
+            Plugin key portion
+
+        Raises:
+            InvalidAuidError: If AUID format is invalid
+
+        Example:
+            >>> auid = "org|lockss|plugin|TestPlugin&base_url~http%3A%2F%2Fexample.com%2F"
+            >>> AuidGenerator.plugin_key_from_auid(auid)
+            'org|lockss|plugin|TestPlugin'
+        """
+        if not auid:
+            raise InvalidAuidError("AUID cannot be empty")
+
+        idx = auid.find("&")
+        if idx < 0:
+            raise InvalidAuidError(f"AUID missing '&' separator: {auid}")
+
+        return auid[:idx]
+
+    @staticmethod
+    def au_key_from_auid(auid: str) -> str:
+        """
+        Extract AU key from AUID.
+
+        Port of PluginManager.auKeyFromAuId() from lockss-core.
+
+        Args:
+            auid: AUID string
+
+        Returns:
+            AU key portion (may be empty string)
+
+        Raises:
+            InvalidAuidError: If AUID format is invalid
+
+        Example:
+            >>> auid = "org|lockss|plugin|TestPlugin&base_url~http%3A%2F%2Fexample.com%2F"
+            >>> AuidGenerator.au_key_from_auid(auid)
+            'base_url~http%3A%2F%2Fexample.com%2F'
+        """
+        if not auid:
+            raise InvalidAuidError("AUID cannot be empty")
+
+        idx = auid.find("&")
+        if idx < 0:
+            raise InvalidAuidError(f"AUID missing '&' separator: {auid}")
+
+        return auid[idx + 1:]
+
+    @staticmethod
+    def plugin_id_from_auid(auid: str) -> str:
+        """
+        Extract plugin ID from AUID.
+
+        Port of PluginManager.pluginIdFromAuId() from lockss-core.
+
+        Args:
+            auid: AUID string
+
+        Returns:
+            Plugin ID (with dots restored)
+
+        Raises:
+            InvalidAuidError: If AUID format is invalid
+
+        Example:
+            >>> auid = "org|lockss|plugin|TestPlugin&base_url~http%3A%2F%2Fexample.com%2F"
+            >>> AuidGenerator.plugin_id_from_auid(auid)
+            'org.lockss.plugin.TestPlugin'
+        """
+        plugin_key = AuidGenerator.plugin_key_from_auid(auid)
+        return AuidGenerator.plugin_id_from_key(plugin_key)
+
+    @staticmethod
+    def decode_auid(auid: str) -> Dict[str, str]:
+        """
+        Decode an AUID into its definitional parameters.
+
+        This is a convenience method that extracts the AU key and decodes it.
+
+        Args:
+            auid: AUID string
+
+        Returns:
+            Dictionary of decoded AU parameters
+
+        Raises:
+            InvalidAuidError: If AUID format is invalid
+
+        Example:
+            >>> auid = "org|lockss|plugin|TestPlugin&base_url~http%3A%2F%2Fexample.com%2F&year~2023"
+            >>> AuidGenerator.decode_auid(auid)
+            {'base_url': 'http://example.com/', 'year': '2023'}
+        """
+        au_key = AuidGenerator.au_key_from_auid(auid)
+        return AuidGenerator.canonical_encoded_string_to_props(au_key)
+
+    @staticmethod
+    def validate_auid(auid: str) -> bool:
+        """
+        Check if an AUID string is valid.
+
+        Args:
+            auid: AUID string to validate
+
+        Returns:
+            True if valid, False otherwise
+
+        Example:
+            >>> AuidGenerator.validate_auid("org|lockss|plugin|TestPlugin&base_url~http%3A%2F%2Fexample.com%2F")
+            True
+            >>> AuidGenerator.validate_auid("invalid-auid")
+            False
+        """
+        try:
+            AuidGenerator.plugin_key_from_auid(auid)
+            AuidGenerator.au_key_from_auid(auid)
+            return True
+        except (InvalidAuidError, ValueError):
+            return False

lockss/pybasic/cliutil.py

@@ -34,55 +34,47 @@ Command line utilities.
 
 from collections.abc import Callable
 import sys
-from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar, TYPE_CHECKING
-import warnings
+from typing import Any, Dict, Generic, Optional, TypeVar
 
-from pydantic.v1 import BaseModel, PrivateAttr, create_model
-from pydantic.v1.fields import FieldInfo
+from pydantic.v1 import BaseModel
 from pydantic_argparse import ArgumentParser
 from pydantic_argparse.argparse.actions import SubParsersAction
 from rich_argparse import RichHelpFormatter
 
-if TYPE_CHECKING:
-    from _typeshed import SupportsWrite as SupportsWriteStr
-else:
-    SupportsWriteStr = Any
 
+class ActionCommand(Callable, BaseModel):
+    """
+    Base class for a pydantic-argparse style command.
+    """
+    pass
 
-class StringCommand(BaseModel):
-
-    def display(self, file: SupportsWriteStr=sys.stdout) -> None:
-        print(getattr(self, '_display_string'), file=file)
-
-    @staticmethod
-    def make(model_name: str, option_name: str, description: str, display_string: str):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")  # Pydantic v1 demands that PrivateAttr begins with a hyphen but raises a warning that such names are for private attributes
-            return create_model(model_name,
-                                __base__=StringCommand,
-                                _display_string=PrivateAttr(display_string),
-                                **{option_name: (Optional[bool], FieldInfo(False, description=description))})
 
+class StringCommand(ActionCommand):
+    """
+    A pydantic-argparse style command that prints a string.
 
-class CopyrightCommand(StringCommand):
+    Example of use:
 
-    @staticmethod
-    def make(display_string: str):
-        return StringCommand.make('CopyrightCommand', 'copyright', 'print the copyright and exit', display_string)
+    .. code-block:: python
 
+       class MyCliModel(BaseModel):
+           copyright: Optional[StringCommand.type(my_copyright_string)] = Field(description=COPYRIGHT_DESCRIPTION)
 
-class LicenseCommand(StringCommand):
+    See also the convenience constants ``COPYRIGHT_DESCRIPTION``,
+    ``LICENSE_DESCRIPTION``, and ``VERSION_DESCRIPTION``.
+    """
 
     @staticmethod
-    def make(display_string: str):
-        return StringCommand.make('LicenseCommand', 'license', 'print the software license and exit', display_string)
+    def type(display_str: str):
+        class _StringCommand(StringCommand):
+            def __call__(self, file=sys.stdout, **kwargs):
+                print(display_str, file=file)
+        return _StringCommand
 
 
-class VersionCommand(StringCommand):
-
-    @staticmethod
-    def make(display_string: str):
-        return StringCommand.make('VersionCommand', 'version', 'print the version number 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'
 
 
 BaseModelT = TypeVar('BaseModelT', bound=BaseModel)
@@ -187,7 +179,7 @@ class BaseCli(Generic[BaseModelT]):
             })
 
 
-def at_most_one_from_enum(model_cls: type[BaseModel], values: Dict[str, Any], enum_cls) -> Dict[str, Any]:
+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
@@ -203,7 +195,7 @@ def at_most_one_from_enum(model_cls: type[BaseModel], values: Dict[str, Any], en
     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(model_cls, enum_name) for enum_name in enum_names])} 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
 
 
@@ -227,21 +219,21 @@ def get_from_enum(model_inst, enum_cls, default=None):
     return default
 
 
-def at_most_one(model_cls: type[BaseModel], values: Dict[str, Any], *names: str):
+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(model_cls, name) for name in names])} 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(model_cls: type[BaseModel], values: Dict[str, Any], *names: str):
+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(model_cls, name) for name in names])} 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(model_cls: type[BaseModel], values: Dict[str, Any], *names: str):
+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(model_cls, name) for name in names])} required')
+        raise ValueError(f'one or more of {", ".join([option_name(name) for name in names])} is required')
     return values
 
 
@@ -250,7 +242,7 @@ def option_name(model_cls: type[BaseModel], name: str) -> str:
         raise RuntimeError(f'invalid name: {name}')
     if alias := info.alias:
         name = alias
-    return f'{('-' if len(name) == 1 else '--')}{name.replace('_', '-')}'
+    return f'{("-" if len(name) == 1 else "--")}{name.replace("_", "-")}'
 
 
 def _matchy_length(values: Dict[str, Any], *names: str) -> int:

lockss/pybasic/outpututil.py

@@ -46,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):
@@ -54,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.2.0.dev5.dist-info → lockss_pybasic-0.2.0.dev7.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: lockss-pybasic
-Version: 0.2.0.dev5
+Version: 0.2.0.dev7
 Summary: Basic Python utilities
 License: BSD-3-Clause
+License-File: LICENSE
 Author: Thib Guicherd-Callin
 Author-email: thib@cs.stanford.edu
 Maintainer: Thib Guicherd-Callin
@@ -26,8 +27,8 @@ Description-Content-Type: text/x-rst
 lockss-pybasic
 ==============
 
-.. |RELEASE| replace:: 0.1.0
-.. |RELEASE_DATE| replace:: 2025-07-01
+.. |RELEASE| replace:: 0.1.1
+.. |RELEASE_DATE| replace:: 2025-10-02
 
 **Latest release:** |RELEASE| (|RELEASE_DATE|)
 

lockss_pybasic-0.2.0.dev7.dist-info/RECORD

@@ -0,0 +1,10 @@
+lockss/pybasic/__init__.py,sha256=zBCFbOy0mzMxX4ofmKT5pq7i2s5bTNX5ECUCi02W2M4,1678
+lockss/pybasic/auidutil.py,sha256=o5IsRLEYROXRVS6oTO1VFtdzw7SImYSR5VcqAMHY4To,13921
+lockss/pybasic/cliutil.py,sha256=BFOijSrTByMHno3bbDmtICLQfREJpD7lVGUAuzvrHBY,10697
+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.dev7.dist-info/METADATA,sha256=ReyRdrU3vbGjOcdjkz4r2nqNCHXHWLK0tsN7g_2b2_s,4269
+lockss_pybasic-0.2.0.dev7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+lockss_pybasic-0.2.0.dev7.dist-info/licenses/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
+lockss_pybasic-0.2.0.dev7.dist-info/RECORD,,

{lockss_pybasic-0.2.0.dev5.dist-info → lockss_pybasic-0.2.0.dev7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

lockss_pybasic-0.2.0.dev5.dist-info/RECORD

@@ -1,9 +0,0 @@
-lockss/pybasic/__init__.py,sha256=-Q8lj5dmHarJid06shaGAk79FNGd3QUDDyFCPMVOeAY,1678
-lockss/pybasic/cliutil.py,sha256=PaMrDg2eGMx_h1JEybvgLlXnvxV09CYlEFBIHS1urgA,11475
-lockss/pybasic/errorutil.py,sha256=XI84PScZ851_-gfoazivJ8ceieMYWaxQr7qih5ltga0,1951
-lockss/pybasic/fileutil.py,sha256=BpdoPWL70xYTuhyQRBEurScRVnPQg0mX-XW8yyKPGjw,2958
-lockss/pybasic/outpututil.py,sha256=JyXKXlkaCcCGvonUvmDGRdI6PxwN5t7DPVIk64S8-2g,2345
-lockss_pybasic-0.2.0.dev5.dist-info/LICENSE,sha256=O9ONND4uDxY_jucI4jZDf2liAk05ScEJaYu-Al7EOdQ,1506
-lockss_pybasic-0.2.0.dev5.dist-info/METADATA,sha256=QhQmvLDES42rAOQTuNcbd_8J7IEX8hKut4uK2L5gmrQ,4247
-lockss_pybasic-0.2.0.dev5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-lockss_pybasic-0.2.0.dev5.dist-info/RECORD,,