tracdap-runtime 0.6.1.dev3__py3-none-any.whl → 0.6.3__py3-none-any.whl

tracdap/rt/_impl/grpc/tracdap/metadata/type_pb2.pyi

@@ -0,0 +1,101 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class BasicType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    BASIC_TYPE_NOT_SET: _ClassVar[BasicType]
+    BOOLEAN: _ClassVar[BasicType]
+    INTEGER: _ClassVar[BasicType]
+    FLOAT: _ClassVar[BasicType]
+    STRING: _ClassVar[BasicType]
+    DECIMAL: _ClassVar[BasicType]
+    DATE: _ClassVar[BasicType]
+    DATETIME: _ClassVar[BasicType]
+    ARRAY: _ClassVar[BasicType]
+    MAP: _ClassVar[BasicType]
+BASIC_TYPE_NOT_SET: BasicType
+BOOLEAN: BasicType
+INTEGER: BasicType
+FLOAT: BasicType
+STRING: BasicType
+DECIMAL: BasicType
+DATE: BasicType
+DATETIME: BasicType
+ARRAY: BasicType
+MAP: BasicType
+
+class TypeDescriptor(_message.Message):
+    __slots__ = ("basicType", "arrayType", "mapType")
+    BASICTYPE_FIELD_NUMBER: _ClassVar[int]
+    ARRAYTYPE_FIELD_NUMBER: _ClassVar[int]
+    MAPTYPE_FIELD_NUMBER: _ClassVar[int]
+    basicType: BasicType
+    arrayType: TypeDescriptor
+    mapType: TypeDescriptor
+    def __init__(self, basicType: _Optional[_Union[BasicType, str]] = ..., arrayType: _Optional[_Union[TypeDescriptor, _Mapping]] = ..., mapType: _Optional[_Union[TypeDescriptor, _Mapping]] = ...) -> None: ...
+
+class DecimalValue(_message.Message):
+    __slots__ = ("decimal",)
+    DECIMAL_FIELD_NUMBER: _ClassVar[int]
+    decimal: str
+    def __init__(self, decimal: _Optional[str] = ...) -> None: ...
+
+class DateValue(_message.Message):
+    __slots__ = ("isoDate",)
+    ISODATE_FIELD_NUMBER: _ClassVar[int]
+    isoDate: str
+    def __init__(self, isoDate: _Optional[str] = ...) -> None: ...
+
+class DatetimeValue(_message.Message):
+    __slots__ = ("isoDatetime",)
+    ISODATETIME_FIELD_NUMBER: _ClassVar[int]
+    isoDatetime: str
+    def __init__(self, isoDatetime: _Optional[str] = ...) -> None: ...
+
+class Value(_message.Message):
+    __slots__ = ("type", "booleanValue", "integerValue", "floatValue", "stringValue", "decimalValue", "dateValue", "datetimeValue", "arrayValue", "mapValue")
+    TYPE_FIELD_NUMBER: _ClassVar[int]
+    BOOLEANVALUE_FIELD_NUMBER: _ClassVar[int]
+    INTEGERVALUE_FIELD_NUMBER: _ClassVar[int]
+    FLOATVALUE_FIELD_NUMBER: _ClassVar[int]
+    STRINGVALUE_FIELD_NUMBER: _ClassVar[int]
+    DECIMALVALUE_FIELD_NUMBER: _ClassVar[int]
+    DATEVALUE_FIELD_NUMBER: _ClassVar[int]
+    DATETIMEVALUE_FIELD_NUMBER: _ClassVar[int]
+    ARRAYVALUE_FIELD_NUMBER: _ClassVar[int]
+    MAPVALUE_FIELD_NUMBER: _ClassVar[int]
+    type: TypeDescriptor
+    booleanValue: bool
+    integerValue: int
+    floatValue: float
+    stringValue: str
+    decimalValue: DecimalValue
+    dateValue: DateValue
+    datetimeValue: DatetimeValue
+    arrayValue: ArrayValue
+    mapValue: MapValue
+    def __init__(self, type: _Optional[_Union[TypeDescriptor, _Mapping]] = ..., booleanValue: bool = ..., integerValue: _Optional[int] = ..., floatValue: _Optional[float] = ..., stringValue: _Optional[str] = ..., decimalValue: _Optional[_Union[DecimalValue, _Mapping]] = ..., dateValue: _Optional[_Union[DateValue, _Mapping]] = ..., datetimeValue: _Optional[_Union[DatetimeValue, _Mapping]] = ..., arrayValue: _Optional[_Union[ArrayValue, _Mapping]] = ..., mapValue: _Optional[_Union[MapValue, _Mapping]] = ...) -> None: ...
+
+class ArrayValue(_message.Message):
+    __slots__ = ("items",)
+    ITEMS_FIELD_NUMBER: _ClassVar[int]
+    items: _containers.RepeatedCompositeFieldContainer[Value]
+    def __init__(self, items: _Optional[_Iterable[_Union[Value, _Mapping]]] = ...) -> None: ...
+
+class MapValue(_message.Message):
+    __slots__ = ("entries",)
+    class EntriesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+    ENTRIES_FIELD_NUMBER: _ClassVar[int]
+    entries: _containers.MessageMap[str, Value]
+    def __init__(self, entries: _Optional[_Mapping[str, Value]] = ...) -> None: ...

tracdap/rt/_impl/guard_rails.py

@@ -46,6 +46,27 @@ def _get_package_path(module_name):
     return module_path.parents[depth]
 
 
+def run_model_guard(operation: str = None):
+
+    # A simple guard method to block model code from accessing parts of the TRAC runtime framework
+    # To blocks calls to the Python stdlib or 3rd party libs, use PythonGuardRails instead
+
+    stack = inspect.stack()
+    frame = stack[-1]
+
+    if operation is None:
+        operation = f"Calling {frame.function}()"
+
+    for frame_index in range(len(stack) - 2, 0, -1):
+
+        parent_frame = frame
+        frame = stack[frame_index]
+
+        if frame.function == "run_model" and parent_frame.function == "_execute":
+            err = f"{operation} is not allowed inside run_model()"
+            raise ex.ERuntimeValidation(err)
+
+
 class PythonGuardRails:
 
     DANGEROUS_BUILTIN_FUNCTIONS = ["exec", "eval", "compile", "open", "input", "memoryview"]
@@ -258,14 +279,13 @@ class PythonGuardRails:
     @classmethod
     def is_debug(cls):
 
-        get_trace_func = getattr(sys, 'gettrace', None)
+        has_trace = hasattr(sys, 'gettrace') and sys.gettrace() is not None
+        has_breakpoint = sys.breakpointhook.__module__ != "sys"
 
-        if get_trace_func is None:
-            return False
+        if has_trace or has_breakpoint:
+            return True
 
-        else:
-            trace = get_trace_func()
-            return trace is not None
+        return False
 
     @classmethod
     def is_import(cls):

tracdap/rt/_impl/models.py

@@ -215,12 +215,15 @@ class ModelLoader:
 
             for name, param in model_def.parameters.items():
                 self.__log.info(f"Parameter [{name}] - {param.paramType.basicType.name}")
+                param.paramProps = self._encoded_props(param.paramProps, "parameter", name)
 
             for name, schema in model_def.inputs.items():
                 self.__log.info(f"Input [{name}] - {schema.schema.schemaType.name}")
+                schema.inputProps = self._encoded_props(schema.inputProps, "input", name)
 
             for name, schema in model_def.outputs.items():
                 self.__log.info(f"Output [{name}] - {schema.schema.schemaType.name}")
+                schema.outputProps = self._encoded_props(schema.outputProps, "input", name)
 
             return model_def
 
@@ -231,3 +234,25 @@ class ModelLoader:
 
             self.__log.error(msg, exc_info=True)
             raise _ex.EModelValidation(msg) from e
+
+    @staticmethod
+    def _encoded_props(
+            raw_props: tp.Dict[str, tp.Any],
+            item_type: str, item_name: str) \
+            -> tp.Dict[str, _meta.Value]:
+
+        if raw_props is None:
+            return dict()
+
+        encoded_props = dict()
+
+        for key, raw_value in raw_props.items():
+
+            if raw_value is None:
+                raise _ex.EModelValidation(f"Invalid null property [{key}] for {item_type} [{item_name}]")
+            elif isinstance(raw_value, _meta.Value):
+                encoded_props[key] = raw_value
+            else:
+                encoded_props[key] = _types.MetadataCodec.encode_value(raw_value)
+
+        return encoded_props

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]]]) \
@@ -147,22 +153,34 @@ class StaticApiImpl(_StaticApiHook):
         return _schemas.SchemaLoader.load_schema(package, schema_file)
 
     def define_input_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]], label: _tp.Optional[str] = None) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            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)
+        _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)
+        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) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            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)
+        _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)
+        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.1.dev3"
+__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
@@ -119,14 +120,20 @@ class _StaticApiHook:
 
     @_abc.abstractmethod
     def define_input_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]], label: _tp.Optional[str] = None) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            optional: bool = False,
+            input_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelInputSchema:
 
         pass
 
     @_abc.abstractmethod
     def define_output_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]], label: _tp.Optional[str] = None) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            optional: bool = False,
+            output_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelOutputSchema:
 
         pass

tracdap/rt/api/model_api.py

@@ -72,6 +72,28 @@ class TracContext:
 
         pass
 
+    @_abc.abstractmethod
+    def has_dataset(self, dataset_name: str) -> bool:
+
+        """
+        Check whether a dataset is available in the current context
+
+        This method can be used to check whether optional model inputs have been supplied or not.
+        Models should use this method before calling get methods on optional inputs.
+        For inputs not marked as optional, this method will always return true. For outputs,
+        this method will return true after the model calls a put method for the dataset.
+
+        A runtime validation error will be raised if the dataset name is not defined
+        as a model input or output.
+
+        :param dataset_name: The name of the dataset to check
+        :return: True if the dataset exists in the current context, False otherwise
+        :rtype: bool
+        :raises: :py:class:`ERuntimeValidation <tracdap.rt.exceptions.ERuntimeValidation>`
+        """
+
+        pass
+
     @_abc.abstractmethod
     def get_schema(self, dataset_name: str) -> SchemaDefinition: