tracdap-runtime 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

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()