tracdap-runtime 0.10.0.dev3__tar.gz → 0.10.0.dev4__tar.gz

{tracdap_runtime-0.10.0.dev3/tracdap_runtime.egg-info → tracdap_runtime-0.10.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tracdap-runtime
-Version: 0.10.0.dev3
+Version: 0.10.0.dev4
 Summary: Portable, production-grade models in Python
 Home-page: https://www.fintrac.co.uk/
 Author: Martin Traverse

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = tracdap-runtime
-version = 0.10.0.dev3
+version = 0.10.0.dev4
 license = Apache-2.0
 platform = any
 description = Portable, production-grade models in Python

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/src/tracdap/rt/__init__.py

@@ -13,4 +13,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-__version__ = "0.10.0.dev3"
+__version__ = "0.10.0.dev4"

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/src/tracdap/rt/_impl/core/resources.py

@@ -86,3 +86,27 @@ class ResourceManager:
             raise _ex.ETracInternal(f"External system [{system_name}] is not available")
 
         return system
+
+
+class ResourceMeta(type):
+
+    # Use a placeholder type for representing resources in the execution engine
+    # This allows resource objects to be defined and type checked during graph processing
+
+    __RESOURCE_TYPES = [_external.IExternalSystem]
+
+    def __instancecheck__(self, instance):
+        for resource_type in self.__RESOURCE_TYPES:
+            if isinstance(instance, resource_type):
+                return True
+        return False
+
+    def __subclasscheck__(self, subclass):
+        for resource_type in self.__RESOURCE_TYPES:
+            if issubclass(subclass, resource_type):
+                return True
+        return False
+
+
+class Resource(metaclass=ResourceMeta):
+    pass

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/src/tracdap/rt/_impl/core/validation.py

@@ -68,24 +68,39 @@ def is_primitive_type(basic_type: meta.BasicType) -> bool:
 
 T_PLUGIN = tp.TypeVar("T_PLUGIN")
 
+
 def plugin_validation_wrapper(plugin_api: tp.Type[T_PLUGIN], plugin: T_PLUGIN) -> T_PLUGIN:
 
     # Create a wrapper that validates return values from plugin API calls
-    # A dynamic type would give better type similarity, but is more fiddly to set up
+    # Use ABC registration to pass isinstance() checks, only register each wrapper type once
     # Since plugins are not exposed directly to client code, this approach should suffice
 
+    if not hasattr(plugin_validation_wrapper, "__registrations"):
+        plugin_validation_wrapper.__registrations = {}
+
+    if plugin_api in plugin_validation_wrapper.__registrations:
+        wrapper_class = plugin_validation_wrapper.__registrations[plugin_api]
+        return wrapper_class(plugin)
+
     class PluginValidationWrapper:
 
         def __init__(self, delegate: T_PLUGIN):
             self.__delegate = delegate
+            self.__cache = dict()
 
         def __getattr__(self, name: str) -> tp.Any:
 
+            # Do not create a new wrapped method object on every call
+            cache_method = self.__cache.get(name)
+            if cache_method:
+                return cache_method
+
             # Use abstract method to validate (concrete plugin may have bad annotations)
             abstract_method = getattr(plugin_api, name)
             concrete_method = getattr(self.__delegate, name)
 
             if abstract_method is None or not callable(abstract_method):
+                self.__cache[name] = concrete_method
                 return concrete_method
 
             def wrapped_method(*args, **kwargs):
@@ -100,13 +115,11 @@ def plugin_validation_wrapper(plugin_api: tp.Type[T_PLUGIN], plugin: T_PLUGIN) -
                     message = f"Invalid plugin: [{util.qualified_type_name(type(plugin))}] {detail}"
                     raise ex.EPluginConformance(message) from e
 
+            self.__cache[name] = wrapped_method
             return wrapped_method
 
-        def __instancecheck__(self, instance: tp.Any) -> bool:
-            return isinstance(instance, plugin_api)
-
-        def __subclasscheck__(self, subclass: tp.Any) -> bool:
-            return issubclass(subclass, self._interface)
+    plugin_validation_wrapper.__registrations[plugin_api] = PluginValidationWrapper
+    plugin_api.register(PluginValidationWrapper)
 
     return PluginValidationWrapper(plugin)
 
@@ -609,9 +622,9 @@ class StaticValidator:
             if resource.resourceType == meta.ResourceType.EXTERNAL_SYSTEM:
                 if resource.protocol is None or len(resource.protocol) == 0:
                     cls._fail(f"Invalid model resource: [{resource_name}] protocol is missing")
-                if resource.system.client_type is None or len(resource.system.client_type) == 0:
+                if resource.system.clientType is None or len(resource.system.clientType) == 0:
                     cls._fail(f"Invalid model resource: [{resource_name}] client type is missing")
-                if not cls.__qualified_identifier_pattern.match(resource.system.client_type):
+                if not cls.__qualified_identifier_pattern.match(resource.system.clientType):
                     cls._fail(f"Invalid model resource: [{resource_name}] client type is not a valid Python type")
 
             else:

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/src/tracdap/rt/_impl/exec/context.py

@@ -122,9 +122,8 @@ class TracContextImpl(_api.TracContext):
 
     :param model_def: Definition object for the model that will run in this context
     :param model_class: Type for the model that will run in this context
-    :param local_ctx: Dictionary of all parameters, inputs and outputs that will be available to the model
-            Parameters are supplied as python native types.
-            Output views will contain schemas but no data.
+    :param local_ctx: Dictionary of all parameters, inputs, outputs and resources that will be available to the model.
+            Parameters are supplied as python native types. Output views will contain schemas but no data.
     """
 
     def __init__(self,
@@ -132,7 +131,6 @@ class TracContextImpl(_api.TracContext):
                  model_class: _api.TracModel.__class__,
                  local_ctx: tp.Dict[str, tp.Any],
                  dynamic_outputs: tp.List[str] = None,
-                 resources: tp.Dict[str, tp.Any] = None,
                  log_provider: _logging.LogProvider = None,
                  checkout_directory: pathlib.Path = None):
 
@@ -147,14 +145,12 @@ class TracContextImpl(_api.TracContext):
         self.__model_class = model_class
         self.__local_ctx = local_ctx if local_ctx is not None else {}
         self.__dynamic_outputs = dynamic_outputs if dynamic_outputs is not None else []
-        self.__resources = resources if resources is not None else {}
         self.__rct = _util.RuntimeContextTracking()
 
         self.__val = TracContextValidator(
             self.__ctx_log,
             self.__model_def,
             self.__local_ctx,
-            self.__resources,
             self.__dynamic_outputs,
             checkout_directory)
 
@@ -327,7 +323,7 @@ class TracContextImpl(_api.TracContext):
         self.__val.check_item_defined_in_model(system_name, TracContextValidator.SYSTEM)
         self.__val.check_item_available_in_context(system_name, TracContextValidator.SYSTEM)
 
-        system = self.__resources.get(system_name)
+        system = self.__local_ctx.get(system_name)
 
         self.__val.check_context_object_type(system_name, system, TracExternalSystemWrapper)
         self.__val.check_external_system_client_type(system_name, system, client_type)
@@ -547,7 +543,7 @@ class TracDataContextImpl(TracContextImpl, _eapi.TracDataContext):
             storage_map: tp.Dict[str, tp.Union[_eapi.TracFileStorage, _eapi.TracDataStorage]],
             log_provider: _logging.LogProvider = None, checkout_directory: pathlib.Path = None):
 
-        super().__init__(model_def, model_class, local_ctx, dynamic_outputs, storage_map, log_provider, checkout_directory)
+        super().__init__(model_def, model_class, local_ctx, dynamic_outputs, log_provider, checkout_directory)
 
         self.__model_def = model_def
         self.__local_ctx = local_ctx
@@ -939,7 +935,6 @@ class TracContextValidator(TracContextErrorReporter):
             self, log: logging.Logger,
             model_def: _meta.ModelDefinition,
             local_ctx: tp.Dict[str, tp.Any],
-            resources: tp.Dict[str, tp.Any],
             dynamic_outputs: tp.List[str],
             checkout_directory: pathlib.Path):
 
@@ -947,7 +942,6 @@ class TracContextValidator(TracContextErrorReporter):
 
         self.__model_def = model_def
         self.__local_ctx = local_ctx
-        self.__resources = resources
         self.__dynamic_outputs = dynamic_outputs
 
     def check_item_valid_identifier(self, item_name: str, item_type: str):
@@ -985,16 +979,12 @@ class TracContextValidator(TracContextErrorReporter):
 
     def check_item_available_in_context(self, item_name: str, item_type: str):
 
-        ctx = self.__resources if item_type in [self.SYSTEM] else self.__local_ctx
-
-        if item_name not in ctx:
+        if item_name not in self.__local_ctx:
             self._report_error(f"{item_type} {item_name} is not available in the current context")
 
     def check_item_not_available_in_context(self, item_name: str, item_type: str):
 
-        ctx = self.__resources if item_type in [self.SYSTEM] else self.__local_ctx
-
-        if item_name in ctx:
+        if item_name in self.__local_ctx:
             self._report_error(f"{item_type} {item_name} already exists in the current context")
 
     def check_dataset_is_dynamic_output(self, dataset_name: str):
@@ -1161,7 +1151,7 @@ class TracContextValidator(TracContextErrorReporter):
     def check_external_system_client_type(self, system_name, system, client_type):
 
         model_system = self.__model_def.resources.get(system_name)
-        model_type_name = model_system.system.client_type if model_system and model_system.system else None
+        model_type_name = model_system.system.clientType if model_system and model_system.system else None
         client_type_name = _util.qualified_type_name(client_type)
 
         if client_type_name != model_type_name:

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/src/tracdap/rt/_impl/exec/dev_mode.py

@@ -551,7 +551,7 @@ class DevModeTranslator:
                 errors[target_key] = f"Flow target {target_name} is not provided by any node"
 
         for node_name, node in flow.nodes.items():
-            if node.nodeType == _meta.FlowNodeType.INPUT_NODE or node.nodeType == _meta.FlowNodeType.PARAMETER_NODE:
+            if node.nodeType in [_meta.FlowNodeType.INPUT_NODE, _meta.FlowNodeType.PARAMETER_NODE, _meta.FlowNodeType.RESOURCE_NODE]:
                 add_source(node_name, _meta.FlowSocket(node_name))
             if node.nodeType == _meta.FlowNodeType.MODEL_NODE:
                 for model_output in node.outputs:
@@ -574,6 +574,8 @@ class DevModeTranslator:
                     add_edge(_meta.FlowSocket(node_name, model_input))
                 for model_param in node.parameters:
                     add_edge(_meta.FlowSocket(node_name, model_param))
+                for model_resource in node.resources:
+                    add_edge(_meta.FlowSocket(node_name, model_resource))
 
         if any(errors):
 
@@ -613,6 +615,11 @@ class DevModeTranslator:
 
         for node_name, node in flow.nodes.items():
 
+            if node.nodeType == _meta.FlowNodeType.RESOURCE_NODE and node_name not in flow.resources:
+                targets = edges_by_source.get(node_name) or []
+                model_resource = cls._infer_resource(node_name, targets, job_def, job_config)
+                updated_flow.resources[node_name] = model_resource
+
             if node.nodeType == _meta.FlowNodeType.PARAMETER_NODE and node_name not in flow.parameters:
                 targets = edges_by_source.get(node_name) or []
                 model_parameter = cls._infer_parameter(node_name, targets, job_def, job_config)
@@ -631,28 +638,56 @@ class DevModeTranslator:
         return updated_flow
 
     @classmethod
-    def _infer_parameter(
-            cls, param_name: str, targets: tp.List[_meta.FlowSocket],
+    def _infer_resource(
+            cls, resource_name: str, targets: tp.List[_meta.FlowSocket],
             job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
-            -> _meta.ModelParameter:
+            -> _meta.ModelResource:
 
-        model_params = []
+        model_resources = cls._infer_targets(
+            resource_name, targets, lambda model: model.resources,
+            job_def, job_config)
 
-        for target in targets:
+        model_resource: _meta.ModelResource = model_resources[0]
 
-            model_selector = job_def.runFlow.models.get(target.node)
-            model_obj = _util.get_job_metadata(model_selector, job_config)
-            model_param = model_obj.model.parameters.get(target.socket)
-            model_params.append(model_param)
+        for i in range(1, len(targets)):
 
-        if len(model_params) == 0:
-            err = f"Flow parameter [{param_name}] is not connected to any models, type information cannot be inferred" \
-                  + f" (either remove the parameter or connect it to a model)"
-            cls._log.error(err)
-            raise _ex.EJobValidation(err)
+            next_resource: _meta.ModelResource = model_resources[i]
+
+            if next_resource.resourceType != model_resource.resourceType:
+                err = f"Resource is ambiguous for [{resource_name}]: " + \
+                      f"Resource types are different for [{cls._socket_key(targets[0])}] and [{cls._socket_key(targets[i])}]"
+                raise _ex.EJobValidation(err)
+
+            if model_resource.protocol is None:
+                model_resource.protocol = next_resource.protocol
+            elif model_resource.protocol != next_resource.protocol:
+                err = f"Resource is ambiguous for [{resource_name}]: " + \
+                      f"Protocols are different for [{cls._socket_key(targets[0])}] and [{cls._socket_key(targets[i])}]"
+                raise _ex.EJobValidation(err)
+
+            if model_resource.subProtocol is None:
+                model_resource.subProtocol = next_resource.subProtocol
+            elif model_resource.subProtocol != next_resource.subProtocol:
+                err = f"Resource is ambiguous for [{resource_name}]: " + \
+                      f"Sub protocols are different for [{cls._socket_key(targets[0])}] and [{cls._socket_key(targets[i])}]"
+                raise _ex.EJobValidation(err)
+
+            # System details are informational, safe to remove if they are not a match
+            if model_resource.system is not None and next_resource.system is not None:
+                if model_resource.system != next_resource.system:
+                    model_resource.system = None
+
+        return model_resource
+
+    @classmethod
+    def _infer_parameter(
+            cls, param_name: str, targets: tp.List[_meta.FlowSocket],
+            job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
+            -> _meta.ModelParameter:
 
-        if len(model_params) == 1:
-            return model_params[0]
+        model_params = cls._infer_targets(
+            param_name, targets, lambda model: model.parameters,
+            job_def, job_config)
 
         model_param = model_params[0]
 
@@ -673,23 +708,9 @@ class DevModeTranslator:
             job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
             -> _meta.ModelInputSchema:
 
-        model_inputs = []
-
-        for target in targets:
-
-            model_selector = job_def.runFlow.models.get(target.node)
-            model_obj = _util.get_job_metadata(model_selector, job_config)
-            model_input = model_obj.model.inputs.get(target.socket)
-            model_inputs.append(model_input)
-
-        if len(model_inputs) == 0:
-            err = f"Flow input [{input_name}] is not connected to any models, schema cannot be inferred" \
-                  + f" (either remove the input or connect it to a model)"
-            cls._log.error(err)
-            raise _ex.EJobValidation(err)
-
-        if len(model_inputs) == 1:
-            return model_inputs[0]
+        model_inputs = cls._infer_targets(
+            input_name, targets, lambda model: model.inputs,
+            job_def, job_config)
 
         model_input = model_inputs[0]
 
@@ -708,29 +729,44 @@ class DevModeTranslator:
             job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
             -> _meta.ModelOutputSchema:
 
-        model_outputs = []
-
-        for source in sources:
-
-            model_selector = job_def.runFlow.models.get(source.node)
-            model_obj = _util.get_job_metadata(model_selector, job_config)
-            model_input = model_obj.model.outputs.get(source.socket)
-            model_outputs.append(model_input)
-
-        if len(model_outputs) == 0:
-            err = f"Flow output [{output_name}] is not connected to any models, schema cannot be inferred" \
-                  + f" (either remove the output or connect it to a model)"
-            cls._log.error(err)
-            raise _ex.EJobValidation(err)
+        # Lookup logic is the same for source and target sockets
+        model_outputs = cls._infer_targets(
+            output_name, sources, lambda model: model.outputs,
+            job_def, job_config)
 
         if len(model_outputs) > 1:
-            err = f"Flow output [{output_name}] is not to multiple models" \
+            err = f"Flow output [{output_name}] is connected to multiple models" \
                   + f" (only one model can supply one output)"
             cls._log.error(err)
             raise _ex.EJobValidation(err)
 
         return model_outputs[0]
 
+    @classmethod
+    def _infer_targets(
+            cls, node_name: str, targets, target_func: tp.Callable[[_meta.ModelDefinition], dict],
+            job_def: _meta.JobDefinition, job_config: _cfg.JobConfig):
+
+        # Common logic to look up inference targets
+
+        target_objects = []
+
+        for targets in targets:
+
+            model_selector = job_def.runFlow.models.get(targets.node)
+            model_obj = _util.get_job_metadata(model_selector, job_config)
+            target_map = target_func(model_obj.model)
+            target_obj = target_map.get(targets.socket)
+            target_objects.append(target_obj)
+
+        if len(target_objects) == 0:
+            err = f"Flow node [{node_name}] is not connected to any models, type inference is not possible" \
+                  + f" (either remove this node or connect it to a model)"
+            cls._log.error(err)
+            raise _ex.EJobValidation(err)
+
+        return target_objects
+
     @classmethod
     def _socket_key(cls, socket):
         return f"{socket.node}.{socket.socket}" if socket.socket else socket.node

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/src/tracdap/rt/_impl/exec/engine.py

@@ -1190,6 +1190,7 @@ class NodeLogger:
         PUSH_POP = 2
         SIMPLE_MAPPING = 3
         MODEL = 4
+        RESOURCE = 5
 
     def log_node_start(self, node: _EngineNode):
 
@@ -1203,6 +1204,9 @@ class NodeLogger:
         elif logging_type in [self.LoggingType.SIMPLE_MAPPING]:
             self._log.info(f"MAP {self._value_type(node)} [{self._mapping_source(node)}] -> [{node_name}] / {namespace}")
 
+        elif logging_type == self.LoggingType.RESOURCE:
+            self._log.info(f"USE {self._func_type(node)} [{node_name}] / {namespace}")
+
         else:
             self._log.info(f"START {self._func_type(node)} [{node_name}] / {namespace}")
 
@@ -1212,7 +1216,7 @@ class NodeLogger:
         node_name = node.node.id.name
         namespace = node.node.id.namespace
 
-        if logging_type in [self.LoggingType.STATIC_VALUE, self.LoggingType.SIMPLE_MAPPING]:
+        if logging_type in [self.LoggingType.STATIC_VALUE, self.LoggingType.SIMPLE_MAPPING, self.LoggingType.RESOURCE]:
             return
 
         if logging_type == self.LoggingType.PUSH_POP:
@@ -1237,7 +1241,7 @@ class NodeLogger:
         node_name = node.node.id.name
         namespace = node.node.id.namespace
 
-        if logging_type in [self.LoggingType.STATIC_VALUE, self.LoggingType.SIMPLE_MAPPING]:
+        if logging_type in [self.LoggingType.STATIC_VALUE, self.LoggingType.SIMPLE_MAPPING, self.LoggingType.RESOURCE]:
             return
 
         self._log.info(f"EVICT {self._func_type(node)} [{node_name}] / {namespace}")
@@ -1276,6 +1280,9 @@ class NodeLogger:
         if isinstance(node.node, _graph.RunModelNode):
             return cls.LoggingType.MODEL
 
+        if isinstance(node.node, _graph.ResourceNode):
+            return cls.LoggingType.RESOURCE
+
         return cls.LoggingType.DEFAULT
 
     @classmethod

{tracdap_runtime-0.10.0.dev3 → tracdap_runtime-0.10.0.dev4}/src/tracdap/rt/_impl/exec/functions.py

@@ -33,6 +33,7 @@ import tracdap.rt._impl.core.storage as _storage
 import tracdap.rt._impl.core.struct as _struct
 import tracdap.rt._impl.core.models as _models
 import tracdap.rt._impl.core.util as _util
+import tracdap.rt.ext.external as _ext_system
 
 from tracdap.rt._impl.exec.graph import *
 from tracdap.rt._impl.exec.graph import _T
@@ -213,6 +214,21 @@ class ContextPopFunc(_ContextPushPopFunc):
         super(ContextPopFunc, self).__init__(node, self._POP)
 
 
+# RESOURCE PROVISION
+# ------------------
+
+
+class ResourceFunc(NodeFunction):
+
+    def __init__(self, node: ResourceNode, resource: _resources.Resource):
+        super().__init__()
+        self.node = node
+        self.resource = resource
+
+    def _execute(self, ctx: NodeContext) -> _resources.Resource:
+        return self.resource
+
+
 # DATA HANDLING
 # -------------
 
@@ -599,6 +615,8 @@ class RunModelFunc(NodeFunction[Bundle[_data.DataView]]):
             if node_id.namespace == self.node.id.namespace:
                 if node_id.name in model_def.parameters or node_id.name in model_def.inputs:
                     local_ctx[node_id.name] = node_result
+                elif node_id.name in model_def.resources:
+                    local_ctx[node_id.name] = self._wrap_resource(node_id.name, node_result)
 
         # Run the model against the mapped local context
 
@@ -610,7 +628,7 @@ class RunModelFunc(NodeFunction[Bundle[_data.DataView]]):
         else:
             trac_ctx = _ctx.TracContextImpl(
                 self.node.model_def, self.model_class,
-                local_ctx, dynamic_outputs, self.resources,
+                local_ctx, dynamic_outputs,
                 self.log_provider, self.checkout_directory)
 
         try:
@@ -648,6 +666,13 @@ class RunModelFunc(NodeFunction[Bundle[_data.DataView]]):
 
         return results
 
+    def _wrap_resource(self, resource_name, resource):
+
+        if isinstance(resource, _ext_system.IExternalSystem):
+            return _ctx.TracExternalSystemWrapper(resource)
+
+        raise _ex.EJobValidation(f"Unsupported resource [{resource_name}] of type [{type(resource).__name__}]")
+
 
 # RESULTS PROCESSING
 # ------------------
@@ -828,6 +853,20 @@ class FunctionResolver:
 
         return resolve_func(self, node)
 
+    def resolve_resource_node(self, node: ResourceNode):
+
+        if node.model_resource is not None:
+            resource_def = self._resources.get_resource_definition(node.resource_key)
+            self._check_model_resource(node.resource_key, node.model_resource, resource_def)
+
+        if node.resource_type == _meta.ResourceType.EXTERNAL_SYSTEM:
+            resource = self._resources.get_external_system(node.resource_key)
+        else:
+            # Other resource types not currently used as graph nodes
+            raise _ex.EUnexpected()
+
+        return ResourceFunc(node, resource)
+
     def resolve_load_data(self, node: LoadDataNode):
         return LoadDataFunc(node, self._resources.get_storage())
 
@@ -845,10 +884,10 @@ class FunctionResolver:
         model_class = model_loader.load_model_class(node.model_scope, node.model_def)
         checkout_directory = model_loader.model_load_checkout_directory(node.model_scope, node.model_def)
 
-        # Prepare model resources - Missing resources will raise an error during the resolve phase
-        resources = self._resolve_model_resources(node, checkout_directory, self._log_provider)
+        # Prepare external storage resources - Missing resources will raise an error during the resolve phase
+        storage_map = self._resolve_model_storage_resources(node, checkout_directory, self._log_provider)
 
-        return RunModelFunc(node, model_class, resources, self._log_provider, checkout_directory)
+        return RunModelFunc(node, model_class, storage_map, self._log_provider, checkout_directory)
 
     __basic_node_mapping: tp.Dict[Node.__class__, NodeFunction.__class__] = {
 
@@ -869,33 +908,21 @@ class FunctionResolver:
 
     __node_mapping: tp.Dict[Node.__class__, tp.Callable[["FunctionResolver", Node], NodeFunction]] = {
 
+        ResourceNode: resolve_resource_node,
         LoadDataNode: resolve_load_data,
         SaveDataNode: resolve_save_data,
         RunModelNode: resolve_run_model_node,
         ImportModelNode: resolve_import_model_node
     }
 
-    def _resolve_model_resources(
+    def _resolve_model_storage_resources(
             self, node: RunModelNode,
             checkout_directory, log_provider) \
             -> tp.Dict[str, tp.Any]:
 
-        resources = {}
-
-        for model_resource_key, model_resource in node.model_def.resources.items():
-
-            resource_key = node.resource_mapping.get(model_resource_key)
-            resource_def = self._resources.get_resource_definition(resource_key) if resource_key else None
-
-            self._check_model_resource(
-                model_resource_key, model_resource,
-                resource_key, resource_def)
-
-            if resource_def.resourceType == _meta.ResourceType.EXTERNAL_SYSTEM:
-                system_impl = self._resources.get_external_system(resource_key)
-                system = _ctx.TracExternalSystemWrapper(system_impl)
-                resources[model_resource_key] = system
+        storage_map = {}
 
+        # TODO: Switch to resource nodes for external storage
         if node.storage_access:
 
             storage_manager = self._resources.get_storage()
@@ -905,7 +932,7 @@ class FunctionResolver:
                 if storage_manager.has_file_storage(storage_key, external=True):
                     storage_impl = storage_manager.get_file_storage(storage_key, external=True)
                     storage = _ctx.TracFileStorageImpl(storage_key, storage_impl, write_access, checkout_directory, log_provider)
-                    resources[storage_key] = storage
+                    storage_map[storage_key] = storage
                 elif storage_manager.has_data_storage(storage_key, external=True):
                     storage_impl = storage_manager.get_data_storage(storage_key, external=True)
                     # This is a work-around until the storage extension API can be updated / unified
@@ -913,31 +940,29 @@ class FunctionResolver:
                         raise _ex.EStorageConfig(f"External storage for [{storage_key}] is using the legacy storage framework]")
                     converter = _data.DataConverter.noop()
                     storage = _ctx.TracDataStorageImpl(storage_key, storage_impl, converter, write_access, checkout_directory, log_provider)
-                    resources[storage_key] = storage
+                    storage_map[storage_key] = storage
                 else:
                     raise _ex.EStorageConfig(f"External storage is not available: [{storage_key}]")
 
-        return resources
+        return storage_map
 
     @classmethod
     def _check_model_resource(
-            cls, model_resource_key: str, model_resource: _meta.ModelResource,
-            resource_key: str, resource_def: _meta.ResourceDefinition):
-
-        if resource_key is None:
-            raise _ex.EJobValidation(f"Resource [{model_resource_key}] is not available (missing resource mapping)")
+            cls, resource_key: str,
+            model_resource: _meta.ModelResource,
+            resource_def: _meta.ResourceDefinition):
 
         if resource_def is None:
-            raise _ex.EJobValidation(f"Resource [{model_resource_key}] is not available (missing job resource [{resource_key}])")
+            raise _ex.EJobValidation(f"Resource [{resource_key}] is not available)")
 
         if model_resource.resourceType != resource_def.resourceType:
             detail = f"(expected {model_resource.resourceType}, got {resource_def.resourceType})"
-            raise _ex.EJobValidation(f"Resource [{model_resource_key}] is not compatible with the model {detail}")
+            raise _ex.EJobValidation(f"Resource [{resource_key}] is not compatible with the model {detail}")
 
         if model_resource.protocol and model_resource.protocol != resource_def.protocol:
             detail = f"(expected protocol {model_resource.protocol}, got protocol {resource_def.protocol})"
-            raise _ex.EJobValidation(f"Resource [{model_resource_key}] is not compatible with the model {detail}")
+            raise _ex.EJobValidation(f"Resource [{resource_key}] is not compatible with the model {detail}")
 
         if model_resource.subProtocol and model_resource.subProtocol != resource_def.subProtocol:
             detail = f"(expected sub-protocol {model_resource.protocol}, got sub-protocol {resource_def.protocol})"
-            raise _ex.EJobValidation(f"Resource [{model_resource_key}] is not compatible with the model {detail}")
+            raise _ex.EJobValidation(f"Resource [{resource_key}] is not compatible with the model {detail}")