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

tracdap/rt/_impl/config_parser.py

@@ -14,89 +14,216 @@
 
 from __future__ import annotations
 
-import re
-import typing as tp
+import dataclasses as _dc
 import decimal
 import enum
-import uuid
+import io
 import inspect
-import dataclasses as _dc
+import json
+import os
+import pathlib
+import re
+import typing as tp
+import urllib.parse as _urlp
+import uuid
 
+import tracdap.rt.config as _config
 import tracdap.rt.exceptions as _ex
+import tracdap.rt.ext.plugins as _plugins
+import tracdap.rt.ext.config as _config_ext
 import tracdap.rt._impl.util as _util
 
-import pathlib
-import json
 import yaml
 import yaml.parser
 
-
 _T = tp.TypeVar('_T')
 
 
-class ConfigParser(tp.Generic[_T]):
+class ConfigManager:
 
-    # 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])
+    @classmethod
+    def for_root_config(cls, root_config_file: tp.Union[str, pathlib.Path, None]) -> ConfigManager:
+
+        if isinstance(root_config_file, pathlib.Path):
+            root_file_path = cls._resolve_scheme(root_config_file)
+            root_dir_path = cls._resolve_scheme(root_config_file.parent)
+            if root_dir_path[-1] not in ["/", "\\"]:
+                root_dir_path += os.sep
+            root_file_url = _urlp.urlparse(root_file_path, scheme="file")
+            root_dir_url = _urlp.urlparse(root_dir_path, scheme="file")
+            return ConfigManager(root_dir_url, root_file_url, )
+
+        elif isinstance(root_config_file, str):
+            root_file_with_scheme = cls._resolve_scheme(root_config_file)
+            root_file_url = _urlp.urlparse(root_file_with_scheme, scheme="file")
+            root_dir_path = str(pathlib.Path(root_file_url.path).parent)
+            if root_dir_path[-1] not in ["/", "\\"]:
+                root_dir_path += os.sep if root_file_url.scheme == "file" else "/"
+            root_dir_url = _urlp.urlparse(_urlp.urljoin(root_file_url.geturl(), root_dir_path))
+            return ConfigManager(root_dir_url, root_file_url)
 
-    __primitive_types: tp.Dict[type, callable] = {
-        bool: bool,
-        int: int,
-        float: float,
-        str: str,
-        decimal.Decimal: decimal.Decimal
-        # TODO: Date (requires type system)
-        # TODO: Datetime (requires type system)
-    }
+        else:
+            working_dir_path = str(pathlib.Path.cwd().resolve())
+            working_dir_url = _urlp.urlparse(str(working_dir_path), scheme="file")
+            return ConfigManager(working_dir_url, None)
 
-    def __init__(self, config_class: _T.__class__, dev_mode_locations: tp.List[str] = None):
+    @classmethod
+    def for_root_dir(cls, root_config_dir: tp.Union[str, pathlib.Path]) -> ConfigManager:
+
+        if isinstance(root_config_dir, pathlib.Path):
+            root_dir_path = cls._resolve_scheme(root_config_dir)
+            if root_dir_path[-1] not in ["/", "\\"]:
+                root_dir_path += os.sep
+            root_dir_url = _urlp.urlparse(root_dir_path, scheme="file")
+            return ConfigManager(root_dir_url, None)
+
+        elif isinstance(root_config_dir, str):
+            root_dir_with_scheme = cls._resolve_scheme(root_config_dir)
+            if root_dir_with_scheme[-1] not in ["/", "\\"]:
+                root_dir_with_scheme += "/"
+            root_dir_url = _urlp.urlparse(root_dir_with_scheme, scheme="file")
+            return ConfigManager(root_dir_url, None)
+
+        # Should never happen since root dir is specified explicitly
+        else:
+            raise _ex.ETracInternal("Wrong parameter type for root_config_dir")
+
+    @classmethod
+    def _resolve_scheme(cls, raw_url: tp.Union[str, pathlib.Path]) -> str:
+
+        if isinstance(raw_url, pathlib.Path):
+            return "file:" + str(raw_url.resolve())
+
+        # Look for drive letters on Windows - these can be mis-interpreted as URL scheme
+        # If there is a drive letter, explicitly set scheme = file instead
+        if len(raw_url) > 1 and raw_url[1] == ":":
+            return "file:" + raw_url
+        else:
+            return raw_url
+
+    def __init__(self, root_dir_url: _urlp.ParseResult, root_file_url: tp.Optional[_urlp.ParseResult]):
         self._log = _util.logger_for_object(self)
-        self._config_class = config_class
-        self._dev_mode_locations = dev_mode_locations or []
-        self._errors = []
+        self._root_dir_url = root_dir_url
+        self._root_file_url = root_file_url
+
+    def config_dir_path(self):
+        if self._root_dir_url.scheme == "file":
+            return pathlib.Path(self._root_dir_url.path).resolve()
+        else:
+            return None
+
+    def load_root_object(
+            self, config_class: type(_T),
+            dev_mode_locations: tp.List[str] = None,
+            config_file_name: tp.Optional[str] = None) -> _T:
 
-    def load_raw_config(self, config_file: tp.Union[str, pathlib.Path], config_file_name: str = None):
+        # Root config not available normally means you're using embedded config
+        # In which case this method should not be called
+        if self._root_file_url is None:
+            message = f"Root config file not available"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+        resolved_url = self._root_file_url
 
         if config_file_name is not None:
-            self._log.info(f"Loading {config_file_name} config: {str(config_file)}")
+            self._log.info(f"Loading {config_file_name} config: {self._url_to_str(resolved_url)}")
         else:
-            self._log.info(f"Loading config file: {str(config_file)}")
+            self._log.info(f"Loading config file: {self._url_to_str(resolved_url)}")
+
+        config_dict = self._load_config_dict(resolved_url)
 
-        # Construct a Path for config_file and make sure the file exists
-        # (For now, config must be on a locally mounted filesystem)
+        parser = ConfigParser(config_class, dev_mode_locations)
+        return parser.parse(config_dict, resolved_url.path)
 
-        if isinstance(config_file, str):
-            config_path = pathlib.Path(config_file)
+    def load_config_object(
+            self, config_url: tp.Union[str, pathlib.Path],
+            config_class: type(_T),
+            dev_mode_locations: tp.List[str] = None,
+            config_file_name: tp.Optional[str] = None) -> _T:
 
-        elif isinstance(config_file, pathlib.Path):
-            config_path = config_file
+        resolved_url = self._resolve_config_file(config_url)
 
+        if config_file_name is not None:
+            self._log.info(f"Loading {config_file_name} config: {self._url_to_str(resolved_url)}")
         else:
-            config_file_type = type(config_file) if config_file is not None else "None"
-            err = f"Attempt to load an invalid config file, expected a path, got {config_file_type}"
-            self._log.error(err)
-            raise _ex.EConfigLoad(err)
+            self._log.info(f"Loading config file: {self._url_to_str(resolved_url)}")
 
-        if not config_path.exists():
-            msg = f"Config file not found: [{config_file}]"
-            self._log.error(msg)
-            raise _ex.EConfigLoad(msg)
+        config_dict = self._load_config_dict(resolved_url)
 
-        if not config_path.is_file():
-            msg = f"Config path does not point to a regular file: [{config_file}]"
-            self._log.error(msg)
-            raise _ex.EConfigLoad(msg)
+        parser = ConfigParser(config_class, dev_mode_locations)
+        return parser.parse(config_dict, config_url)
 
-        return self._parse_raw_config(config_path)
+    def load_config_file(
+            self, config_url: tp.Union[str, pathlib.Path],
+            config_file_name: tp.Optional[str] = None) -> bytes:
 
-    def _parse_raw_config(self, config_path: pathlib.Path):
+        resolved_url = self._resolve_config_file(config_url)
+
+        if config_file_name is not None:
+            self._log.info(f"Loading {config_file_name} config: {self._url_to_str(resolved_url)}")
+        else:
+            self._log.info(f"Loading config file: {self._url_to_str(resolved_url)}")
+
+        return self._load_config_file(resolved_url)
+
+    def _resolve_config_file(self, config_url: tp.Union[str, pathlib.Path]) -> _urlp.ParseResult:
+
+        # If the config URL defines a scheme, treat it as absolute
+        # (This also works for Windows paths, C:\ is an absolute path)
+        if ":" in str(config_url):
+            absolute_url = str(config_url)
+        # If the root URL is a path, resolve using path logic (this allows for config_url to be an absolute path)
+        elif self._root_dir_url.scheme == "file":
+            absolute_url = str(pathlib.Path(self._root_dir_url.path).joinpath(str(config_url)))
+        # Otherwise resolve relative to the root URL
+        else:
+            absolute_url = _urlp.urljoin(self._root_dir_url.geturl(), str(config_url))
+
+        # Look for drive letters on Windows - these can be mis-interpreted as URL scheme
+        # If there is a drive letter, explicitly set scheme = file instead
+        if len(absolute_url) > 1 and absolute_url[1] == ":":
+            absolute_url = "file:" + absolute_url
+
+        return _urlp.urlparse(absolute_url, scheme="file")
+
+    def _load_config_file(self, resolved_url: _urlp.ParseResult) -> bytes:
+
+        loader = self._get_loader(resolved_url)
+        config_url = self._url_to_str(resolved_url)
+
+        if not loader.has_config_file(config_url):
+            message = f"Config file not found: {config_url}"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+        return loader.load_config_file(config_url)
+
+    def _load_config_dict(self, resolved_url: _urlp.ParseResult) -> dict:
+
+        loader = self._get_loader(resolved_url)
+        config_url = self._url_to_str(resolved_url)
+
+        if loader.has_config_dict(config_url):
+            return loader.load_config_dict(config_url)
+
+        elif loader.has_config_file(config_url):
+            config_bytes = loader.load_config_file(config_url)
+            config_path = pathlib.Path(resolved_url.path)
+            return self._parse_config_dict(config_bytes, config_path)
+
+        else:
+            message = f"Config file not found: {config_url}"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+    def _parse_config_dict(self, config_bytes: bytes, config_path: pathlib.Path):
 
         # Read in the raw config, use the file extension to decide which format to expect
 
         try:
 
-            with config_path.open('r') as config_stream:
+            with io.BytesIO(config_bytes) as config_stream:
 
                 extension = config_path.suffix.lower()
 
@@ -123,11 +250,54 @@ class ConfigParser(tp.Generic[_T]):
             self._log.error(err)
             raise _ex.EConfigParse(err) from e
 
-        except yaml.parser.ParserError as e:
+        except (yaml.parser.ParserError, yaml.reader.ReaderError) as e:
             err = f"Config file contains invalid YAML ({str(e)})"
             self._log.error(err)
             raise _ex.EConfigParse(err) from e
 
+    def _get_loader(self, resolved_url: _urlp.ParseResult) -> _config_ext.IConfigLoader:
+
+        protocol = resolved_url.scheme
+        loader_config = _config.PluginConfig(protocol)
+
+        if not _plugins.PluginManager.is_plugin_available(_config_ext.IConfigLoader, protocol):
+            message = f"No config loader available for protocol [{protocol}]: {self._url_to_str(resolved_url)}"
+            self._log.error(message)
+            raise _ex.EConfigLoad(message)
+
+        return _plugins.PluginManager.load_config_plugin(_config_ext.IConfigLoader, loader_config)
+
+    @staticmethod
+    def _url_to_str(url: _urlp.ParseResult) -> str:
+
+        if url.scheme == "file" and not url.netloc:
+            return url.path
+        else:
+            return url.geturl()
+
+
+class ConfigParser(tp.Generic[_T]):
+
+    # 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])
+
+    __primitive_types: tp.Dict[type, callable] = {
+        bool: bool,
+        int: int,
+        float: float,
+        str: str,
+        decimal.Decimal: decimal.Decimal
+        # TODO: Date (requires type system)
+        # TODO: Datetime (requires type system)
+    }
+
+    def __init__(self, config_class: _T.__class__, dev_mode_locations: tp.List[str] = None):
+        self._log = _util.logger_for_object(self)
+        self._config_class = config_class
+        self._dev_mode_locations = dev_mode_locations or []
+        self._errors = []
+
     def parse(self, config_dict: dict, config_file: tp.Union[str, pathlib.Path] = None) -> _T:
 
         # If config is empty, return a default (blank) config

tracdap/rt/_impl/data.py

@@ -58,6 +58,13 @@ class DataItem:
     pandas: tp.Optional[pd.DataFrame] = None
     pyspark: tp.Any = None
 
+    def is_empty(self) -> bool:
+        return self.table is None and (self.batches is None or len(self.batches) == 0)
+
+    @staticmethod
+    def create_empty() -> DataItem:
+        return DataItem(pa.schema([]))
+
 
 @dc.dataclass(frozen=True)
 class DataView:
@@ -72,6 +79,13 @@ class DataView:
         arrow_schema = DataMapping.trac_to_arrow_schema(trac_schema)
         return DataView(trac_schema, arrow_schema, dict())
 
+    def is_empty(self) -> bool:
+        return self.parts is None or len(self.parts) == 0
+
+    @staticmethod
+    def create_empty() -> DataView:
+        return DataView(_meta.SchemaDefinition(), pa.schema([]), dict())
+
 
 class _DataInternal:
     pass

tracdap/rt/_impl/grpc/__init__.py

@@ -0,0 +1,13 @@
+#  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.

tracdap/rt/_impl/grpc/codec.py

@@ -0,0 +1,99 @@
+#  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 enum
+import typing as tp
+
+import tracdap.rt.exceptions as ex
+import tracdap.rt.metadata as metadata
+
+import tracdap.rt._impl.grpc.tracdap.metadata.type_pb2 as type_pb2
+import tracdap.rt._impl.grpc.tracdap.metadata.object_id_pb2 as object_id_pb2
+import tracdap.rt._impl.grpc.tracdap.metadata.object_pb2 as object_pb2
+from tracdap.rt._impl.grpc.tracdap.metadata import model_pb2
+import tracdap.rt._impl.grpc.tracdap.metadata.data_pb2 as data_pb2
+import tracdap.rt._impl.grpc.tracdap.metadata.stoarge_pb2 as storage_pb2
+
+from google.protobuf import message as _message
+
+
+__METADATA_MAPPING = {
+    metadata.TypeDescriptor: type_pb2.TypeDescriptor,
+    metadata.Value: type_pb2.Value,
+    metadata.DecimalValue: type_pb2.DecimalValue,
+    metadata.DateValue: type_pb2.DateValue,
+    metadata.DatetimeValue: type_pb2.DatetimeValue,
+    metadata.ArrayValue: type_pb2.ArrayValue,
+    metadata.MapValue: type_pb2.MapValue,
+    metadata.TagHeader: object_id_pb2.TagHeader,
+    metadata.TagSelector: object_id_pb2.TagSelector,
+    metadata.ObjectDefinition: object_pb2.ObjectDefinition,
+    metadata.ModelDefinition: model_pb2.ModelDefinition,
+    metadata.ModelParameter: model_pb2.ModelParameter,
+    metadata.ModelInputSchema: model_pb2.ModelInputSchema,
+    metadata.ModelOutputSchema: model_pb2.ModelOutputSchema,
+    metadata.SchemaDefinition: data_pb2.SchemaDefinition,
+    metadata.TableSchema: data_pb2.TableSchema,
+    metadata.FieldSchema: data_pb2.FieldSchema,
+    metadata.PartKey: data_pb2.PartKey,
+    metadata.DataDefinition: data_pb2.DataDefinition,
+    metadata.DataDefinition.Part: data_pb2.DataDefinition.Part,
+    metadata.DataDefinition.Snap: data_pb2.DataDefinition.Snap,
+    metadata.DataDefinition.Delta: data_pb2.DataDefinition.Delta,
+    metadata.StorageDefinition: storage_pb2.StorageDefinition,
+    metadata.StorageIncarnation: storage_pb2.StorageIncarnation,
+    metadata.StorageCopy: storage_pb2.StorageCopy,
+    metadata.StorageItem: storage_pb2.StorageItem
+}
+
+
+_T_MSG = tp.TypeVar('_T_MSG', bound=_message.Message)
+
+
+def encode_message(msg_class: _T_MSG.__class__, obj: tp.Any) -> _T_MSG:
+
+    attrs = dict((k, encode(v)) for k, v in obj.__dict__.items())
+
+    return msg_class(**attrs)
+
+
+def encode(obj: tp.Any) -> tp.Any:
+
+    # Translate TRAC domain objects into generic dict / list structures
+    # These can be accepted by gRPC message constructors, do not try to build messages directly
+    # Use shallow copies and builtins to minimize performance impact
+
+    if obj is None:
+        return None
+
+    if isinstance(obj, str) or isinstance(obj, bool) or isinstance(obj, int) or isinstance(obj, float):
+        return obj
+
+    if isinstance(obj, enum.Enum):
+        return obj.value
+
+    if isinstance(obj, list):
+        return list(map(encode, obj))
+
+    if isinstance(obj, dict):
+        return dict((k, encode(v)) for k, v in obj.items())
+
+    msg_class = __METADATA_MAPPING.get(type(obj))
+
+    if msg_class is None:
+        raise ex.ETracInternal(f"No gRPC metadata mapping is available for type {type(obj).__name__}")
+
+    attrs = dict((k, encode(v)) for k, v in obj.__dict__.items() if v is not None)
+
+    return msg_class(**attrs)

tracdap/rt/_impl/grpc/tracdap/api/internal/runtime_pb2.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tracdap/rt/_impl/grpc/tracdap/api/internal/runtime.proto
+# Protobuf Python Version: 4.25.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from tracdap.rt._impl.grpc.tracdap.metadata import object_id_pb2 as tracdap_dot_rt_dot___impl_dot_grpc_dot_tracdap_dot_metadata_dot_object__id__pb2
+from tracdap.rt._impl.grpc.tracdap.metadata import job_pb2 as tracdap_dot_rt_dot___impl_dot_grpc_dot_tracdap_dot_metadata_dot_job__pb2
+from tracdap.rt._impl.grpc.tracdap.metadata import object_pb2 as tracdap_dot_rt_dot___impl_dot_grpc_dot_tracdap_dot_metadata_dot_object__pb2
+from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n8tracdap/rt/_impl/grpc/tracdap/api/internal/runtime.proto\x12\x14tracdap.api.internal\x1a\x36tracdap/rt/_impl/grpc/tracdap/metadata/object_id.proto\x1a\x30tracdap/rt/_impl/grpc/tracdap/metadata/job.proto\x1a\x33tracdap/rt/_impl/grpc/tracdap/metadata/object.proto\x1a\x1cgoogle/api/annotations.proto\"6\n\x16RuntimeListJobsRequest\x12\x12\n\x05limit\x18\x01 \x01(\rH\x00\x88\x01\x01\x42\x08\n\x06_limit\"O\n\x17RuntimeListJobsResponse\x12\x34\n\x04jobs\x18\x01 \x03(\x0b\x32&.tracdap.api.internal.RuntimeJobStatus\"f\n\x15RuntimeJobInfoRequest\x12\x34\n\x0bjobSelector\x18\x01 \x01(\x0b\x32\x1d.tracdap.metadata.TagSelectorH\x00\x12\x10\n\x06jobKey\x18\x02 \x01(\tH\x00\x42\x05\n\x03job\"\x9f\x01\n\x10RuntimeJobStatus\x12*\n\x05jobId\x18\x01 \x01(\x0b\x32\x1b.tracdap.metadata.TagHeader\x12\x33\n\nstatusCode\x18\x02 \x01(\x0e\x32\x1f.tracdap.metadata.JobStatusCode\x12\x15\n\rstatusMessage\x18\x03 \x01(\t\x12\x13\n\x0b\x65rrorDetail\x18\x04 \x01(\t\"\xa4\x02\n\x10RuntimeJobResult\x12*\n\x05jobId\x18\x01 \x01(\x0b\x32\x1b.tracdap.metadata.TagHeader\x12\x33\n\nstatusCode\x18\x02 \x01(\x0e\x32\x1f.tracdap.metadata.JobStatusCode\x12\x15\n\rstatusMessage\x18\x03 \x01(\t\x12\x44\n\x07results\x18\x04 \x03(\x0b\x32\x33.tracdap.api.internal.RuntimeJobResult.ResultsEntry\x1aR\n\x0cResultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x31\n\x05value\x18\x02 \x01(\x0b\x32\".tracdap.metadata.ObjectDefinition:\x02\x38\x01\x32\x95\x03\n\x0eTracRuntimeApi\x12{\n\x08listJobs\x12,.tracdap.api.internal.RuntimeListJobsRequest\x1a-.tracdap.api.internal.RuntimeListJobsResponse\"\x12\x82\xd3\xe4\x93\x02\x0c\x12\n/list-jobs\x12\x81\x01\n\x0cgetJobStatus\x12+.tracdap.api.internal.RuntimeJobInfoRequest\x1a&.tracdap.api.internal.RuntimeJobStatus\"\x1c\x82\xd3\xe4\x93\x02\x16\x12\x14/job-status/{jobKey}\x12\x81\x01\n\x0cgetJobResult\x12+.tracdap.api.internal.RuntimeJobInfoRequest\x1a&.tracdap.api.internal.RuntimeJobResult\"\x1c\x82\xd3\xe4\x93\x02\x16\x12\x14/job-result/{jobKey}B\"\n\x1eorg.finos.tracdap.api.internalP\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tracdap.rt._impl.grpc.tracdap.api.internal.runtime_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  _globals['DESCRIPTOR']._options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\036org.finos.tracdap.api.internalP\001'
+  _globals['_RUNTIMEJOBRESULT_RESULTSENTRY']._options = None
+  _globals['_RUNTIMEJOBRESULT_RESULTSENTRY']._serialized_options = b'8\001'
+  _globals['_TRACRUNTIMEAPI'].methods_by_name['listJobs']._options = None
+  _globals['_TRACRUNTIMEAPI'].methods_by_name['listJobs']._serialized_options = b'\202\323\344\223\002\014\022\n/list-jobs'
+  _globals['_TRACRUNTIMEAPI'].methods_by_name['getJobStatus']._options = None
+  _globals['_TRACRUNTIMEAPI'].methods_by_name['getJobStatus']._serialized_options = b'\202\323\344\223\002\026\022\024/job-status/{jobKey}'
+  _globals['_TRACRUNTIMEAPI'].methods_by_name['getJobResult']._options = None
+  _globals['_TRACRUNTIMEAPI'].methods_by_name['getJobResult']._serialized_options = b'\202\323\344\223\002\026\022\024/job-result/{jobKey}'
+  _globals['_RUNTIMELISTJOBSREQUEST']._serialized_start=271
+  _globals['_RUNTIMELISTJOBSREQUEST']._serialized_end=325
+  _globals['_RUNTIMELISTJOBSRESPONSE']._serialized_start=327
+  _globals['_RUNTIMELISTJOBSRESPONSE']._serialized_end=406
+  _globals['_RUNTIMEJOBINFOREQUEST']._serialized_start=408
+  _globals['_RUNTIMEJOBINFOREQUEST']._serialized_end=510
+  _globals['_RUNTIMEJOBSTATUS']._serialized_start=513
+  _globals['_RUNTIMEJOBSTATUS']._serialized_end=672
+  _globals['_RUNTIMEJOBRESULT']._serialized_start=675
+  _globals['_RUNTIMEJOBRESULT']._serialized_end=967
+  _globals['_RUNTIMEJOBRESULT_RESULTSENTRY']._serialized_start=885
+  _globals['_RUNTIMEJOBRESULT_RESULTSENTRY']._serialized_end=967
+  _globals['_TRACRUNTIMEAPI']._serialized_start=970
+  _globals['_TRACRUNTIMEAPI']._serialized_end=1375
+# @@protoc_insertion_point(module_scope)

tracdap/rt/_impl/grpc/tracdap/api/internal/runtime_pb2.pyi

@@ -0,0 +1,61 @@
+from tracdap.rt._impl.grpc.tracdap.metadata import object_id_pb2 as _object_id_pb2
+from tracdap.rt._impl.grpc.tracdap.metadata import job_pb2 as _job_pb2
+from tracdap.rt._impl.grpc.tracdap.metadata import object_pb2 as _object_pb2
+from google.api import annotations_pb2 as _annotations_pb2
+from google.protobuf.internal import containers as _containers
+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 RuntimeListJobsRequest(_message.Message):
+    __slots__ = ("limit",)
+    LIMIT_FIELD_NUMBER: _ClassVar[int]
+    limit: int
+    def __init__(self, limit: _Optional[int] = ...) -> None: ...
+
+class RuntimeListJobsResponse(_message.Message):
+    __slots__ = ("jobs",)
+    JOBS_FIELD_NUMBER: _ClassVar[int]
+    jobs: _containers.RepeatedCompositeFieldContainer[RuntimeJobStatus]
+    def __init__(self, jobs: _Optional[_Iterable[_Union[RuntimeJobStatus, _Mapping]]] = ...) -> None: ...
+
+class RuntimeJobInfoRequest(_message.Message):
+    __slots__ = ("jobSelector", "jobKey")
+    JOBSELECTOR_FIELD_NUMBER: _ClassVar[int]
+    JOBKEY_FIELD_NUMBER: _ClassVar[int]
+    jobSelector: _object_id_pb2.TagSelector
+    jobKey: str
+    def __init__(self, jobSelector: _Optional[_Union[_object_id_pb2.TagSelector, _Mapping]] = ..., jobKey: _Optional[str] = ...) -> None: ...
+
+class RuntimeJobStatus(_message.Message):
+    __slots__ = ("jobId", "statusCode", "statusMessage", "errorDetail")
+    JOBID_FIELD_NUMBER: _ClassVar[int]
+    STATUSCODE_FIELD_NUMBER: _ClassVar[int]
+    STATUSMESSAGE_FIELD_NUMBER: _ClassVar[int]
+    ERRORDETAIL_FIELD_NUMBER: _ClassVar[int]
+    jobId: _object_id_pb2.TagHeader
+    statusCode: _job_pb2.JobStatusCode
+    statusMessage: str
+    errorDetail: str
+    def __init__(self, jobId: _Optional[_Union[_object_id_pb2.TagHeader, _Mapping]] = ..., statusCode: _Optional[_Union[_job_pb2.JobStatusCode, str]] = ..., statusMessage: _Optional[str] = ..., errorDetail: _Optional[str] = ...) -> None: ...
+
+class RuntimeJobResult(_message.Message):
+    __slots__ = ("jobId", "statusCode", "statusMessage", "results")
+    class ResultsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: _object_pb2.ObjectDefinition
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_object_pb2.ObjectDefinition, _Mapping]] = ...) -> None: ...
+    JOBID_FIELD_NUMBER: _ClassVar[int]
+    STATUSCODE_FIELD_NUMBER: _ClassVar[int]
+    STATUSMESSAGE_FIELD_NUMBER: _ClassVar[int]
+    RESULTS_FIELD_NUMBER: _ClassVar[int]
+    jobId: _object_id_pb2.TagHeader
+    statusCode: _job_pb2.JobStatusCode
+    statusMessage: str
+    results: _containers.MessageMap[str, _object_pb2.ObjectDefinition]
+    def __init__(self, jobId: _Optional[_Union[_object_id_pb2.TagHeader, _Mapping]] = ..., statusCode: _Optional[_Union[_job_pb2.JobStatusCode, str]] = ..., statusMessage: _Optional[str] = ..., results: _Optional[_Mapping[str, _object_pb2.ObjectDefinition]] = ...) -> None: ...