tracdap-runtime 0.7.0rc1__py3-none-any.whl → 0.8.0__py3-none-any.whl

tracdap/rt/_impl/{type_system.py → core/type_system.py}

@@ -133,9 +133,13 @@ class MetadataCodec:
 
         if basic_type == _meta.BasicType.ARRAY:
             items = value.arrayValue.items
-            return list(map(lambda x: MetadataCodec._decode_value_for_type(x, type_desc.arrayType), items))
+            return list(MetadataCodec._decode_value_for_type(x, type_desc.arrayType) for x in items)
 
-        raise _ex.ETracInternal(f"Decoding value type [{basic_type}] is not supported yet")
+        if basic_type == _meta.BasicType.MAP:
+            items = value.mapValue.entries.items()
+            return dict((k, MetadataCodec._decode_value_for_type(v, type_desc.mapType)) for k, v in items)
+
+        raise _ex.ETracInternal(f"Cannot decode value of type [{basic_type}]")
 
     @classmethod
     def encode_value(cls, value: tp.Any) -> _meta.Value:
@@ -183,19 +187,36 @@ class MetadataCodec:
             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))
+            encoded_items = list(map(lambda x: cls.convert_value(x, array_trac_type, True), 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")
+        if isinstance(value, dict):
+
+            if len(value) == 0:
+                raise _ex.ETracInternal("Cannot encode an empty dict")
+
+            map_raw_type = type(next(iter(value.values())))
+            map_trac_type = TypeMapping.python_to_trac(map_raw_type)
+
+            if any(map(lambda x: type(x) != array_raw_type, value.values())):
+                raise _ex.ETracInternal("Cannot encode a dict with values of different types")
+
+            encoded_entries = dict(map(lambda kv: (kv[0], cls.convert_value(kv[1], map_trac_type, True)), value.items()))
+
+            return _meta.Value(
+                _meta.TypeDescriptor(_meta.BasicType.ARRAY, mapType=map_trac_type),
+                mapValue=_meta.MapValue(encoded_entries))
+
+        raise _ex.ETracInternal(f"Cannot encode value of type [{type(value).__name__}]")
 
     @classmethod
-    def convert_value(cls, raw_value: tp.Any, type_desc: _meta.TypeDescriptor):
+    def convert_value(cls, raw_value: tp.Any, type_desc: _meta.TypeDescriptor, nested: bool = False):
 
         if type_desc.basicType == _meta.BasicType.BOOLEAN:
-            return cls.convert_boolean_value(raw_value)
+            return cls.convert_boolean_value(raw_value, nested)
 
         if type_desc.basicType == _meta.BasicType.INTEGER:
             return cls.convert_integer_value(raw_value)
@@ -218,78 +239,97 @@ class MetadataCodec:
         if type_desc.basicType == _meta.BasicType.ARRAY:
             return cls.convert_array_value(raw_value, type_desc.arrayType)
 
+        if type_desc.basicType == _meta.BasicType.MAP:
+            return cls.convert_map_value(raw_value, type_desc.mapType)
+
         raise _ex.ETracInternal(f"Conversion to value type [{type_desc.basicType.name}] is not supported yet")
 
     @staticmethod
     def convert_array_value(raw_value: tp.List[tp.Any], array_type: _meta.TypeDescriptor) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.ARRAY, array_type)
+        type_desc = _meta.TypeDescriptor(basicType=_meta.BasicType.ARRAY, arrayType=array_type)
 
         if not isinstance(raw_value, list):
-            msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.ARRAY.name}"
+            msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.ARRAY.name}"
             raise _ex.ETracInternal(msg)
 
-        items = list(map(lambda x: MetadataCodec.convert_value(x, array_type), raw_value))
+        items = list(map(lambda x: MetadataCodec.convert_value(x, array_type, True), raw_value))
 
         return _meta.Value(type_desc, arrayValue=_meta.ArrayValue(items))
 
     @staticmethod
-    def convert_boolean_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_map_value(raw_value: tp.Dict[str, tp.Any], map_type: _meta.TypeDescriptor) -> _meta.Value:
+
+        type_desc = _meta.TypeDescriptor(basicType=_meta.BasicType.MAP, mapType=map_type)
+
+        if not isinstance(raw_value, dict):
+            msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.MAP.name}"
+            raise _ex.ETracInternal(msg)
+
+        entries = dict(map(lambda kv: (kv[0], MetadataCodec.convert_value(kv[1], map_type, True)), raw_value.items()))
+
+        return _meta.Value(type_desc, mapValue=_meta.MapValue(entries))
+
+    @staticmethod
+    def convert_boolean_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.BOOLEAN)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.BOOLEAN) if not nested else None
 
         if isinstance(raw_value, bool):
             return _meta.Value(type_desc, booleanValue=raw_value)
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.BOOLEAN.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.BOOLEAN.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_integer_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_integer_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.INTEGER)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.INTEGER) if not nested else None
 
-        if isinstance(raw_value, int):
+        # isinstance(bool_value, int) returns True! An explicit check is needed
+        if isinstance(raw_value, int) and not isinstance(raw_value, bool):
             return _meta.Value(type_desc, integerValue=raw_value)
 
         if isinstance(raw_value, float) and raw_value.is_integer():
             return _meta.Value(type_desc, integerValue=int(raw_value))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.INTEGER.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.INTEGER.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_float_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_float_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.FLOAT)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.FLOAT) if not nested else None
 
         if isinstance(raw_value, float):
             return _meta.Value(type_desc, floatValue=raw_value)
 
-        if isinstance(raw_value, int):
+        # isinstance(bool_value, int) returns True! An explicit check is needed
+        if isinstance(raw_value, int) and not isinstance(raw_value, bool):
             return _meta.Value(type_desc, floatValue=float(raw_value))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.FLOAT.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.FLOAT.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_decimal_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_decimal_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.DECIMAL)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.DECIMAL) if not nested else None
 
         if isinstance(raw_value, decimal.Decimal):
             return _meta.Value(type_desc, decimalValue=_meta.DecimalValue(str(raw_value)))
 
-        if isinstance(raw_value, int) or isinstance(raw_value, float):
+        # isinstance(bool_value, int) returns True! An explicit check is needed
+        if isinstance(raw_value, int) or isinstance(raw_value, float) and not isinstance(raw_value, bool):
             return _meta.Value(type_desc, decimalValue=_meta.DecimalValue(str(raw_value)))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.DECIMAL.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.DECIMAL.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_string_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_string_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.STRING)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.STRING) if not nested else None
 
         if isinstance(raw_value, str):
             return _meta.Value(type_desc, stringValue=raw_value)
@@ -301,13 +341,13 @@ class MetadataCodec:
 
             return _meta.Value(type_desc, stringValue=str(raw_value))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.STRING.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.STRING.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_date_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_date_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATE)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATE) if not nested else None
 
         if isinstance(raw_value, dt.date):
             return _meta.Value(type_desc, dateValue=_meta.DateValue(isoDate=raw_value.isoformat()))
@@ -316,13 +356,13 @@ class MetadataCodec:
             date_value = dt.date.fromisoformat(raw_value)
             return _meta.Value(type_desc, dateValue=_meta.DateValue(isoDate=date_value.isoformat()))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.DATE.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.DATE.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_datetime_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_datetime_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATETIME)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATETIME) if not nested else None
 
         if isinstance(raw_value, dt.datetime):
             return _meta.Value(type_desc, datetimeValue=_meta.DatetimeValue(isoDatetime=raw_value.isoformat()))
@@ -331,5 +371,5 @@ class MetadataCodec:
             datetime_value = dt.datetime.fromisoformat(raw_value)
             return _meta.Value(type_desc, datetimeValue=_meta.DatetimeValue(isoDatetime=datetime_value.isoformat()))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.DATETIME.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.DATETIME.name}"
         raise _ex.ETracInternal(msg)

tracdap/rt/_impl/{util.py → core/util.py}

@@ -14,11 +14,9 @@
 #  limitations under the License.
 
 import datetime as dt
-import logging
 import pathlib
 import platform
 
-import sys
 import typing as tp
 import uuid
 
@@ -38,114 +36,6 @@ def is_windows():
     return __IS_WINDOWS
 
 
-class ColorFormatter(logging.Formatter):
-
-    _BLACK, _RED, _GREEN, _YELLOW, _BLUE, _MAGENTA, _CYAN, _WHITE, _DEFAULT_WHITE = range(9)
-    _DARK_BASE = 30
-    _LIGHT_BASE = 90
-
-    # DARK_BASE + WHITE = light grey
-    # DARK_BASE + DEFAULT_WHITE = regular console white
-    # LIGHT_BASE + WHITE = bright white (0xffffff), very bright!
-
-    def __init__(self, is_bright: bool):
-
-        super().__init__(self._base_fmt(is_bright))
-        self._level_colors = self._make_level_colors(is_bright)
-        self._default_color = self._make_default_color(is_bright)
-
-    def format(self, record):
-
-        level_name = record.levelname
-        level_color = self._level_colors.get(level_name)
-
-        if level_color:
-            record.levelname = level_color
-        else:
-            record.levelname = self._default_color + level_name
-
-        return logging.Formatter.format(self, record)
-
-    def _base_fmt(self, is_bright: bool):
-
-        if is_bright:
-            base_color = self._make_ansi_code(self._DARK_BASE, self._DEFAULT_WHITE, is_bold=False)
-            message_color = self._make_ansi_code(self._LIGHT_BASE, self._CYAN, is_bold=False)
-        else:
-            base_color = self._make_ansi_code(self._DARK_BASE, self._WHITE, is_bold=False)
-            message_color = self._make_ansi_code(self._DARK_BASE, self._CYAN, is_bold=False)
-
-        return f"{base_color}%(asctime)s [%(threadName)s] %(levelname)s{base_color} %(name)s" + \
-               f" - {message_color}%(message)s"
-
-    def _make_level_colors(self, is_bright: bool):
-
-        base_code = self._LIGHT_BASE if is_bright else self._DARK_BASE
-
-        green = self._make_ansi_code(base_code, self._GREEN, is_bold=is_bright)
-        yellow = self._make_ansi_code(base_code, self._YELLOW, is_bold=is_bright)
-        red = self._make_ansi_code(base_code, self._RED, is_bold=is_bright)
-
-        level_colors = {
-            'CRITICAL': f"{red}CRITICAL",
-            'ERROR': f"{red}ERROR",
-            'WARNING': f"{yellow}WARNING",
-            'INFO': f"{green}INFO"
-        }
-
-        return level_colors
-
-    def _make_default_color(self, is_bright: bool):
-
-        base_code = self._LIGHT_BASE if is_bright else self._DARK_BASE
-        blue = self._make_ansi_code(base_code, self._BLUE, is_bold=is_bright)
-
-        return blue
-
-    @classmethod
-    def _make_ansi_code(cls, base_code: int, color_offset: int, is_bold: bool):
-        return f"\033[{1 if is_bold else 0};{base_code + color_offset}m"
-
-
-def configure_logging(enable_debug=False):
-
-    root_logger = logging.getLogger()
-    log_level = logging.DEBUG if enable_debug else logging.INFO
-
-    if not root_logger.hasHandlers():
-
-        console_formatter = ColorFormatter(is_bright=True)
-        console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setFormatter(console_formatter)
-        console_handler.setLevel(logging.INFO)
-        root_logger.addHandler(console_handler)
-        root_logger.setLevel(log_level)
-
-        # Use is_bright=False for logs from the TRAC runtime, so model logs stand out
-
-        trac_logger = logging.getLogger("tracdap.rt")
-
-        console_formatter = ColorFormatter(is_bright=False)
-        console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setFormatter(console_formatter)
-        console_handler.setLevel(log_level)
-        trac_logger.addHandler(console_handler)
-        trac_logger.propagate = False
-
-
-def logger_for_object(obj: object) -> logging.Logger:
-    return logger_for_class(obj.__class__)
-
-
-def logger_for_class(clazz: type) -> logging.Logger:
-    qualified_class_name = f"{clazz.__module__}.{clazz.__name__}"
-    return logging.getLogger(qualified_class_name)
-
-
-def logger_for_namespace(namespace: str) -> logging.Logger:
-    return logging.getLogger(namespace)
-
-
 def format_file_size(size: int) -> str:
 
     if size < 1024:
@@ -235,7 +125,7 @@ def get_job_resource(
     if optional:
         return None
 
-    err = f"Missing required {selector.objectType} resource [{object_key(selector)}]"
+    err = f"Missing required {selector.objectType.name} resource [{object_key(selector)}]"
     raise ex.ERuntimeValidation(err)
 
 

tracdap/rt/_impl/{validation.py → core/validation.py}

@@ -22,7 +22,8 @@ import pathlib
 
 import tracdap.rt.metadata as meta
 import tracdap.rt.exceptions as ex
-import tracdap.rt._impl.util as util
+import tracdap.rt._impl.core.logging as log
+import tracdap.rt._impl.core.util as util
 
 # _Named placeholder type from API hook is needed for API type checking
 from tracdap.rt.api.hook import _Named  # noqa
@@ -66,15 +67,23 @@ class SkipValidation(tp.Generic[T_SKIP_VAL]):
 
 class _TypeValidator:
 
-    # The metaclass for generic types varies between versions of the typing library
-    # To work around this, detect the correct metaclass by inspecting a generic type variable
-    __generic_metaclass = type(tp.List[object])
+    # Support both new and old styles for generic, union and optional types
+    # Old-style annotations are still valid, even when the new style is fully supported
+    __generic_metaclass = [
+        types.GenericAlias,
+        type(tp.List[object]),
+        type(tp.Optional[object])
+    ]
+
+    # UnionType was added to the types module in Python 3.10, we support 3.9 (Jan 2025)
+    if hasattr(types, "UnionType"):
+        __generic_metaclass.append(types.UnionType)
 
     # Cache method signatures to avoid inspection on every call
     # Inspecting a function signature can take ~ half a second in Python 3.7
     __method_cache: tp.Dict[str, tp.Tuple[inspect.Signature, tp.Any]] = dict()
 
-    _log: logging.Logger = util.logger_for_namespace(__name__)
+    _log: logging.Logger = log.logger_for_namespace(__name__)
 
     @classmethod
     def validate_signature(cls, method: tp.Callable, *args, **kwargs):
@@ -203,7 +212,7 @@ class _TypeValidator:
             if value.skip_type == expected_type:
                 return True
 
-        if isinstance(expected_type, cls.__generic_metaclass):
+        if any(map(lambda _t: isinstance(expected_type, _t),  cls.__generic_metaclass)):
 
             origin = util.get_origin(expected_type)
             args = util.get_args(expected_type)
@@ -239,6 +248,33 @@ class _TypeValidator:
                     all(map(lambda k: cls._validate_type(key_type, k), value.keys())) and \
                     all(map(lambda v: cls._validate_type(value_type, v), value.values()))
 
+            if origin is type:
+
+                if not isinstance(value, type):
+                    return False
+
+                type_arg = args[0]
+
+                if type_arg == tp.Any:
+                    return True
+
+                if isinstance(type_arg, tp.TypeVar):
+
+                    constraints =  util.get_constraints(type_arg)
+                    bound = util.get_bound(type_arg)
+
+                    if constraints:
+                        if not any(map(lambda c: expected_type == c, constraints)):
+                            return False
+
+                    if bound:
+                        if not issubclass(expected_type, bound):
+                            return False
+
+                    # So long as constraints / bound are ok, any type matches a generic type var
+                    return True
+
+
             if origin.__module__.startswith("tracdap.rt.api."):
                 return isinstance(value, origin)
 
@@ -273,7 +309,7 @@ class _TypeValidator:
     @classmethod
     def _type_name(cls, type_var: tp.Type, qualified: bool = False) -> str:
 
-        if isinstance(type_var, cls.__generic_metaclass):
+        if any(map(lambda _t: isinstance(type_var, _t),  cls.__generic_metaclass)):
 
             origin = util.get_origin(type_var)
             args = util.get_args(type_var)
@@ -290,7 +326,11 @@ class _TypeValidator:
 
             if origin is list:
                 list_type = cls._type_name(args[0])
-                return f"List[{list_type}]"
+                return f"list[{list_type}]"
+
+            if origin is type:
+                type_arg = cls._type_name(args[0])
+                return f"type[{type_arg}]"
 
             raise ex.ETracInternal(f"Validation of [{origin.__name__}] generic parameters is not supported yet")
 
@@ -306,6 +346,9 @@ class StaticValidator:
     __reserved_identifier_pattern = re.compile("\\A(_|trac_)", re.ASCII)
     __label_length_limit = 4096
 
+    __file_extension_pattern = re.compile('\\A[a-zA-Z0-9]+\\Z')
+    __mime_type_pattern = re.compile('\\A\\w+/[-.\\w]+(?:\\+[-.\\w]+)?\\Z')
+
     __PRIMITIVE_TYPES = [
         meta.BasicType.BOOLEAN,
         meta.BasicType.INTEGER,
@@ -321,7 +364,7 @@ class StaticValidator:
         meta.BasicType.INTEGER,
         meta.BasicType.DATE]
 
-    _log: logging.Logger = util.logger_for_namespace(__name__)
+    _log: logging.Logger = log.logger_for_namespace(__name__)
 
     @classmethod
     def is_primitive_type(cls, basic_type: meta.BasicType) -> bool:
@@ -418,25 +461,49 @@ class StaticValidator:
                 cls._valid_identifiers(param.paramProps.keys(), "entry in param props")
 
     @classmethod
-    def _check_inputs_or_outputs(cls, inputs_or_outputs):
+    def _check_inputs_or_outputs(cls, sockets):
 
-        for input_name, input_schema in inputs_or_outputs.items():
+        for socket_name, socket in sockets.items():
 
-            cls._log.info(f"Checking {input_name}")
+            if socket.objectType == meta.ObjectType.DATA:
+                cls._check_socket_schema(socket_name, socket)
+            elif socket.objectType == meta.ObjectType.FILE:
+                cls._check_socket_file_type(socket_name, socket)
+            else:
+                raise ex.EModelValidation(f"Invalid object type [{socket.objectType.name}] for [{socket_name}]")
 
-            if input_schema.dynamic:
-                if input_schema.schema and input_schema.schema.table:
-                    error = "Dynamic schemas must have schema.table = None"
-                    cls._fail(f"Invalid schema for [{input_name}]: {error}")
-                else:
-                    continue
+            label = socket.label
+            cls._check_label(label, socket_name)
+
+            if isinstance(socket, meta.ModelInputSchema):
+                if socket.inputProps is not None:
+                    cls._valid_identifiers(socket.inputProps.keys(), "entry in input props")
+            else:
+                if socket.outputProps is not None:
+                    cls._valid_identifiers(socket.outputProps.keys(), "entry in output props")
 
-            fields = input_schema.schema.table.fields
+    @classmethod
+    def _check_socket_schema(cls, socket_name, socket):
+
+        if socket.schema is None:
+            cls._fail(f"Missing schema requirement for [{socket_name}]")
+            return
+
+        if socket.dynamic:
+            if socket.schema and socket.schema.table:
+                error = "Dynamic schemas must have schema.table = None"
+                cls._fail(f"Invalid schema for [{socket_name}]: {error}")
+            else:
+                return
+
+        if socket.schema.schemaType == meta.SchemaType.TABLE:
+
+            fields = socket.schema.table.fields
             field_names = list(map(lambda f: f.fieldName, fields))
-            property_type = f"field in [{input_name}]"
+            property_type = f"field in [{socket_name}]"
 
             if len(fields) == 0:
-                cls._fail(f"Invalid schema for [{input_name}]: No fields defined")
+                cls._fail(f"Invalid schema for [{socket_name}]: No fields defined")
 
             cls._valid_identifiers(field_names, property_type)
             cls._case_insensitive_duplicates(field_names, property_type)
@@ -444,23 +511,24 @@ class StaticValidator:
             for field in fields:
                 cls._check_single_field(field, property_type)
 
-            label = input_schema.label
-            cls._check_label(label, input_name)
+    @classmethod
+    def _check_socket_file_type(cls, socket_name, socket):
 
-            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")
+        if socket.fileType is None:
+            cls._fail(f"Missing file type requirement for [{socket_name}]")
+            return
+
+        if not cls.__file_extension_pattern.match(socket.fileType.extension):
+            cls._fail(f"Invalid extension [{socket.fileType.extension}] for [{socket_name}]")
+
+        if not cls.__mime_type_pattern.match(socket.fileType.mimeType):
+            cls._fail(f"Invalid mime type [{socket.fileType.mimeType}] for [{socket_name}]")
 
     @classmethod
     def _check_single_field(cls, field: meta.FieldSchema, property_type):
 
         # Valid identifier and not trac reserved checked separately
 
-        cls._log.info(field.fieldName)
-
         if field.fieldOrder < 0:
             cls._fail(f"Invalid {property_type}: [{field.fieldName}] fieldOrder < 0")
 

tracdap/rt/_impl/exec/__init__.py

@@ -0,0 +1,14 @@
+#  Licensed to the Fintech Open Source Foundation (FINOS) under one or
+#  more contributor license agreements. See the NOTICE file distributed
+#  with this work for additional information regarding copyright ownership.
+#  FINOS licenses this file to you 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.

tracdap/rt/{_exec → _impl/exec}/actors.py

@@ -13,8 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from __future__ import annotations
-
 import logging
 import threading
 import functools as func
@@ -25,8 +23,8 @@ import inspect
 import queue
 import time
 
-import tracdap.rt._impl.util as util  # noqa
-import tracdap.rt._impl.validation as _val  # noqa
+import tracdap.rt._impl.core.logging as _logging
+import tracdap.rt._impl.core.validation as _val
 import tracdap.rt.exceptions as _ex
 
 
@@ -118,7 +116,7 @@ class Actor:
     def error(self) -> tp.Optional[Exception]:
         return self.__ctx.get_error()
 
-    def actors(self) -> ActorContext:
+    def actors(self) -> "ActorContext":
         return self.__ctx
 
     def on_start(self):
@@ -134,7 +132,7 @@ class Actor:
 class ActorContext:
 
     def __init__(
-            self, node: ActorNode, message: str,
+            self, node: "ActorNode", message: str,
             current_actor: ActorId, parent: ActorId, sender: tp.Optional[ActorId]):
 
         self.__node = node
@@ -188,13 +186,13 @@ class ThreadsafeActor(Actor):
         super().__init__()
         self.__threadsafe: tp.Optional[ThreadsafeContext] = None
 
-    def threadsafe(self) -> ThreadsafeContext:
+    def threadsafe(self) -> "ThreadsafeContext":
         return self.__threadsafe
 
 
 class ThreadsafeContext:
 
-    def __init__(self, node: ActorNode):
+    def __init__(self, node: "ActorNode"):
         self.__node = node
         self.__id = node.actor_id
         self.__parent = node.parent.actor_id if node.parent is not None else None
@@ -235,7 +233,7 @@ class EventLoop:
         self.__shutdown = False
         self.__shutdown_now = False
         self.__done = False
-        self.__log = util.logger_for_object(self)
+        self.__log = _logging.logger_for_object(self)
 
     def post_message(self, msg: _T_MSG, processor: tp.Callable[[_T_MSG], None]) -> bool:
         with self.__msg_lock:
@@ -365,12 +363,12 @@ class FunctionCache:
 
 class ActorNode:
 
-    _log = util.logger_for_class(Actor)
+    _log = _logging.logger_for_class(Actor)
 
     def __init__(
             self, actor_id: ActorId, actor: Actor,
-            parent: tp.Optional[ActorNode],
-            system: ActorSystem,
+            parent: "tp.Optional[ActorNode]",
+            system: "ActorSystem",
             event_loop: EventLoop):
 
         self.actor_id = actor_id
@@ -483,7 +481,7 @@ class ActorNode:
 
         target_node._accept(msg)
 
-    def _lookup_node(self, target_id: ActorId) -> tp.Optional[ActorNode]:
+    def _lookup_node(self, target_id: ActorId) -> "tp.Optional[ActorNode]":
 
         # Check self first
 
@@ -904,7 +902,7 @@ class ActorSystem:
 
         super().__init__()
 
-        self._log = util.logger_for_object(self)
+        self._log = _logging.logger_for_object(self)
 
         # self.__actors: tp.Dict[ActorId, ActorNode] = {self.__ROOT_ID: ActorNode("", self.__ROOT_ID, None)}
         # self.__message_queue: tp.List[Msg] = list()