tracdap-runtime 0.6.2__py3-none-any.whl → 0.6.3__py3-none-any.whl

tracdap/rt/_impl/static_api.py

@@ -71,10 +71,14 @@ class StaticApiImpl(_StaticApiHook):
 
     def define_parameter(
             self, param_name: str, param_type: _tp.Union[_meta.TypeDescriptor, _meta.BasicType],
-            label: str, default_value: _tp.Optional[_tp.Any] = None) \
+            label: str, default_value: _tp.Optional[_tp.Any] = None,
+            *, param_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _Named[_meta.ModelParameter]:
 
-        _val.validate_signature(self.define_parameter, param_name, param_type, label, default_value)
+        _val.validate_signature(
+            self.define_parameter,
+            param_name, param_type, label, default_value,
+            param_props=param_props)
 
         if isinstance(param_type, _meta.TypeDescriptor):
             param_type_descriptor = param_type
@@ -88,7 +92,9 @@ class StaticApiImpl(_StaticApiHook):
                 msg = f"Default value for parameter [{param_name}] does not match the declared type"
                 raise _ex.EModelValidation(msg) from e
 
-        return _Named(param_name, _meta.ModelParameter(param_type_descriptor, label, default_value))
+        return _Named(param_name, _meta.ModelParameter(
+            param_type_descriptor, label, default_value,
+            paramProps=param_props))
 
     def define_parameters(
             self, *params: _tp.Union[_Named[_meta.ModelParameter], _tp.List[_Named[_meta.ModelParameter]]]) \
@@ -149,24 +155,32 @@ class StaticApiImpl(_StaticApiHook):
     def define_input_table(
             self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
             label: _tp.Optional[str] = None,
-            optional: bool = False) \
+            optional: bool = False,
+            input_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelInputSchema:
 
-        _val.validate_signature(self.define_input_table, *fields, label=label, optional=optional)
+        _val.validate_signature(
+            self.define_input_table, *fields,
+            label=label, optional=optional,
+            input_props=input_props)
 
         schema_def = self.define_schema(*fields, schema_type=_meta.SchemaType.TABLE)
-        return _meta.ModelInputSchema(schema=schema_def, label=label, optional=optional)
+        return _meta.ModelInputSchema(schema=schema_def, label=label, optional=optional, inputProps=input_props)
 
     def define_output_table(
             self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
             label: _tp.Optional[str] = None,
-            optional: bool = False) \
+            optional: bool = False,
+            output_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelOutputSchema:
 
-        _val.validate_signature(self.define_output_table, *fields, label=label, optional=optional)
+        _val.validate_signature(
+            self.define_output_table, *fields,
+            label=label, optional=optional,
+            output_props=output_props)
 
         schema_def = self.define_schema(*fields, schema_type=_meta.SchemaType.TABLE)
-        return _meta.ModelOutputSchema(schema=schema_def, label=label, optional=optional)
+        return _meta.ModelOutputSchema(schema=schema_def, label=label, optional=optional, outputProps=output_props)
 
     @staticmethod
     def _build_named_dict(

tracdap/rt/_impl/type_system.py

@@ -171,6 +171,23 @@ class MetadataCodec:
             type_desc = _meta.TypeDescriptor(_meta.BasicType.DATE)
             return _meta.Value(type_desc, dateValue=_meta.DateValue(value.isoformat()))
 
+        if isinstance(value, list):
+
+            if len(value) == 0:
+                raise _ex.ETracInternal("Cannot encode an empty list")
+
+            array_raw_type = type(value[0])
+            array_trac_type = TypeMapping.python_to_trac(array_raw_type)
+
+            if any(map(lambda x: type(x) != array_raw_type, value)):
+                raise _ex.ETracInternal("Cannot encode a list with values of different types")
+
+            encoded_items = list(map(lambda x: cls.convert_value(x, array_trac_type), value))
+
+            return _meta.Value(
+                _meta.TypeDescriptor(_meta.BasicType.ARRAY, arrayType=array_trac_type),
+                arrayValue=_meta.ArrayValue(encoded_items))
+
         raise _ex.ETracInternal(f"Value type [{type(value)}] is not supported yet")
 
     @classmethod

tracdap/rt/_impl/validation.py

@@ -320,6 +320,9 @@ class _StaticValidator:
             else:
                 cls._check_label(param.label, param_name)
 
+            if param.paramProps is not None:
+                cls._valid_identifiers(param.paramProps.keys(), "entry in param props")
+
     @classmethod
     def _check_inputs_or_outputs(cls, inputs_or_outputs):
 
@@ -340,6 +343,13 @@ class _StaticValidator:
             label = input_schema.label
             cls._check_label(label, input_name)
 
+            if isinstance(input_schema, meta.ModelInputSchema):
+                if input_schema.inputProps is not None:
+                    cls._valid_identifiers(input_schema.inputProps.keys(), "entry in input props")
+            else:
+                if input_schema.outputProps is not None:
+                    cls._valid_identifiers(input_schema.outputProps.keys(), "entry in output props")
+
     @classmethod
     def _check_single_field(cls, field: meta.FieldSchema, property_type):
 

tracdap/rt/_plugins/config_local.py

@@ -0,0 +1,49 @@
+#  Copyright 2024 Accenture Global Solutions Limited
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import pathlib as pathlib
+import typing as tp
+
+import tracdap.rt.ext.plugins as plugins
+import tracdap.rt.exceptions as ex
+
+from tracdap.rt.ext.config import *
+
+
+class LocalConfigLoader(IConfigLoader):
+
+    # Properties dict will be empty for config plugins
+    def __init__(self, properties: tp.Dict[str, str]):  # noqa
+        pass
+
+    def has_config_file(self, config_url: str) -> bool:
+        if config_url.startswith("file:"):
+            config_url = config_url[5:]
+        config_path = pathlib.Path(config_url).resolve()
+        return config_path.exists() and config_path.is_file()
+
+    def load_config_file(self, config_url: str) -> bytes:
+        if config_url.startswith("file:"):
+            config_url = config_url[5:]
+        config_path = pathlib.Path(config_url).resolve()
+        return config_path.read_bytes()
+
+    def has_config_dict(self, config_url: str) -> bool:
+        return False
+
+    def load_config_dict(self, config_url: str) -> dict:
+        raise ex.ETracInternal("Local config loader does not support loading objects")
+
+
+plugins.PluginManager.register_plugin(IConfigLoader, LocalConfigLoader, ["LOCAL", "file"])

tracdap/rt/_version.py

@@ -12,4 +12,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-__version__ = "0.6.2"
+__version__ = "0.6.3"

tracdap/rt/api/hook.py

@@ -80,7 +80,8 @@ class _StaticApiHook:
     @_abc.abstractmethod
     def define_parameter(
             self, param_name: str, param_type: _tp.Union[_meta.TypeDescriptor, _meta.BasicType],
-            label: str, default_value: _tp.Optional[_tp.Any] = None) \
+            label: str, default_value: _tp.Optional[_tp.Any] = None,
+            *, param_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _Named[_meta.ModelParameter]:
 
         pass
@@ -121,7 +122,8 @@ class _StaticApiHook:
     def define_input_table(
             self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
             label: _tp.Optional[str] = None,
-            optional: bool = False) \
+            optional: bool = False,
+            input_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelInputSchema:
 
         pass
@@ -130,7 +132,8 @@ class _StaticApiHook:
     def define_output_table(
             self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
             label: _tp.Optional[str] = None,
-            optional: bool = False) \
+            optional: bool = False,
+            output_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelOutputSchema:
 
         pass

tracdap/rt/api/static_api.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+import sys
 import typing as _tp
 import types as _ts
 
@@ -111,7 +112,8 @@ def A(  # noqa
 
 def define_parameter(
         param_name: str, param_type: _tp.Union[TypeDescriptor, BasicType],
-        label: str, default_value: _tp.Optional[_tp.Any] = None) \
+        label: str, default_value: _tp.Optional[_tp.Any] = None,
+        *, param_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
         -> _Named[ModelParameter]:
 
     """
@@ -128,6 +130,10 @@ def define_parameter(
     the model. TRAC will apply type coercion where possible to ensure the default value matches the parameter type,
     if the default value cannot be coerced to match the parameter type then model validation will fail.
 
+    You can use param_props to associate arbitrary key-value properties with this model parameter.
+    These properties are not used by the TRAC engine, but are stored in the model metadata for
+    the parameter and can be used as needed in 3rd-party applications.
+
     Once defined model parameters can be passed to :py:func:`define_parameters`,
     either as a list or as individual arguments, to create the set of parameters for a model.
 
@@ -135,6 +141,7 @@ def define_parameter(
     :param param_type: The parameter type, expressed in the TRAC type system
     :param label: A descriptive label for the parameter (required)
     :param default_value: A default value to use if no explicit value is supplied (optional)
+    :param param_props: Associate key-value properties with this parameter (not used by the TRAC engine)
     :return: A named model parameter, suitable for passing to :py:func:`define_parameters`
 
     :type param_name: str
@@ -142,11 +149,12 @@ def define_parameter(
                       :py:class:`BasicType <tracdap.rt.metadata.BasicType>`
     :type label: str
     :type default_value: Optional[Any]
+    :type param_props: Optional[Dict[str, Any]]
     :rtype: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
     """
 
     sa = _StaticApiHook.get_instance()
-    return sa.define_parameter(param_name, param_type, label, default_value)
+    return sa.define_parameter(param_name, param_type, label, default_value, param_props=param_props)
 
 
 def declare_parameter(
@@ -160,6 +168,9 @@ def declare_parameter(
     .. deprecated:: 0.4.4
        Use :py:func:`define_parameter` or :py:func:`P` instead.
 
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_parameter() <tracdap.rt.api.define_parameter>` instead.
+
     :type param_name: str
     :type param_type: :py:class:`TypeDescriptor <tracdap.rt.metadata.TypeDescriptor>` |
                       :py:class:`BasicType <tracdap.rt.metadata.BasicType>`
@@ -168,6 +179,8 @@ def declare_parameter(
     :rtype: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
     """
 
+    print("TRAC Warning: declare_parameter() is deprecated, please use define_parameter()", file=sys.stderr)
+
     return define_parameter(param_name, param_type, label, default_value)
 
 
@@ -175,7 +188,8 @@ def P(  # noqa
         param_name: str,
         param_type: _tp.Union[TypeDescriptor, BasicType],
         label: str,
-        default_value: _tp.Optional[_tp.Any] = None) \
+        default_value: _tp.Optional[_tp.Any] = None,
+        *, param_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
         -> _Named[ModelParameter]:
 
     """
@@ -186,12 +200,11 @@ def P(  # noqa
                       :py:class:`BasicType <tracdap.rt.metadata.BasicType>`
     :type label: str
     :type default_value: Optional[Any]
+    :type param_props: Optional[Dict[str, Any]]
     :rtype: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
     """
 
-    return declare_parameter(
-        param_name, param_type, label,
-        default_value)
+    return define_parameter(param_name, param_type, label, default_value, param_props=param_props)
 
 
 def define_parameters(
@@ -226,11 +239,16 @@ def declare_parameters(
     .. deprecated:: 0.4.4
        Use :py:func:`define_parameters` instead.
 
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_parameters() <tracdap.rt.api.define_parameters>` instead.
+
     :type params: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`] |
                   List[_Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]]
     :rtype: Dict[str, :py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
     """
 
+    print("TRAC Warning: declare_parameters() is deprecated, please use define_parameters()", file=sys.stderr)
+
     return define_parameters(*params)
 
 
@@ -278,9 +296,9 @@ def define_field(
     :type label: str
     :type business_key: bool
     :type categorical: bool
-    :type not_null: _tp.Optional[bool]
-    :type format_code: _tp.Optional[str]
-    :type field_order: _tp.Optional[int]
+    :type not_null: Optional[bool]
+    :type format_code: Optional[str]
+    :type field_order: Optional[int]
     :rtype: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`
     """
 
@@ -307,17 +325,22 @@ def declare_field(
     .. deprecated:: 0.4.4
        Use :py:func:`define_field` or :py:func:`F` instead.
 
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_field() <tracdap.rt.api.define_field>` instead.
+
     :type field_name: str
     :type field_type: :py:class:`BasicType <tracdap.rt.metadata.BasicType>`
     :type label: str
     :type business_key: bool
     :type categorical: bool
-    :type not_null: _tp.Optional[bool]
-    :type format_code: _tp.Optional[str]
-    :type field_order: _tp.Optional[int]
+    :type not_null: Optional[bool]
+    :type format_code: Optional[str]
+    :type field_order: Optional[int]
     :rtype: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`
     """
 
+    print("TRAC Warning: declare_field() is deprecated, please use define_field()", file=sys.stderr)
+
     return define_field(
         field_name, field_type, label,
         business_key, categorical, not_null,
@@ -343,9 +366,9 @@ def F(  # noqa
     :type label: str
     :type business_key: bool
     :type categorical: bool
-    :type not_null: _tp.Optional[bool]
-    :type format_code: _tp.Optional[str]
-    :type field_order: _tp.Optional[int]
+    :type not_null: Optional[bool]
+    :type format_code: Optional[str]
+    :type field_order: Optional[int]
     :rtype: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`
     """
 
@@ -429,7 +452,8 @@ def load_schema(
 def define_input_table(
         *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]],
         label: _tp.Optional[str] = None,
-        optional: bool = False) \
+        optional: bool = False,
+        input_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
         -> ModelInputSchema:
 
     """
@@ -438,20 +462,26 @@ def define_input_table(
     Fields can be supplied either as individual arguments to this function or as a list.
     Individual fields should be defined using :py:func:`define_field` or the shorthand alias :py:func:`F`.
 
+    You can use input_props to associate arbitrary key-value properties with this model input.
+    These properties are not used by the TRAC engine, but are stored in the model metadata for
+    the input and can be used as needed in 3rd-party applications.
+
     :param fields: A set of fields to make up a :py:class:`TableSchema <tracdap.rt.metadata.TableSchema>`
     :param label: An optional label (of type str) for a model input schema. Default value: None.
     :param optional: Mark this input as an optional model input
+    :param input_props: Associate key-value properties with this input (not used by the TRAC engine)
     :return: A model input schema, suitable for returning from :py:meth:`TracModel.define_inputs`
 
     :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
                   List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
-    :type label: _tp.Optional[str]
+    :type label: Optional[str]
     :type optional: bool
+    :type input_props: Optional[Dict[str, Any]]
     :rtype: :py:class:`ModelInputSchema <tracdap.rt.metadata.ModelInputSchema>`
     """
 
     sa = _StaticApiHook.get_instance()
-    return sa.define_input_table(*fields, label=label, optional=optional)
+    return sa.define_input_table(*fields, label=label, optional=optional, input_props=input_props)
 
 
 def declare_input_table(
@@ -462,18 +492,24 @@ def declare_input_table(
     .. deprecated:: 0.4.4
        Use :py:func:`define_input_table` instead.
 
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_input_table() <tracdap.rt.api.define_input_table>` instead.
+
     :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
                   List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
     :rtype: :py:class:`ModelInputSchema <tracdap.rt.metadata.ModelInputSchema>`
     """
 
+    print("TRAC Warning: declare_input_table() is deprecated, please use define_input_table()", file=sys.stderr)
+
     return define_input_table(*fields)
 
 
 def define_output_table(
         *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]],
         label: _tp.Optional[str] = None,
-        optional: bool = False) \
+        optional: bool = False,
+        output_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
         -> ModelOutputSchema:
 
     """
@@ -482,20 +518,26 @@ def define_output_table(
     Fields can be supplied either as individual arguments to this function or as a list.
     Individual fields should be defined using :py:func:`define_field` or the shorthand alias :py:func:`F`.
 
+    You can use output_props to associate arbitrary key-value properties with this model output.
+    These properties are not used by the TRAC engine, but are stored in the model metadata for
+    the output and can be used as needed in 3rd-party applications.
+
     :param fields: A set of fields to make up a :py:class:`TableSchema <tracdap.rt.metadata.TableSchema>`
     :param label: An optional label (of type str) for a model output schema. Default value: None.
     :param optional: Mark this output as an optional model output
+    :param output_props: Associate key-value properties with this output (not used by the TRAC engine)
     :return: A model output schema, suitable for returning from :py:meth:`TracModel.define_outputs`
 
     :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
                   List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
-    :type label: _tp.Optional[str]
+    :type label: Optional[str]
     :type optional: bool
+    :type output_props: Optional[Dict[str, Any]]
     :rtype: :py:class:`ModelOutputSchema <tracdap.rt.metadata.ModelOutputSchema>`
     """
 
     sa = _StaticApiHook.get_instance()
-    return sa.define_output_table(*fields, label=label, optional=optional)
+    return sa.define_output_table(*fields, label=label, optional=optional, output_props=output_props)
 
 
 def declare_output_table(
@@ -506,9 +548,17 @@ def declare_output_table(
     .. deprecated:: 0.4.4
        Use :py:func:`define_output_table` instead.
 
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_output_table() <tracdap.rt.api.define_output_table>` instead.
+
+    This function is deprecated and will be removed in a future version.
+    Please use define_output_table() instead.
+
     :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
                   List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
     :rtype: :py:class:`ModelOutputSchema <tracdap.rt.metadata.ModelOutputSchema>`
     """
 
+    print("TRAC Warning: declare_output_table() is deprecated, please use define_output_table()", file==sys.stderr)
+
     return define_output_table(*fields)

tracdap/rt/config/__init__.py

@@ -5,13 +5,11 @@ from .common import PluginConfig
 from .common import PlatformInfo
 from .common import AuthenticationConfig
 from .common import StorageConfig
+from .common import ServiceConfig
 
 from .runtime import RuntimeConfig
 from .runtime import SparkSettings
 
-from .result import TagUpdateList
-from .result import JobResult
-
 from .platform import RoutingProtocol
 from .platform import DeploymentLayout
 from .platform import PlatformConfig
@@ -24,7 +22,9 @@ from .platform import GatewayConfig
 from .platform import RouteConfig
 from .platform import RoutingMatch
 from .platform import RoutingTarget
-from .platform import ServiceConfig
 from .platform import DeploymentConfig
 
 from .job import JobConfig
+
+from .result import TagUpdateList
+from .result import JobResult

tracdap/rt/config/common.py

@@ -66,3 +66,13 @@ class StorageConfig:
     defaultBucket: str = None
 
     defaultFormat: str = None
+
+
+@_dc.dataclass
+class ServiceConfig:
+
+    enabled: _tp.Optional[bool] = None
+
+    alias: str = None
+
+    port: int = None

tracdap/rt/config/platform.py

@@ -153,16 +153,6 @@ class RoutingTarget:
     path: str = None
 
 
-@_dc.dataclass
-class ServiceConfig:
-
-    enabled: _tp.Optional[bool] = None
-
-    alias: str = None
-
-    port: int = None
-
-
 @_dc.dataclass
 class DeploymentConfig:
 

tracdap/rt/config/runtime.py

@@ -20,6 +20,8 @@ class RuntimeConfig:
 
     sparkSettings: SparkSettings = None
 
+    runtimeApi: ServiceConfig = None
+
 
 @_dc.dataclass
 class SparkSettings:

tracdap/rt/ext/config.py

@@ -0,0 +1,34 @@
+#  Copyright 2024 Accenture Global Solutions Limited
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import abc as _abc
+
+
+class IConfigLoader:
+
+    @_abc.abstractmethod
+    def has_config_file(self, config_url: str) -> bool:
+        pass
+
+    @_abc.abstractmethod
+    def load_config_file(self, config_url: str) -> bytes:
+        pass
+
+    @_abc.abstractmethod
+    def has_config_dict(self, config_url: str) -> bool:
+        pass
+
+    @_abc.abstractmethod
+    def load_config_dict(self, config_url: str) -> dict:
+        pass

tracdap/rt/ext/embed.py

@@ -13,9 +13,7 @@
 #  limitations under the License.
 
 import tracdap.rt.config as _cfg
-import tracdap.rt.ext._guard as _guard
-
-# Dependency back into the main runtime implementation
+import tracdap.rt._impl.guard_rails as _guard  # noqa
 import tracdap.rt._exec.runtime as _rt  # noqa
 
 

tracdap/rt/ext/plugins.py

@@ -19,7 +19,8 @@ import importlib as _il
 
 import tracdap.rt.config as _cfg
 import tracdap.rt.exceptions as _ex
-import tracdap.rt.ext._guard as _guard
+import tracdap.rt._impl.guard_rails as _guard  # noqa
+from tracdap.rt.exceptions import EStartup
 
 
 class PluginManager:
@@ -29,6 +30,8 @@ class PluginManager:
     __log = _log.getLogger(f"{__name__}.PluginManager")
 
     __core_registered = False
+    __3rd_party_registered = list()
+
     __plugins = {}
 
     @classmethod
@@ -40,17 +43,42 @@ class PluginManager:
             return
 
         cls.__log.info("Register core plugins...")
+        cls.__register_plugin_package("tracdap.rt._plugins")
+
+        cls.__core_registered = True
+
+    @classmethod
+    def register_plugin_package(cls, plugin_package_name: str):
+
+        _guard.run_model_guard()
 
-        plugins_package = _il.import_module("tracdap.rt._plugins")
+        if plugin_package_name in cls.__3rd_party_registered:
+            return
+
+        if plugin_package_name.startswith("tracdap."):
+            raise EStartup("3rd party plugins cannot be registered from the tracdap namespace")
+
+        cls.__log.info(f"Register plugins from package [{plugin_package_name}]...")
+        cls.__register_plugin_package(plugin_package_name)
+
+        cls.__3rd_party_registered.append(plugin_package_name)
+
+    @classmethod
+    def __register_plugin_package(cls, plugin_package_name: str):
+
+        _guard.run_model_guard()
+
+        plugins_package = _il.import_module(plugin_package_name)
 
         for module in _pkg.iter_modules(plugins_package.__path__):
+
+            module_name = f"{plugin_package_name}.{module.name}"
+
             try:
-                module_name = f"tracdap.rt._plugins.{module.name}"
                 _il.import_module(module_name)
             except ImportError:
-                pass  # Ignore plugins that fail to load
-
-        cls.__core_registered = True
+                # It is not a fatal error if some plugins fail to load
+                cls.__log.warning(f"Failed to load plugins from module [{module_name}]")
 
     @classmethod
     def register_plugin(
@@ -94,3 +122,16 @@ class PluginManager:
         plugin = plugin_class(config.properties)
 
         return plugin
+
+    @classmethod
+    def load_config_plugin(cls,
+            service_type: _tp.Type[T_SERVICE],
+            config: _cfg.PluginConfig) \
+            -> T_SERVICE:
+
+        # Currently config plugins are loaded the same way as regular plugins
+        # However, regular plugins can be modified to take ConfigManager as an init parameter
+        # This is useful for loading secondary config files needed in particularly plugins
+        # Config plugins can never do this, because the config manager is not yet initialized
+
+        return cls.load_plugin(service_type, config)