tracdap-runtime 0.6.2__tar.gz → 0.6.3__tar.gz

{tracdap_runtime-0.6.2/tracdap_runtime.egg-info → tracdap_runtime-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tracdap-runtime
-Version: 0.6.2
+Version: 0.6.3
 Summary: Runtime package for building models on the TRAC Data & Analytics Platform
 Home-page: https://tracdap.finos.org/
 Author: Martin Traverse
@@ -16,9 +16,9 @@ Classifier: Operating System :: OS Independent
 Requires-Python: <3.13,>=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: protobuf==5.27.4
-Requires-Dist: pyarrow==16.0.0
-Requires-Dist: pyyaml==6.0.1
+Requires-Dist: protobuf==5.28.2
+Requires-Dist: pyarrow==16.1.0
+Requires-Dist: pyyaml==6.0.2
 Requires-Dist: dulwich==0.22.1
 Requires-Dist: requests==2.32.3
 Requires-Dist: pandas<2.3.0,>=1.2.0

{tracdap_runtime-0.6.2 → tracdap_runtime-0.6.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = tracdap-runtime
-version = 0.6.2
+version = 0.6.3
 description = Runtime package for building models on the TRAC Data & Analytics Platform
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -31,8 +31,6 @@ packages =
 	tracdap.rt._impl.grpc
 	tracdap.rt._impl.grpc.tracdap
 	tracdap.rt._impl.grpc.tracdap.metadata
-	tracdap.rt._impl.grpc.tracdap.config
-	tracdap.rt._impl.grpc.tracdap.api
 	tracdap.rt._impl.grpc.tracdap.api.internal
 	tracdap.rt._plugins
 package_dir = 
@@ -40,9 +38,9 @@ package_dir =
 	tracdap.rt = src/tracdap/rt
 python_requires = >= 3.8, < 3.13
 install_requires = 
-	protobuf == 5.27.4
-	pyarrow == 16.0.0
-	pyyaml == 6.0.1
+	protobuf == 5.28.2
+	pyarrow == 16.1.0
+	pyyaml == 6.0.2
 	dulwich == 0.22.1
 	requests == 2.32.3
 	

{tracdap_runtime-0.6.2 → tracdap_runtime-0.6.3}/src/tracdap/rt/_exec/actors.py

@@ -25,6 +25,7 @@ import queue
 import time
 
 import tracdap.rt._impl.util as util  # noqa
+import tracdap.rt._impl.validation as _val  # noqa
 import tracdap.rt.exceptions as _ex
 
 
@@ -180,6 +181,49 @@ class ActorContext:
         return self.__error or self.__node.error
 
 
+class ThreadsafeActor(Actor):
+
+    def __init__(self):
+        super().__init__()
+        self.__threadsafe: tp.Optional[ThreadsafeContext] = None
+
+    def threadsafe(self) -> ThreadsafeContext:
+        return self.__threadsafe
+
+
+class ThreadsafeContext:
+
+    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
+
+    def spawn(self, actor: Actor):
+        self.__node.event_loop.post_message(
+            None, lambda _:
+            self.__node.spawn(actor) and None)
+
+    def send(self, target_id: ActorId, message: str, *args, **kwargs):
+        self.__node.event_loop.post_message(
+            None, lambda _:
+            self.__node.send_message(self.__id, target_id, message, args, kwargs))
+
+    def send_parent(self, message: str, *args, **kwargs):
+        self.__node.event_loop.post_message(
+            None, lambda _:
+            self.__node.send_message(self.__id, self.__parent, message, args, kwargs))
+
+    def stop(self):
+        self.__node.event_loop.post_message(
+            None, lambda _:
+            self.__node.send_signal(self.__id, self.__id, SignalNames.STOP))
+
+    def fail(self, error: Exception):
+        self.__node.event_loop.post_message(
+            None, lambda _:
+            self.__node.send_signal(self.__id, self.__id, SignalNames.STOP, error))
+
+
 class EventLoop:
 
     _T_MSG = tp.TypeVar("_T_MSG")
@@ -340,7 +384,7 @@ class ActorNode:
         self.state: ActorState = ActorState.NOT_STARTED
         self.error: tp.Optional[Exception] = None
 
-    def spawn(self, child_actor: Actor):
+    def spawn(self, child_actor: Actor) -> ActorId:
 
         if self._log.isEnabledFor(logging.DEBUG):
             self._log.debug(f"spawn [{self.actor_id}]: [{type(child_actor)}]")
@@ -355,6 +399,11 @@ class ActorNode:
         child_node = ActorNode(child_id, child_actor, self, self.system, event_loop)
         self.children[child_id] = child_node
 
+        # If this is a threadsafe actor, set up the threadsafe context
+        if isinstance(child_actor, ThreadsafeActor):
+            threadsafe = ThreadsafeContext(child_node)
+            child_actor._ThreadsafeActor__threadsafe = threadsafe
+
         child_node.send_signal(self.actor_id, child_id, SignalNames.START)
 
         return child_id
@@ -542,6 +591,12 @@ class ActorNode:
         if not self._check_message_target(signal):
             return
 
+        # Do not process signals after the actor has stopped
+        # This is common with e.g. STOP signals that propagate up and down the tree
+
+        if self.state in [ActorState.STOPPED, ActorState.FAILED]:
+            return
+
         # Call the signal receiver function
         # This gives the actor a chance to respond to the signal
 
@@ -768,10 +823,12 @@ class ActorNode:
         # Positional arg types
         for pos_param, pos_arg in zip(pos_params, args):
 
+            # If no type hint is available, allow anything through
+            # Otherwise, reuse the validator logic to type check individual args
             type_hint = type_hints.get(pos_param.name)
+            type_check = type_hint is None or _val.check_type(type_hint, pos_arg)
 
-            # If no type hint is available, allow anything through
-            if type_hint is not None and not isinstance(pos_arg, type_hint):
+            if not type_check:
                 error = f"Invalid message: [{message}] -> {target_id} (wrong parameter type for '{pos_param.name}')"
                 self._log.error(error)
                 raise EBadActor(error)
@@ -780,20 +837,20 @@ class ActorNode:
         for kw_param in kw_params:
 
             kw_arg = kwargs.get(kw_param.name)
-            type_hint = type_hints.get(kw_param.name)
 
             # If param has taken a default value, no type check is needed
             if kw_arg is None:
                 continue
 
-            # If no type hint is available, allow anything through
-            if type_hint is not None and not isinstance(kw_arg, type_hint):
+            # Otherwise use the same type-validation logic as positional args
+            type_hint = type_hints.get(kw_param.name)
+            type_check = type_hint is None or _val.check_type(type_hint, kw_arg)
+
+            if not type_check:
                 error = f"Invalid message: [{message}] -> {target_id} (wrong parameter type for '{kw_param.name}')"
                 self._log.error(error)
                 raise EBadActor(error)
 
-        # TODO: Verify generics for both args and kwargs
-
 
 class RootActor(Actor):
 
@@ -864,11 +921,17 @@ class ActorSystem:
 
         self.__root_started = threading.Event()
         self.__root_stopped = threading.Event()
+
         self.__root_actor = RootActor(main_actor, self.__root_started, self.__root_stopped)
         self.__root_node = ActorNode(self.ROOT_ID, self.__root_actor, None, self, self.__system_event_loop)
 
     # Public API
 
+    def main_id(self) -> ActorId:
+        if not self.__root_started.is_set():
+            raise EBadActor("System has not started yet")
+        return self.__root_actor.main_id
+
     def start(self, wait=True):
 
         self.__system_thread.start()
@@ -913,12 +976,26 @@ class ActorSystem:
 
         return self.__root_node.error
 
-    def send(self, message: str, *args, **kwargs):
+    def spawn_agent(self, agent: Actor) -> ActorId:
+
+        if not self.__root_started.is_set():
+            raise EBadActor("System has not started yet")
+
+        return self.__root_node.spawn(agent)
+
+    def send_main(self, message: str, *args, **kwargs):
 
         if self.__root_actor.main_id is None:
             raise EBadActor("System has not started yet")
 
-        self.__root_node.send_message("/external", self.__root_actor.main_id, message, args, kwargs)
+        self.__root_node.send_message("/external", self.__root_actor.main_id, message, args, kwargs)  # TODO
+
+    def send(self, actor_id: ActorId, message: str, *args, **kwargs):
+
+        if not self.__root_started.is_set():
+            raise EBadActor("System has not started yet")
+
+        self.__root_node.send_message("/external", actor_id, message, args, kwargs)
 
     def _setup_event_loops(self, thread_pools: tp.Dict[str, int]):
 

{tracdap_runtime-0.6.2 → tracdap_runtime-0.6.3}/src/tracdap/rt/_exec/dev_mode.py

@@ -46,7 +46,7 @@ class DevModeTranslator:
     _log: tp.Optional[_util.logging.Logger] = None
 
     @classmethod
-    def translate_sys_config(cls, sys_config: _cfg.RuntimeConfig, config_dir: tp.Optional[pathlib.Path]):
+    def translate_sys_config(cls, sys_config: _cfg.RuntimeConfig, config_mgr: _cfg_p.ConfigManager):
 
         cls._log.info(f"Applying dev mode config translation to system config")
 
@@ -56,7 +56,7 @@ class DevModeTranslator:
             sys_config.storage = _cfg.StorageConfig()
 
         sys_config = cls._add_integrated_repo(sys_config)
-        sys_config = cls._resolve_relative_storage_root(sys_config, config_dir)
+        sys_config = cls._resolve_relative_storage_root(sys_config, config_mgr)
 
         return sys_config
 
@@ -66,7 +66,7 @@ class DevModeTranslator:
             sys_config: _cfg.RuntimeConfig,
             job_config: _cfg.JobConfig,
             scratch_dir: pathlib.Path,
-            config_dir: tp.Optional[pathlib.Path],
+            config_mgr: _cfg_p.ConfigManager,
             model_class: tp.Optional[_api.TracModel.__class__]) \
             -> _cfg.JobConfig:
 
@@ -84,7 +84,7 @@ class DevModeTranslator:
 
         # Fow flows, load external flow definitions then perform auto-wiring and type inference
         if job_config.job.jobType == _meta.JobType.RUN_FLOW:
-            job_config = cls._process_flow_definition(job_config, config_dir)
+            job_config = cls._process_flow_definition(job_config, config_mgr)
 
         # For run (model|flow) jobs, apply processing to the parameters, inputs and outputs
         if job_config.job.jobType in [_meta.JobType.RUN_MODEL, _meta.JobType.RUN_FLOW]:
@@ -109,7 +109,7 @@ class DevModeTranslator:
     @classmethod
     def _resolve_relative_storage_root(
             cls, sys_config: _cfg.RuntimeConfig,
-            sys_config_path: tp.Optional[pathlib.Path]):
+            config_mgr: _cfg_p.ConfigManager):
 
         storage_config = copy.deepcopy(sys_config.storage)
 
@@ -128,6 +128,7 @@ class DevModeTranslator:
 
             cls._log.info(f"Resolving relative path for [{bucket_key}] local storage...")
 
+            sys_config_path = config_mgr.config_dir_path()
             if sys_config_path is not None:
                 absolute_path = sys_config_path.joinpath(root_path).resolve()
                 if absolute_path.exists():
@@ -291,7 +292,7 @@ class DevModeTranslator:
         return model_id, model_object
 
     @classmethod
-    def _process_flow_definition(cls, job_config: _cfg.JobConfig, config_dir: pathlib.Path) -> _cfg.JobConfig:
+    def _process_flow_definition(cls, job_config: _cfg.JobConfig, config_mgr: _cfg_p.ConfigManager) -> _cfg.JobConfig:
 
         flow_details = job_config.job.runFlow.flow
 
@@ -305,21 +306,12 @@ class DevModeTranslator:
             cls._log.error(err)
             raise _ex.EConfigParse(err)
 
-        flow_path = config_dir.joinpath(flow_details) if config_dir is not None else pathlib.Path(flow_details)
-
-        if not flow_path.exists():
-            err = f"Flow definition not available for [{flow_details}]: File not found ({flow_path})"
-            cls._log.error(err)
-            raise _ex.EConfigParse(err)
-
         flow_id = _util.new_object_id(_meta.ObjectType.FLOW)
         flow_key = _util.object_key(flow_id)
 
-        cls._log.info(f"Generating flow definition for [{flow_details}] with ID = [{flow_key}]")
+        cls._log.info(f"Generating flow definition from [{flow_details}] with ID = [{flow_key}]")
 
-        flow_parser = _cfg_p.ConfigParser(_meta.FlowDefinition)
-        flow_raw_data = flow_parser.load_raw_config(flow_path, flow_path.name)
-        flow_def = flow_parser.parse(flow_raw_data, flow_path.name)
+        flow_def = config_mgr.load_config_object(flow_details, _meta.FlowDefinition)
 
         # Auto-wiring and inference only applied to externally loaded flows for now
         flow_def = cls._autowire_flow(flow_def, job_config)

{tracdap_runtime-0.6.2 → tracdap_runtime-0.6.3}/src/tracdap/rt/_exec/engine.py

@@ -19,6 +19,7 @@ import dataclasses as dc
 import enum
 import typing as tp
 
+import tracdap.rt.metadata as _meta
 import tracdap.rt.config as _cfg
 import tracdap.rt.exceptions as _ex
 import tracdap.rt._exec.actors as _actors
@@ -28,7 +29,6 @@ import tracdap.rt._impl.models as _models  # noqa
 import tracdap.rt._impl.data as _data  # noqa
 import tracdap.rt._impl.storage as _storage  # noqa
 import tracdap.rt._impl.util as _util  # noqa
-from .actors import Signal
 
 from .graph import NodeId
 
@@ -66,6 +66,18 @@ class _EngineContext:
     failed_nodes: tp.Set[NodeId] = dc.field(default_factory=set)
 
 
+@dc.dataclass
+class _JobState:
+
+    job_id: _meta.TagHeader
+    job_config: _cfg.JobConfig
+
+    actor_id: _actors.ActorId = None
+
+    job_result: _cfg.JobResult = None
+    job_error: Exception = None
+
+
 class TracEngine(_actors.Actor):
 
     """
@@ -88,7 +100,7 @@ class TracEngine(_actors.Actor):
         self._storage = storage
         self._notify_callback = notify_callback
 
-        self._job_actors = dict()
+        self._jobs: tp.Dict[str, _JobState] = dict()
 
     def on_start(self):
 
@@ -98,7 +110,7 @@ class TracEngine(_actors.Actor):
 
         self._log.info("Engine shutdown complete")
 
-    def on_signal(self, signal: Signal) -> tp.Optional[bool]:
+    def on_signal(self, signal: _actors.Signal) -> tp.Optional[bool]:
 
         # Failed signals can propagate from leaf nodes up the actor tree for a job
         # If the failure goes all the way up the tree without being handled, it will reach the engine node
@@ -110,8 +122,8 @@ class TracEngine(_actors.Actor):
             failed_job_key = None
 
             # Look for the job key corresponding to the failed actor
-            for job_key, job_actor in self._job_actors.items():
-                if job_actor == signal.sender:
+            for job_key, job_state in self._jobs.items():
+                if job_state.actor_id == signal.sender:
                     failed_job_key = job_key
 
             # If the job is still live, call job_failed explicitly
@@ -147,19 +159,34 @@ class TracEngine(_actors.Actor):
         job_processor = JobProcessor(job_key, job_config, result_spec,self._models, self._storage)
         job_actor_id = self.actors().spawn(job_processor)
 
-        job_actors = {**self._job_actors, job_key: job_actor_id}
-        self._job_actors = job_actors
+        job_state = _JobState(job_config.jobId, job_config)
+        job_state.actor_id = job_actor_id
+
+        self._jobs[job_key] = job_state
+
+    @_actors.Message
+    def get_job_list(self):
+
+        job_list = list(map(self._get_job_info, self._jobs.keys()))
+        self.actors().reply("job_list", job_list)
+
+    @_actors.Message
+    def get_job_details(self, job_key: str, details: bool):
+
+        details = self._get_job_info(job_key, details)
+        self.actors().reply("job_details", details)
 
     @_actors.Message
     def job_succeeded(self, job_key: str, job_result: _cfg.JobResult):
 
         # Ignore duplicate messages from the job processor (can happen in unusual error cases)
-        if job_key not in self._job_actors:
+        if job_key not in self._jobs:
             self._log.warning(f"Ignoring [job_succeeded] message, job [{job_key}] has already completed")
             return
 
         self._log.info(f"Recording job as successful: {job_key}")
 
+        self._jobs[job_key].job_result = job_result
         self._finalize_job(job_key)
 
         if self._notify_callback is not None:
@@ -169,12 +196,13 @@ class TracEngine(_actors.Actor):
     def job_failed(self, job_key: str, error: Exception):
 
         # Ignore duplicate messages from the job processor (can happen in unusual error cases)
-        if job_key not in self._job_actors:
+        if job_key not in self._jobs:
             self._log.warning(f"Ignoring [job_failed] message, job [{job_key}] has already completed")
             return
 
         self._log.error(f"Recording job as failed: {job_key}")
 
+        self._jobs[job_key].job_error = error
         self._finalize_job(job_key)
 
         if self._notify_callback is not None:
@@ -182,10 +210,47 @@ class TracEngine(_actors.Actor):
 
     def _finalize_job(self, job_key: str):
 
-        job_actors = self._job_actors
-        job_actor_id = job_actors.pop(job_key)
-        self.actors().stop(job_actor_id)
-        self._job_actors = job_actors
+        # Stop the actor but keep the job state available for status / results queries
+
+        # In the future, job state will need to be expunged after some period of time
+        # For now each instance of the runtime only processes one job so no need to worry
+
+        job_state = self._jobs.get(job_key)
+        job_actor_id = job_state.actor_id if job_state is not None else None
+
+        if job_actor_id is not None:
+            self.actors().stop(job_actor_id)
+            job_state.actor_id = None
+
+    def _get_job_info(self, job_key: str, details: bool = False) -> tp.Optional[_cfg.JobResult]:
+
+        job_state = self._jobs.get(job_key)
+
+        if job_state is None:
+            return None
+
+        job_result = _cfg.JobResult()
+        job_result.jobId = job_state.job_id
+
+        if job_state.actor_id is not None:
+            job_result.statusCode = _meta.JobStatusCode.RUNNING
+
+        elif job_state.job_result is not None:
+            job_result.statusCode = job_state.job_result.statusCode
+            job_result.statusMessage = job_state.job_result.statusMessage
+            if details:
+                job_result.results = job_state.job_result.results or dict()
+
+        elif job_state.job_error is not None:
+            job_result.statusCode = _meta.JobStatusCode.FAILED
+            job_result.statusMessage = str(job_state.job_error.args[0])
+
+        else:
+            # Alternatively return UNKNOWN status or throw an error here
+            job_result.statusCode = _meta.JobStatusCode.FAILED
+            job_result.statusMessage = "No details available"
+
+        return job_result
 
 
 class JobProcessor(_actors.Actor):
@@ -218,7 +283,7 @@ class JobProcessor(_actors.Actor):
         self._log.info(f"Cleaning up job [{self.job_key}]")
         self._models.destroy_scope(self.job_key)
 
-    def on_signal(self, signal: Signal) -> tp.Optional[bool]:
+    def on_signal(self, signal: _actors.Signal) -> tp.Optional[bool]:
 
         if signal.message == _actors.SignalNames.FAILED and isinstance(signal, _actors.ErrorSignal):