lockss-turtles 0.6.0.dev2__py3-none-any.whl → 0.6.0.dev4__py3-none-any.whl

lockss/turtles/__init__.py

@@ -5,7 +5,7 @@ Library and command line tool to manage LOCKSS plugin sets and LOCKSS plugin
 registries.
 """
 
-__version__ = '0.6.0-dev2'
+__version__ = '0.6.0-dev4'
 
 __copyright__ = '''
 Copyright (c) 2000-2025, Board of Trustees of Leland Stanford Jr. University

lockss/turtles/app.py

@@ -28,79 +28,135 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-from collections.abc import Callable
-import importlib.resources as IR
+# Remove in Python 3.14
+# See https://stackoverflow.com/questions/33533148/how-do-i-type-hint-a-method-with-the-type-of-the-enclosing-class/33533514#33533514
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import ClassVar, Literal, Optional, Union
 
+import yaml
 from lockss.pybasic.fileutil import path
+from pydantic import BaseModel, Field
 import xdg
 
-from . import resources as __resources__
-from .plugin import Plugin
-from .plugin_registry import PluginRegistry, PluginRegistryCatalog
-from .plugin_set import PluginSet, PluginSetCatalog
-from .util import YamlT, load_and_validate
+from .plugin import Plugin, PluginIdentifier
+from .plugin_registry import PluginRegistry, PluginRegistryCatalog, PluginRegistryCatalogKind, PluginRegistryKind, PluginRegistryLayerIdentifier
+from .plugin_set import PluginSet, PluginSetCatalog, PluginSetCatalogKind, PluginSetKind
+from .util import BaseModelWithRoot, PathOrStr
 
 
-class TurtlesApp(object):
 
-    CONFIG_DIR_NAME = 'lockss-turtles'
+PluginSigningCredentialsKind = Literal['PluginSigningCredentials']
+
+
+class PluginSigningCredentials(BaseModelWithRoot):
+    kind: PluginSigningCredentialsKind = Field(description="This object's kind")
+    plugin_signing_keystore: str = Field(title='Plugin Signing Keystore', description='A path to the plugin signing keystore')
+    plugin_signing_alias: str = Field(title='Plugin Signing Alias', description='The plugin signing alias to use')
+
+    def get_plugin_signing_alias(self) -> str:
+        return self.plugin_signing_alias
 
-    XDG_CONFIG_DIR: Path = xdg.xdg_config_home().joinpath(CONFIG_DIR_NAME)
+    def get_plugin_signing_keystore(self) -> Path:
+        return self.get_root().joinpath(self.plugin_signing_keystore)
 
-    USR_CONFIG_DIR: Path = Path('/usr/local/share', CONFIG_DIR_NAME)
 
-    ETC_CONFIG_DIR: Path = Path('/etc', CONFIG_DIR_NAME)
+class TurtlesApp(object):
+
+    CONFIG_DIR_NAME: ClassVar[str] = 'lockss-turtles'
+
+    XDG_CONFIG_DIR: ClassVar[Path] = Path(xdg.xdg_config_home(), CONFIG_DIR_NAME)
 
-    CONFIG_DIRS: List[Path] = [XDG_CONFIG_DIR, USR_CONFIG_DIR, ETC_CONFIG_DIR]
+    USR_CONFIG_DIR: ClassVar[Path] = Path('/usr/local/share', CONFIG_DIR_NAME)
 
-    PLUGIN_REGISTRY_CATALOG: str = 'plugin-registry-catalog.yaml'
+    ETC_CONFIG_DIR: ClassVar[Path] = Path('/etc', CONFIG_DIR_NAME)
 
-    PLUGIN_SET_CATALOG: str = 'plugin-set-catalog.yaml'
+    CONFIG_DIRS: ClassVar[tuple[Path, ...]] = (XDG_CONFIG_DIR, USR_CONFIG_DIR, ETC_CONFIG_DIR)
 
-    PLUGIN_SIGNING_CREDENTIALS: str = 'plugin-signing-credentials.yaml'
+    PLUGIN_REGISTRY_CATALOG: ClassVar[str] = 'plugin-registry-catalog.yaml'
 
-    PLUGIN_SIGNING_CREDENTIALS_SCHEMA: str = 'plugin-signing-credentials-schema.json'
+    PLUGIN_SET_CATALOG: ClassVar[str] = 'plugin-set-catalog.yaml'
+
+    PLUGIN_SIGNING_CREDENTIALS: ClassVar[str] = 'plugin-signing-credentials.yaml'
 
     def __init__(self) -> None:
         super().__init__()
         self._password: Optional[Callable[[], str]] = None
-        self._plugin_registries: Optional[List[PluginRegistry]] = None
-        self._plugin_sets: Optional[List[PluginSet]] = None
-        self._plugin_signing_credentials: YamlT = None
+        self._plugin_registries: list[PluginRegistry] = list()
+        self._plugin_registry_catalogs: list[PluginRegistryCatalog] = list()
+        self._plugin_set_catalogs: list[PluginSetCatalog] = list()
+        self._plugin_sets: list[PluginSet] = list()
+        self._plugin_signing_credentials: Optional[PluginSigningCredentials] = None
 
-    def build_plugin(self, plugin_ids: List[str]) -> Dict[str, Tuple[str, Path, Plugin]]:
+    def build_plugin(self, plugin_ids: list[PluginIdentifier]) -> dict[str, tuple[str, Path, Plugin]]:
         return {plugin_id: self._build_one_plugin(plugin_id) for plugin_id in plugin_ids}
 
-    def deploy_plugin(self, src_paths: List[Path], layer_ids: List[str], interactive: bool=False) -> Dict[Tuple[Path, str], List[Tuple[str, str, Optional[Path], Optional[Plugin]]]]:
+    def deploy_plugin(self, src_paths: list[Path], layer_ids: list[PluginRegistryLayerIdentifier], interactive: bool=False) -> dict[tuple[Path, str], list[tuple[str, str, Optional[Path], Optional[Plugin]]]]:
         plugin_ids = [Plugin.id_from_jar(src_path) for src_path in src_paths]
         return {(src_path, plugin_id): self._deploy_one_plugin(src_path,
                                                                plugin_id,
                                                                layer_ids,
                                                                interactive=interactive) for src_path, plugin_id in zip(src_paths, plugin_ids)}
 
-    def load_plugin_registries(self, plugin_registry_catalog_path: Optional[Union[Path, str]]=None) -> None:
-        if self._plugin_registries is None:
-            plugin_registry_catalog = PluginRegistryCatalog.from_path(self.select_plugin_registry_catalog(plugin_registry_catalog_path))
-            self._plugin_registries = list()
-            for plugin_registry_file in plugin_registry_catalog.get_plugin_registry_files():
-                self._plugin_registries.extend(PluginRegistry.from_path(plugin_registry_file))
-
-    def load_plugin_sets(self, plugin_set_catalog_path: Optional[Union[Path, str]]=None) -> None:
-        if self._plugin_sets is None:
-            plugin_set_catalog = PluginSetCatalog.from_path(self.select_plugin_set_catalog(plugin_set_catalog_path))
-            self._plugin_sets = list()
-            for plugin_set_file in plugin_set_catalog.get_plugin_set_files():
-                self._plugin_sets.extend(PluginSet.from_path(plugin_set_file))
-
-    def load_plugin_signing_credentials(self, plugin_signing_credentials_path: Optional[Union[Path, str]]=None) -> None:
-        if self._plugin_signing_credentials is None:
-            plugin_signing_credentials_path = path(plugin_signing_credentials_path) if plugin_signing_credentials_path else self._select_file(TurtlesApp.PLUGIN_SIGNING_CREDENTIALS)
-            with IR.path(__resources__, TurtlesApp.PLUGIN_SIGNING_CREDENTIALS_SCHEMA) as plugin_signing_credentials_schema_path:
-                self._plugin_signing_credentials = load_and_validate(plugin_signing_credentials_schema_path, plugin_signing_credentials_path)
-
-    def release_plugin(self, plugin_ids: List[str], layer_ids: List[str], interactive: bool=False) -> Dict[str, List[Tuple[str, str, Path, Plugin]]]:
+    def load_plugin_registries(self, plugin_registry_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_registry_path = path(plugin_registry_path_or_str)
+        if plugin_registry_path in map(lambda pr: pr.get_root(), self._plugin_registries):
+            raise ValueError(f'Plugin registries already loaded from: {plugin_registry_path!s}')
+        with plugin_registry_path.open('r') as fpr:
+            for yaml_obj in yaml.safe_load_all(fpr):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginRegistryKind.__args__:
+                    plugin_registry = PluginRegistry(**yaml_obj).initialize(plugin_registry_path)
+                    self._plugin_registries.append(plugin_registry)
+        return self
+
+    def load_plugin_registry_catalogs(self, plugin_registry_catalog_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_registry_catalog_path = path(plugin_registry_catalog_path_or_str)
+        if plugin_registry_catalog_path in map(lambda prc: prc.get_root(), self._plugin_registry_catalogs):
+            raise ValueError(f'Plugin registry catalogs already loaded from: {plugin_registry_catalog_path!s}')
+        with plugin_registry_catalog_path.open('r') as fprc:
+            for yaml_obj in yaml.safe_load_all(fprc):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginRegistryCatalogKind.__args__:
+                    plugin_registry_catalog = PluginRegistryCatalog(**yaml_obj).initialize(plugin_registry_catalog_path)
+                    self._plugin_registry_catalogs.append(plugin_registry_catalog)
+                    for plugin_registry_file in plugin_registry_catalog.get_plugin_registry_files():
+                        self.load_plugin_registries(plugin_registry_catalog_path.joinpath(plugin_registry_file))
+        return self
+
+    def load_plugin_set_catalogs(self, plugin_set_catalog_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_set_catalog_path = path(plugin_set_catalog_path_or_str)
+        if plugin_set_catalog_path in map(lambda psc: psc.get_root(), self._plugin_set_catalogs):
+            raise ValueError(f'Plugin set catalogs already loaded from: {plugin_set_catalog_path!s}')
+        with plugin_set_catalog_path.open('r') as fpsc:
+            for yaml_obj in yaml.safe_load_all(fpsc):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginSetCatalogKind.__args__:
+                    plugin_set_catalog = PluginSetCatalog(**yaml_obj).initialize(plugin_set_catalog_path)
+                    self._plugin_set_catalogs.append(plugin_set_catalog)
+                    for plugin_set_file in plugin_set_catalog.get_plugin_set_files():
+                        self.load_plugin_sets(plugin_set_catalog_path.joinpath(plugin_set_file))
+        return self
+
+    def load_plugin_sets(self, plugin_set_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_set_path = path(plugin_set_path_or_str)
+        if plugin_set_path in map(lambda ps: ps.get_root(), self._plugin_sets):
+            raise ValueError(f'Plugin sets already loaded from: {plugin_set_path!s}')
+        with plugin_set_path.open('r') as fps:
+            for yaml_obj in yaml.safe_load_all(fps):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginSetKind.__args__:
+                    plugin_set = PluginSet(**yaml_obj).initialize(plugin_set_path)
+                    self._plugin_sets.append(plugin_set)
+        return self
+
+    def load_plugin_signing_credentials(self, plugin_signing_credentials_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_signing_credentials_path = path(plugin_signing_credentials_path_or_str)
+        if self._plugin_signing_credentials:
+            raise ValueError(f'Plugin signing credentials already loaded from: {self._plugin_signing_credentials.get_root()!s}')
+        with plugin_signing_credentials_path.open('r') as fpsc:
+            self._plugin_signing_credentials = PluginSigningCredentials(**yaml.safe_load(fpsc)).initialize(plugin_signing_credentials_path)
+        return self
+
+    def release_plugin(self, plugin_ids: list[PluginIdentifier], layer_ids: list[PluginRegistryLayerIdentifier], interactive: bool=False) -> dict[str, list[tuple[str, str, Path, Plugin]]]:
         # ... plugin_id -> (set_id, jar_path, plugin)
         ret1 = self.build_plugin(plugin_ids)
         jar_paths = [jar_path for set_id, jar_path, plugin in ret1.values()]
@@ -110,19 +166,10 @@ class TurtlesApp(object):
                                   interactive=interactive)
         return {plugin_id: val for (jar_path, plugin_id), val in ret2.items()}
 
-    def select_plugin_registry_catalog(self, preselected: Optional[Union[Path, str]]=None) -> Path:
-        return TurtlesApp._select_file(TurtlesApp.PLUGIN_REGISTRY_CATALOG, preselected)
-
-    def select_plugin_set_catalog(self, preselected: Optional[Union[Path, str]]=None) -> Path:
-        return TurtlesApp._select_file(TurtlesApp.PLUGIN_SET_CATALOG, preselected)
-
-    def select_plugin_signing_credentials(self, preselected: Optional[Union[Path, str]]=None) -> Path:
-        return TurtlesApp._select_file(TurtlesApp.PLUGIN_SIGNING_CREDENTIALS, preselected)
-
     def set_password(self, pw: Union[Callable[[], str], str]) -> None:
         self._password = pw if callable(pw) else lambda: pw
 
-    def _build_one_plugin(self, plugin_id: str) -> Tuple[str, Optional[Path], Optional[Plugin]]:
+    def _build_one_plugin(self, plugin_id: str) -> tuple[str, Optional[Path], Optional[Plugin]]:
         for plugin_set in self._plugin_sets:
             if plugin_set.has_plugin(plugin_id):
                 bp = plugin_set.build_plugin(plugin_id,
@@ -132,7 +179,7 @@ class TurtlesApp(object):
                 return plugin_set.get_id(), bp[0] if bp else None, bp[1] if bp else None
         raise Exception(f'{plugin_id}: not found in any plugin set')
 
-    def _deploy_one_plugin(self, src_jar: Path, plugin_id: str, layer_ids: List[str], interactive: bool=False) -> List[Tuple[str, str, Optional[Path], Optional[Plugin]]]:
+    def _deploy_one_plugin(self, src_jar: Path, plugin_id: PluginIdentifier, layer_ids: list[PluginRegistryLayerIdentifier], interactive: bool=False) -> list[tuple[str, str, Optional[Path], Optional[Plugin]]]:
         ret = list()
         for plugin_registry in self._plugin_registries:
             if plugin_registry.has_plugin(plugin_id):
@@ -154,39 +201,45 @@ class TurtlesApp(object):
         return self._password() if self._password else None
 
     def _get_plugin_signing_alias(self) -> str:
-        return self._plugin_signing_credentials['plugin-signing-alias']
+        return self._plugin_signing_credentials.get_plugin_signing_alias()
 
-    def _get_plugin_signing_keystore(self) -> str:
-        return self._plugin_signing_credentials['plugin-signing-keystore']
+    def _get_plugin_signing_keystore(self) -> Path:
+        return self._plugin_signing_credentials.get_plugin_signing_keystore()
 
     def _get_plugin_signing_password(self) -> str:
         return self._get_password()
 
     @staticmethod
-    def default_plugin_registry_catalogs() -> List[Path]:
+    def default_plugin_registry_catalog_choices() -> tuple[Path, ...]:
         return TurtlesApp._default_files(TurtlesApp.PLUGIN_REGISTRY_CATALOG)
 
     @staticmethod
-    def default_plugin_set_catalogs() -> List[Path]:
+    def default_plugin_set_catalog_choices() -> tuple[Path, ...]:
         return TurtlesApp._default_files(TurtlesApp.PLUGIN_SET_CATALOG)
 
     @staticmethod
-    def default_plugin_signing_credentials() -> List[Path]:
+    def default_plugin_signing_credentials_choices() -> tuple[Path, ...]:
         return TurtlesApp._default_files(TurtlesApp.PLUGIN_SIGNING_CREDENTIALS)
 
     @staticmethod
-    def _default_files(file_str) -> List[Path]:
-        return [dir_path.joinpath(file_str) for dir_path in TurtlesApp.CONFIG_DIRS]
+    def select_default_plugin_registry_catalog() -> Optional[Path]:
+        return TurtlesApp._select_file(TurtlesApp.default_plugin_registry_catalog_choices())
 
     @staticmethod
-    def _select_file(file_str, preselected: Optional[Union[Path, str]]=None) -> Path:
-        if preselected:
-            preselected = path(preselected)
-            if not preselected.is_file():
-                raise FileNotFoundError(str(preselected))
-            return preselected
-        choices = TurtlesApp._default_files(file_str)
-        ret = next(filter(lambda f: f.is_file(), choices), None)
-        if ret is None:
-            raise FileNotFoundError(' or '.join(map(str, choices)))
-        return ret
+    def select_default_plugin_set_catalog() -> Optional[Path]:
+        return TurtlesApp._select_file(TurtlesApp.default_plugin_set_catalog_choices())
+
+    @staticmethod
+    def select_default_plugin_signing_credentials() -> Optional[Path]:
+        return TurtlesApp._select_file(TurtlesApp.default_plugin_signing_credentials_choices())
+
+    @staticmethod
+    def _default_files(file_str) -> tuple[Path, ...]:
+        return tuple(dir_path.joinpath(file_str) for dir_path in TurtlesApp.CONFIG_DIRS)
+
+    @staticmethod
+    def _select_file(choices: Iterable[Path]) -> Optional[Path]:
+        for p in choices:
+            if p.is_file():
+                return p
+        return None

lockss/turtles/cli.py

@@ -41,73 +41,104 @@ from lockss.pybasic.outpututil import OutputFormatOptions
 from pydantic.v1 import BaseModel, Field, FilePath
 from pydantic.v1.class_validators import validator
 import tabulate
-from typing import List, Optional
+from typing import Optional
 
 from . import __copyright__, __license__, __version__
 from .app import TurtlesApp
+from .plugin_registry import PluginRegistryLayerIdentifier
+from .util import file_or
 
 
 class PluginBuildingOptions(BaseModel):
-    plugin_set_catalog: Optional[FilePath] = Field(aliases=['-s'], description=f'(plugin set catalog) load the plugin set catalog from the given file, or if none, from {" or ".join(map(str, TurtlesApp.default_plugin_set_catalogs()))}')
-    plugin_signing_credentials: Optional[FilePath] = Field(aliases=['-c'], description=f'(plugin signing credentials) load the plugin signing credentials from the given file, or if none, from {" or ".join(map(str, TurtlesApp.default_plugin_signing_credentials()))}')
+    plugin_set: Optional[list[FilePath]] = Field(aliases=['-s'], description=f'(plugin sets) add one or more plugin sets to the loaded plugin sets')
+    plugin_set_catalog: Optional[list[FilePath]] = Field(aliases=['-S'], description=f'(plugin sets) add one or more plugin set catalogs to the loaded plugin set catalogs; if no plugin set catalogs or plugin sets are specified, load {file_or(TurtlesApp.default_plugin_set_catalog_choices())}')
+    plugin_signing_credentials: Optional[FilePath] = Field(aliases=['-c'], description=f'(plugin signing credentials) load the plugin signing credentials from the given file, or if none, from {file_or(TurtlesApp.default_plugin_signing_credentials_choices())}')
     plugin_signing_password: Optional[str] = Field(description='(plugin signing credentials) set the plugin signing password, or if none, prompt interactively')
 
+    def get_plugin_sets(self) -> list[Path]:
+        return [path(p) for p in self.plugin_set or []]
+
+    def get_plugin_set_catalogs(self) -> list[Path]:
+        if self.plugin_set or self.plugin_set_catalog:
+            return [path(p) for p in self.plugin_set_catalog or []]
+        if single := TurtlesApp.select_default_plugin_set_catalog():
+            return [single]
+        raise FileNotFoundError(file_or(TurtlesApp.default_plugin_set_catalog_choices()))
+
+    def get_plugin_signing_credentials(self) -> Path:
+        if self.plugin_signing_credentials:
+            return path(self.plugin_signing_credentials)
+        if ret := TurtlesApp.select_default_plugin_signing_credentials():
+            return ret
+        raise FileNotFoundError(file_or(TurtlesApp.default_plugin_signing_credentials_choices()))
+
 
 class PluginDeploymentOptions(BaseModel):
-    plugin_registry_catalog: Optional[FilePath] = Field(aliases=['-r'], description=f'(plugin registry catalog) load the plugin registry catalog from the given file, or if none, from {" or ".join(map(str, TurtlesApp.default_plugin_registry_catalogs()))}')
-    plugin_registry_layer: Optional[List[str]] = Field(aliases=['-l'], description='(plugin registry layers) add one or more plugin registry layers to the set of plugin registry layers to process')
-    plugin_registry_layers: Optional[List[FilePath]] = Field(aliases=['-L'], description='(plugin registry layers) add the plugin registry layers listed in one or more files to the set of plugin registry layers to process')
+    plugin_registry: Optional[list[FilePath]] = Field(aliases=['-r'], description=f'(plugin registry) add one or more plugin registries to the loaded plugin registries')
+    plugin_registry_catalog: Optional[list[FilePath]] = Field(aliases=['-R'], description=f'(plugin registry) add one or more plugin registry catalogs to the loaded plugin registry catalogs; if no plugin registry catalogs or plugin registries are specified, load {file_or(TurtlesApp.default_plugin_registry_catalog_choices())}')
+    plugin_registry_layer: Optional[list[str]] = Field(aliases=['-l'], description='(plugin registry layers) add one or more plugin registry layers to the set of plugin registry layers to process')
+    plugin_registry_layers: Optional[list[FilePath]] = Field(aliases=['-L'], description='(plugin registry layers) add the plugin registry layers listed in one or more files to the set of plugin registry layers to process')
     testing: Optional[bool] = Field(False, aliases=['-t'], description='(plugin registry layers) synonym for --plugin-registry-layer testing (i.e. add "testing" to the list of plugin registry layers to process)')
     production: Optional[bool] = Field(False, aliases=['-p'], description='(plugin registry layers) synonym for --plugin-registry-layer production (i.e. add "production" to the list of plugin registry layers to process)')
 
     @validator('plugin_registry_layers', each_item=True, pre=True)
-    def _expand_each_plugin_registry_layers_path(cls, v: Path):
+    def _expand_each_plugin_registry_layers_path(cls, v: Path) -> Path:
         return path(v)
 
-    def get_plugin_registry_layers(self):
-        ret = [*self.plugin_registry_layer[:], *[file_lines(file_path) for file_path in self.plugin_registry_layers]]
+    def get_plugin_registries(self) -> list[Path]:
+        return [path(p) for p in self.plugin_registry or []]
+
+    def get_plugin_registry_catalogs(self) -> list[Path]:
+        if self.plugin_registry or self.plugin_registry_catalog:
+            return [path(p) for p in self.plugin_registry_catalog or []]
+        if single := TurtlesApp.select_default_plugin_registry_catalog():
+            return [single]
+        raise FileNotFoundError(file_or(TurtlesApp.default_plugin_set_catalog_choices()))
+
+    def get_plugin_registry_layers(self) -> list[PluginRegistryLayerIdentifier]:
+        ret = [*(self.plugin_registry_layer or []), *[file_lines(file_path) for file_path in self.plugin_registry_layers or []]]
         for layer in reversed(['testing', 'production']):
             if getattr(self, layer, False):
                 ret.insert(0, layer)
-        if len(ret) == 0:
-            raise RuntimeError('empty list of plugin registry layers')
-        return ret
+        if ret:
+            return ret
+        raise ValueError('Empty list of plugin registry layers')
 
 
 class PluginIdentifierOptions(BaseModel):
     """
     The --identifier/-i and --identifiers/-I options.
     """
-    plugin_identifier: Optional[List[str]] = Field([], aliases=['-i'], description='(plugin identifiers) add one or more plugin identifiers to the set of plugin identifiers to process')
-    plugin_identifiers: Optional[List[FilePath]] = Field([], aliases=['-I'], description='(plugin identifiers) add the plugin identifiers listed in one or more files to the set of plugin identifiers to process')
+    plugin_identifier: Optional[list[str]] = Field(aliases=['-i'], description='(plugin identifiers) add one or more plugin identifiers to the set of plugin identifiers to process')
+    plugin_identifiers: Optional[list[FilePath]] = Field(aliases=['-I'], description='(plugin identifiers) add the plugin identifiers listed in one or more files to the set of plugin identifiers to process')
 
     @validator('plugin_identifiers', each_item=True, pre=True)
-    def _expand_each_plugin_identifiers_path(cls, v: Path):
+    def _expand_each_plugin_identifiers_path(cls, v: Path) -> Path:
         return path(v)
 
-    def get_plugin_identifiers(self) -> List[str]:
-        ret = [*self.plugin_identifier[:], *[file_lines(file_path) for file_path in self.plugin_identifiers]]
-        if len(ret) == 0:
-            raise RuntimeError('empty list of plugin identifiers')
-        return ret
+    def get_plugin_identifiers(self) -> list[str]:
+        ret = [*(self.plugin_identifier or []), *[file_lines(file_path) for file_path in self.plugin_identifiers or []]]
+        if ret:
+            return ret
+        raise ValueError('Empty list of plugin identifiers')
 
 
 class PluginJarOptions(BaseModel):
     """
     The --plugin-jar/-j and --plugin-jars/-J options.
     """
-    plugin_jar: Optional[List[FilePath]] = Field([], aliases=['-j'], description='(plugin JARs) add one or more plugin JARs to the set of plugin JARs to process')
-    plugin_jars: Optional[List[FilePath]] = Field([], aliases=['-J'], description='(plugin JARs) add the plugin JARs listed in one or more files to the set of plugin JARs to process')
+    plugin_jar: Optional[list[FilePath]] = Field(aliases=['-j'], description='(plugin JARs) add one or more plugin JARs to the set of plugin JARs to process')
+    plugin_jars: Optional[list[FilePath]] = Field(aliases=['-J'], description='(plugin JARs) add the plugin JARs listed in one or more files to the set of plugin JARs to process')
 
     @validator('plugin_jar', 'plugin_jars', each_item=True, pre=True)
-    def _expand_each_plugin_jars_path(cls, v: Path):
+    def _expand_each_plugin_jars_path(cls, v: Path) -> Path:
         return path(v)
 
     def get_plugin_jars(self):
-        ret = [*self.plugin_jar[:], *[file_lines(file_path) for file_path in self.plugin_jars]]
-        if len(ret) == 0:
-            raise RuntimeError('empty list of plugin JARs')
-        return ret
+        ret = [*(self.plugin_jar or []), *[file_lines(file_path) for file_path in self.plugin_jars or []]]
+        if len(ret):
+            return ret
+        raise ValueError('Empty list of plugin JARs')
 
 
 class NonInteractiveOptions(BaseModel):
@@ -208,10 +239,12 @@ class TurtlesCli(BaseCli[TurtlesCommand]):
         return self._build_plugin(build_plugin_command)
 
     def _build_plugin(self, build_plugin_command: BuildPluginCommand) -> None:
-        # Prerequisites
-        self._app.load_plugin_sets(build_plugin_command.plugin_set_catalog)
-        self._app.load_plugin_signing_credentials(build_plugin_command.plugin_signing_credentials)
-        self._obtain_password(build_plugin_command)
+        for psc in build_plugin_command.get_plugin_set_catalogs():
+            self._app.load_plugin_set_catalogs(psc)
+        for ps in build_plugin_command.get_plugin_sets():
+            self._app.load_plugin_sets(ps)
+        self._app.load_plugin_signing_credentials(build_plugin_command.get_plugin_signing_credentials())
+        self._obtain_password(build_plugin_command, non_interactive=build_plugin_command.non_interactive)
         # Action
         # ... plugin_id -> (set_id, jar_path, plugin)
         ret = self._app.build_plugin(build_plugin_command.get_plugin_identifiers())
@@ -224,8 +257,10 @@ class TurtlesCli(BaseCli[TurtlesCommand]):
         self._do_string_command(string_command)
 
     def _deploy_plugin(self, deploy_plugin_command: DeployPluginCommand) -> None:
-        # Prerequisites
-        self._app.load_plugin_registries(deploy_plugin_command.plugin_registry_catalog)
+        for prc in deploy_plugin_command.get_plugin_registry_catalogs():
+            self._app.load_plugin_registry_catalogs(prc)
+        for pr in deploy_plugin_command.get_plugin_registries():
+            self._app.load_plugin_registries(pr)
         # Action
         # ... (src_path, plugin_id) -> list of (registry_id, layer_id, dst_path, plugin)
         ret = self._app.deploy_plugin(deploy_plugin_command.get_plugin_jars(),
@@ -245,21 +280,26 @@ class TurtlesCli(BaseCli[TurtlesCommand]):
     def _license(self, string_command: StringCommand) -> None:
         self._do_string_command(string_command)
 
-    def _obtain_password(self, non_interactive_options: NonInteractiveOptions) -> None:
-        if non_interactive_options.plugin_signing_password is not None:
-            _p = non_interactive_options.plugin_signing_password
-        elif non_interactive_options.non_interactive:
+    def _obtain_password(self, plugin_building_options: PluginBuildingOptions, non_interactive: bool=False) -> None:
+        if plugin_building_options.plugin_signing_password:
+            _p = plugin_building_options.plugin_signing_password
+        elif not non_interactive:
             _p = getpass('Plugin signing password: ')
         else:
             self._parser.error('no plugin signing password specified while in non-interactive mode')
         self._app.set_password(lambda: _p)
 
     def _release_plugin(self, release_plugin_command: ReleasePluginCommand) -> None:
-        # Prerequisites
-        self._app.load_plugin_sets(release_plugin_command.plugin_set_catalog)
-        self._app.load_plugin_registries(release_plugin_command.plugin_registry_catalog)
-        self._app.load_plugin_signing_credentials(release_plugin_command.plugin_signing_credentials)
-        self._obtain_password(release_plugin_command)
+        for psc in release_plugin_command.get_plugin_set_catalogs():
+            self._app.load_plugin_set_catalogs(psc)
+        for ps in release_plugin_command.get_plugin_sets():
+            self._app.load_plugin_sets(ps)
+        for prc in release_plugin_command.get_plugin_registry_catalogs():
+            self._app.load_plugin_registry_catalogs(prc)
+        for pr in release_plugin_command.get_plugin_registries():
+            self._app.load_plugin_registries(pr)
+        self._app.load_plugin_signing_credentials(release_plugin_command.get_plugin_signing_credentials())
+        self._obtain_password(release_plugin_command, non_interactive=release_plugin_command.non_interactive)
         # Action
         # ... plugin_id -> list of (registry_id, layer_id, dst_path, plugin)
         ret = self._app.release_plugin(release_plugin_command.get_plugin_identifiers(),

lockss/turtles/plugin.py

@@ -37,14 +37,19 @@ Library to represent a LOCKSS plugin.
 from __future__ import annotations
 
 from collections.abc import Callable
-from pathlib import Path, PurePath
-from typing import Any, List, Optional, Union
+from pathlib import Path
+from typing import Any, Optional
 import xml.etree.ElementTree as ET
 from zipfile import ZipFile
 
-import java_manifest as JM
+import java_manifest
 from lockss.pybasic.fileutil import path
 
+from .util import PathOrStr
+
+
+PluginIdentifier = str
+
 
 class Plugin(object):
 
@@ -56,7 +61,7 @@ class Plugin(object):
         if tag != 'map':
             raise RuntimeError(f'{plugin_path!s}: invalid root element: {tag}')
 
-    def get_aux_packages(self) -> List[str]:
+    def get_aux_packages(self) -> list[str]:
         key = 'plugin_aux_packages'
         lst = [x[1] for x in self._parsed.findall('entry') if x[0].tag == 'string' and x[0].text == key]
         if lst is None or len(lst) < 1:
@@ -65,13 +70,13 @@ class Plugin(object):
             raise ValueError(f'plugin declares {len(lst)} entries for {key}')
         return [x.text for x in lst[0].findall('string')]
 
-    def get_identifier(self) -> Optional[str]:
+    def get_identifier(self) -> Optional[PluginIdentifier]:
         return self._only_one('plugin_identifier')
 
     def get_name(self) -> Optional[str]:
         return self._only_one('plugin_name')
 
-    def get_parent_identifier(self) -> Optional[str]:
+    def get_parent_identifier(self) -> Optional[PluginIdentifier]:
         return self._only_one('plugin_parent')
 
     def get_parent_version(self) -> Optional[int]:
@@ -89,7 +94,7 @@ class Plugin(object):
         return result(lst[0])
 
     @staticmethod
-    def from_jar(jar_path: Union[PurePath, str]) -> Plugin:
+    def from_jar(jar_path: PathOrStr) -> Plugin:
         jar_path = path(jar_path)  # in case it's a string
         plugin_id = Plugin.id_from_jar(jar_path)
         plugin_fstr = str(Plugin.id_to_file(plugin_id))
@@ -98,19 +103,19 @@ class Plugin(object):
                 return Plugin(plugin_file, plugin_fstr)
 
     @staticmethod
-    def from_path(fpath: Union[PurePath, str]) -> Plugin:
+    def from_path(fpath: PathOrStr) -> Plugin:
         fpath = path(fpath)  # in case it's a string
         with open(fpath, 'r') as input_file:
             return Plugin(input_file, fpath)
 
     @staticmethod
-    def file_to_id(plugin_fstr: str) -> str:
+    def file_to_id(plugin_fstr: str) -> PluginIdentifier:
         return plugin_fstr.replace('/', '.')[:-4]  # 4 is len('.xml')
 
     @staticmethod
-    def id_from_jar(jar_path: Union[PurePath, str]) -> str:
+    def id_from_jar(jar_path: PathOrStr) -> PluginIdentifier:
         jar_path = path(jar_path)  # in case it's a string
-        manifest = JM.from_jar(jar_path)
+        manifest = java_manifest.from_jar(jar_path)
         for entry in manifest:
             if entry.get('Lockss-Plugin') == 'true':
                 name = entry.get('Name')
@@ -121,9 +126,9 @@ class Plugin(object):
             raise Exception(f'{jar_path!s}: no Lockss-Plugin entry in META-INF/MANIFEST.MF')
 
     @staticmethod
-    def id_to_dir(plugin_id: str) -> Path:
+    def id_to_dir(plugin_id: PluginIdentifier) -> Path:
         return Plugin.id_to_file(plugin_id).parent
 
     @staticmethod
-    def id_to_file(plugin_id: str) -> Path:
+    def id_to_file(plugin_id: PluginIdentifier) -> Path:
         return Path(f'{plugin_id.replace(".", "/")}.xml')