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

tracdap/rt/_impl/grpc/tracdap/metadata/type_pb2.pyi

@@ -0,0 +1,101 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+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 BasicType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    BASIC_TYPE_NOT_SET: _ClassVar[BasicType]
+    BOOLEAN: _ClassVar[BasicType]
+    INTEGER: _ClassVar[BasicType]
+    FLOAT: _ClassVar[BasicType]
+    STRING: _ClassVar[BasicType]
+    DECIMAL: _ClassVar[BasicType]
+    DATE: _ClassVar[BasicType]
+    DATETIME: _ClassVar[BasicType]
+    ARRAY: _ClassVar[BasicType]
+    MAP: _ClassVar[BasicType]
+BASIC_TYPE_NOT_SET: BasicType
+BOOLEAN: BasicType
+INTEGER: BasicType
+FLOAT: BasicType
+STRING: BasicType
+DECIMAL: BasicType
+DATE: BasicType
+DATETIME: BasicType
+ARRAY: BasicType
+MAP: BasicType
+
+class TypeDescriptor(_message.Message):
+    __slots__ = ("basicType", "arrayType", "mapType")
+    BASICTYPE_FIELD_NUMBER: _ClassVar[int]
+    ARRAYTYPE_FIELD_NUMBER: _ClassVar[int]
+    MAPTYPE_FIELD_NUMBER: _ClassVar[int]
+    basicType: BasicType
+    arrayType: TypeDescriptor
+    mapType: TypeDescriptor
+    def __init__(self, basicType: _Optional[_Union[BasicType, str]] = ..., arrayType: _Optional[_Union[TypeDescriptor, _Mapping]] = ..., mapType: _Optional[_Union[TypeDescriptor, _Mapping]] = ...) -> None: ...
+
+class DecimalValue(_message.Message):
+    __slots__ = ("decimal",)
+    DECIMAL_FIELD_NUMBER: _ClassVar[int]
+    decimal: str
+    def __init__(self, decimal: _Optional[str] = ...) -> None: ...
+
+class DateValue(_message.Message):
+    __slots__ = ("isoDate",)
+    ISODATE_FIELD_NUMBER: _ClassVar[int]
+    isoDate: str
+    def __init__(self, isoDate: _Optional[str] = ...) -> None: ...
+
+class DatetimeValue(_message.Message):
+    __slots__ = ("isoDatetime",)
+    ISODATETIME_FIELD_NUMBER: _ClassVar[int]
+    isoDatetime: str
+    def __init__(self, isoDatetime: _Optional[str] = ...) -> None: ...
+
+class Value(_message.Message):
+    __slots__ = ("type", "booleanValue", "integerValue", "floatValue", "stringValue", "decimalValue", "dateValue", "datetimeValue", "arrayValue", "mapValue")
+    TYPE_FIELD_NUMBER: _ClassVar[int]
+    BOOLEANVALUE_FIELD_NUMBER: _ClassVar[int]
+    INTEGERVALUE_FIELD_NUMBER: _ClassVar[int]
+    FLOATVALUE_FIELD_NUMBER: _ClassVar[int]
+    STRINGVALUE_FIELD_NUMBER: _ClassVar[int]
+    DECIMALVALUE_FIELD_NUMBER: _ClassVar[int]
+    DATEVALUE_FIELD_NUMBER: _ClassVar[int]
+    DATETIMEVALUE_FIELD_NUMBER: _ClassVar[int]
+    ARRAYVALUE_FIELD_NUMBER: _ClassVar[int]
+    MAPVALUE_FIELD_NUMBER: _ClassVar[int]
+    type: TypeDescriptor
+    booleanValue: bool
+    integerValue: int
+    floatValue: float
+    stringValue: str
+    decimalValue: DecimalValue
+    dateValue: DateValue
+    datetimeValue: DatetimeValue
+    arrayValue: ArrayValue
+    mapValue: MapValue
+    def __init__(self, type: _Optional[_Union[TypeDescriptor, _Mapping]] = ..., booleanValue: bool = ..., integerValue: _Optional[int] = ..., floatValue: _Optional[float] = ..., stringValue: _Optional[str] = ..., decimalValue: _Optional[_Union[DecimalValue, _Mapping]] = ..., dateValue: _Optional[_Union[DateValue, _Mapping]] = ..., datetimeValue: _Optional[_Union[DatetimeValue, _Mapping]] = ..., arrayValue: _Optional[_Union[ArrayValue, _Mapping]] = ..., mapValue: _Optional[_Union[MapValue, _Mapping]] = ...) -> None: ...
+
+class ArrayValue(_message.Message):
+    __slots__ = ("items",)
+    ITEMS_FIELD_NUMBER: _ClassVar[int]
+    items: _containers.RepeatedCompositeFieldContainer[Value]
+    def __init__(self, items: _Optional[_Iterable[_Union[Value, _Mapping]]] = ...) -> None: ...
+
+class MapValue(_message.Message):
+    __slots__ = ("entries",)
+    class EntriesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+    ENTRIES_FIELD_NUMBER: _ClassVar[int]
+    entries: _containers.MessageMap[str, Value]
+    def __init__(self, entries: _Optional[_Mapping[str, Value]] = ...) -> None: ...

tracdap/rt/_impl/guard_rails.py

@@ -258,14 +258,13 @@ class PythonGuardRails:
     @classmethod
     def is_debug(cls):
 
-        get_trace_func = getattr(sys, 'gettrace', None)
+        has_trace = hasattr(sys, 'gettrace') and sys.gettrace() is not None
+        has_breakpoint = sys.breakpointhook.__module__ != "sys"
 
-        if get_trace_func is None:
-            return False
+        if has_trace or has_breakpoint:
+            return True
 
-        else:
-            trace = get_trace_func()
-            return trace is not None
+        return False
 
     @classmethod
     def is_import(cls):

tracdap/rt/_impl/static_api.py

@@ -147,22 +147,26 @@ class StaticApiImpl(_StaticApiHook):
         return _schemas.SchemaLoader.load_schema(package, schema_file)
 
     def define_input_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]], label: _tp.Optional[str] = None) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            optional: bool = False) \
             -> _meta.ModelInputSchema:
 
-        _val.validate_signature(self.define_input_table, *fields, label=label)
+        _val.validate_signature(self.define_input_table, *fields, label=label, optional=optional)
 
         schema_def = self.define_schema(*fields, schema_type=_meta.SchemaType.TABLE)
-        return _meta.ModelInputSchema(schema=schema_def, label=label)
+        return _meta.ModelInputSchema(schema=schema_def, label=label, optional=optional)
 
     def define_output_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]], label: _tp.Optional[str] = None) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            optional: bool = False) \
             -> _meta.ModelOutputSchema:
 
-        _val.validate_signature(self.define_output_table, *fields, label=label)
+        _val.validate_signature(self.define_output_table, *fields, label=label, optional=optional)
 
         schema_def = self.define_schema(*fields, schema_type=_meta.SchemaType.TABLE)
-        return _meta.ModelOutputSchema(schema=schema_def, label=label)
+        return _meta.ModelOutputSchema(schema=schema_def, label=label, optional=optional)
 
     @staticmethod
     def _build_named_dict(

tracdap/rt/_version.py

@@ -12,4 +12,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-__version__ = "0.6.1.dev3"
+__version__ = "0.6.2"

tracdap/rt/api/hook.py

@@ -119,14 +119,18 @@ class _StaticApiHook:
 
     @_abc.abstractmethod
     def define_input_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]], label: _tp.Optional[str] = None) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            optional: bool = False) \
             -> _meta.ModelInputSchema:
 
         pass
 
     @_abc.abstractmethod
     def define_output_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]], label: _tp.Optional[str] = None) \
+            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
+            label: _tp.Optional[str] = None,
+            optional: bool = False) \
             -> _meta.ModelOutputSchema:
 
         pass

tracdap/rt/api/model_api.py

@@ -72,6 +72,28 @@ class TracContext:
 
         pass
 
+    @_abc.abstractmethod
+    def has_dataset(self, dataset_name: str) -> bool:
+
+        """
+        Check whether a dataset is available in the current context
+
+        This method can be used to check whether optional model inputs have been supplied or not.
+        Models should use this method before calling get methods on optional inputs.
+        For inputs not marked as optional, this method will always return true. For outputs,
+        this method will return true after the model calls a put method for the dataset.
+
+        A runtime validation error will be raised if the dataset name is not defined
+        as a model input or output.
+
+        :param dataset_name: The name of the dataset to check
+        :return: True if the dataset exists in the current context, False otherwise
+        :rtype: bool
+        :raises: :py:class:`ERuntimeValidation <tracdap.rt.exceptions.ERuntimeValidation>`
+        """
+
+        pass
+
     @_abc.abstractmethod
     def get_schema(self, dataset_name: str) -> SchemaDefinition:
 

tracdap/rt/api/static_api.py

@@ -427,7 +427,9 @@ def load_schema(
 
 
 def define_input_table(
-        *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]], label: _tp.Optional[str] = None) \
+        *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]],
+        label: _tp.Optional[str] = None,
+        optional: bool = False) \
         -> ModelInputSchema:
 
     """
@@ -438,15 +440,18 @@ def define_input_table(
 
     :param fields: A set of fields to make up a :py:class:`TableSchema <tracdap.rt.metadata.TableSchema>`
     :param label: An optional label (of type str) for a model input schema. Default value: None.
+    :param optional: Mark this input as an optional model input
     :return: A model input schema, suitable for returning from :py:meth:`TracModel.define_inputs`
 
     :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
                   List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
+    :type label: _tp.Optional[str]
+    :type optional: bool
     :rtype: :py:class:`ModelInputSchema <tracdap.rt.metadata.ModelInputSchema>`
     """
 
     sa = _StaticApiHook.get_instance()
-    return sa.define_input_table(*fields, label=label)
+    return sa.define_input_table(*fields, label=label, optional=optional)
 
 
 def declare_input_table(
@@ -466,7 +471,9 @@ def declare_input_table(
 
 
 def define_output_table(
-        *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]], label: _tp.Optional[str] = None) \
+        *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]],
+        label: _tp.Optional[str] = None,
+        optional: bool = False) \
         -> ModelOutputSchema:
 
     """
@@ -477,15 +484,18 @@ def define_output_table(
 
     :param fields: A set of fields to make up a :py:class:`TableSchema <tracdap.rt.metadata.TableSchema>`
     :param label: An optional label (of type str) for a model output schema. Default value: None.
+    :param optional: Mark this output as an optional model output
     :return: A model output schema, suitable for returning from :py:meth:`TracModel.define_outputs`
 
     :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
                   List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
+    :type label: _tp.Optional[str]
+    :type optional: bool
     :rtype: :py:class:`ModelOutputSchema <tracdap.rt.metadata.ModelOutputSchema>`
     """
 
     sa = _StaticApiHook.get_instance()
-    return sa.define_output_table(*fields, label=label)
+    return sa.define_output_table(*fields, label=label, optional=optional)
 
 
 def declare_output_table(

tracdap/rt/config/__init__.py

@@ -9,6 +9,9 @@ from .common import StorageConfig
 from .runtime import RuntimeConfig
 from .runtime import SparkSettings
 
+from .result import TagUpdateList
+from .result import JobResult
+
 from .platform import RoutingProtocol
 from .platform import DeploymentLayout
 from .platform import PlatformConfig
@@ -24,7 +27,4 @@ from .platform import RoutingTarget
 from .platform import ServiceConfig
 from .platform import DeploymentConfig
 
-from .result import TagUpdateList
-from .result import JobResult
-
 from .job import JobConfig

tracdap/rt/config/platform.py

@@ -11,26 +11,26 @@ from .common import *  # noqa
 
 class RoutingProtocol(_enum.Enum):
 
-    PROTOCOL_NOT_SET = 0, 
+    PROTOCOL_NOT_SET = 0
 
-    HTTP = 1, 
+    HTTP = 1
 
-    GRPC = 2, 
+    GRPC = 2
 
-    GRPC_WEB = 3, 
+    GRPC_WEB = 3
 
-    REST = 4, 
+    REST = 4
 
 
 class DeploymentLayout(_enum.Enum):
 
-    LAYOUT_NOT_SET = 0, 
+    LAYOUT_NOT_SET = 0
 
-    SANDBOX = 1, 
+    SANDBOX = 1
 
-    HOSTED = 2, 
+    HOSTED = 2
 
-    CUSTOM = 3, 
+    CUSTOM = 3
 
 
 @_dc.dataclass

tracdap/rt/launch/cli.py

@@ -16,7 +16,7 @@ import argparse
 import pathlib
 
 
-def cli_args():
+def _cli_args():
 
     parser = argparse.ArgumentParser(
         prog="python -m tracdap.rt.launch",
@@ -45,12 +45,10 @@ def cli_args():
     parser.add_argument(
         "--scratch-dir", dest="scratch_dir", type=pathlib.Path, required=False,
         help="Scratch directory for working files" +
-             " (if not supplied the system's temp location will be used)"
-    )
+             " (if not supplied the system's temp location will be used)")
 
     parser.add_argument(
         "--scratch-dir-persist", dest="scratch_dir_persist", default=False, action="store_true",
-        help="Do not clean up the scratch location on exit"
-    )
+        help="Do not clean up the scratch location on exit")
 
     return parser.parse_args()

tracdap/rt/launch/launch.py

@@ -23,7 +23,7 @@ import tracdap.rt._impl.config_parser as _cparse  # noqa
 import tracdap.rt._impl.util as _util  # noqa
 import tracdap.rt._exec.runtime as _runtime  # noqa
 
-from .cli import cli_args
+from .cli import _cli_args
 
 
 def _resolve_config_file(
@@ -59,7 +59,7 @@ def launch_model(
         sys_config: _tp.Union[str, _pathlib.Path]):
 
     """
-    Launch an individual model component by class (embedded launch)
+    Launch an individual model using its Python class
 
     This launch method launches the supplied model class directly, it must be called
     from the Python codebase containing the model class. The TRAC runtime will launch
@@ -100,6 +100,14 @@ def launch_job(
         sys_config: _tp.Union[str, _pathlib.Path],
         dev_mode: bool = False):
 
+    """
+    Launch a TRAC job using external configuration files
+
+    :param job_config: Path to the job configuration file
+    :param sys_config: Path to the system configuration file
+    :param dev_mode: Whether to launch in dev mode (applies dev mode translation to the job inputs)
+    """
+
     _sys_config = _resolve_config_file(sys_config, None)
     _job_config = _resolve_config_file(job_config, None)
 
@@ -115,7 +123,11 @@ def launch_job(
 
 def launch_cli():
 
-    launch_args = cli_args()
+    """
+    Launch the TRAC runtime using the command line interface
+    """
+
+    launch_args = _cli_args()
 
     _sys_config = _resolve_config_file(launch_args.sys_config, None)
     _job_config = _resolve_config_file(launch_args.job_config, None)

tracdap/rt/metadata/__init__.py

@@ -1,11 +1,5 @@
 # Code generated by TRAC
 
-from .custom import CustomDefinition
-
-from .common import MetadataFormat
-from .common import MetadataVersion
-from .common import TenantInfo
-
 from .type import BasicType
 from .type import TypeDescriptor
 from .type import DecimalValue
@@ -21,8 +15,7 @@ from .object_id import TagSelector
 
 from .file import FileDefinition
 
-from .tag_update import TagOperation
-from .tag_update import TagUpdate
+from .custom import CustomDefinition
 
 from .data import SchemaType
 from .data import PartType
@@ -37,6 +30,9 @@ from .model import ModelInputSchema
 from .model import ModelOutputSchema
 from .model import ModelDefinition
 
+from .tag_update import TagOperation
+from .tag_update import TagUpdate
+
 from .search import SearchOperator
 from .search import LogicalOperator
 from .search import SearchTerm
@@ -50,13 +46,6 @@ from .flow import FlowSocket
 from .flow import FlowEdge
 from .flow import FlowDefinition
 
-from .stoarge import CopyStatus
-from .stoarge import IncarnationStatus
-from .stoarge import StorageCopy
-from .stoarge import StorageIncarnation
-from .stoarge import StorageItem
-from .stoarge import StorageDefinition
-
 from .job import JobType
 from .job import JobStatusCode
 from .job import JobDefinition
@@ -64,6 +53,17 @@ from .job import RunModelJob
 from .job import RunFlowJob
 from .job import ImportModelJob
 
+from .stoarge import CopyStatus
+from .stoarge import IncarnationStatus
+from .stoarge import StorageCopy
+from .stoarge import StorageIncarnation
+from .stoarge import StorageItem
+from .stoarge import StorageDefinition
+
 from .object import ObjectDefinition
 
 from .tag import Tag
+
+from .common import MetadataFormat
+from .common import MetadataVersion
+from .common import TenantInfo

tracdap/rt/metadata/common.py

@@ -14,13 +14,13 @@ class MetadataFormat(_enum.Enum):
     metadata stored in the metadata database.
     """
 
-    METADATA_FORMAT_NOT_SET = 0, 
+    METADATA_FORMAT_NOT_SET = 0
 
-    PROTO = 1, 
+    PROTO = 1
 
-    JSON = 2, 
+    JSON = 2
 
-    YAML = 3, 
+    YAML = 3
 
 
 class MetadataVersion(_enum.Enum):
@@ -37,11 +37,11 @@ class MetadataVersion(_enum.Enum):
     or to run upgrades of metadata stored in an older metadata format.
     """
 
-    METADATA_VERSION_NOT_SET = 0, 
+    METADATA_VERSION_NOT_SET = 0
 
-    V1 = 1, 
+    V1 = 1
 
-    CURRENT = 1, 
+    CURRENT = 1
 
 
 @_dc.dataclass

tracdap/rt/metadata/custom.py

@@ -9,6 +9,8 @@ import enum as _enum  # noqa
 @_dc.dataclass
 class CustomDefinition:
 
+    """Define a custom object that can be stored and managed in the TRAC metadata store"""
+
     customSchemaType: str = None
 
     customSchemaVersion: int = None

tracdap/rt/metadata/data.py

@@ -20,23 +20,40 @@ class SchemaType(_enum.Enum):
         :class:`SchemaDefinition <SchemaDefinition>`
     """
 
-    SCHEMA_TYPE_NOT_SET = 0, 
+    SCHEMA_TYPE_NOT_SET = 0
 
-    TABLE = 1, 
+    TABLE = 1
+
+    """Tabular data"""
 
 
 class PartType(_enum.Enum):
 
-    PART_ROOT = 0, 
+    """Partitioning scheme applied to a dataset"""
+
+    PART_ROOT = 0
+
+    """Dataset has a single partition called the root partition (this is the default)"""
+
+    PART_BY_RANGE = 1
 
-    PART_BY_RANGE = 1, 
+    """Partition by range over an ordered variable (not available yet)"""
 
-    PART_BY_VALUE = 2, 
+    PART_BY_VALUE = 2
+
+    """Partition by value over a categorical variable (not available yet)"""
 
 
 @_dc.dataclass
 class FieldSchema:
 
+    """
+    Schema for an individual field in a tabular dataset
+    
+    .. seealso::
+        :class:`TableSchema <TableSchema>`
+    """
+
     fieldName: str = None
 
     fieldOrder: int = None
@@ -59,6 +76,8 @@ class FieldSchema:
 @_dc.dataclass
 class TableSchema:
 
+    """Schema for a tabular dataset"""
+
     fields: _tp.List[FieldSchema] = _dc.field(default_factory=list)
 
 
@@ -89,6 +108,8 @@ class SchemaDefinition:
 @_dc.dataclass
 class PartKey:
 
+    """Partition key for tabular datasets"""
+
     opaqueKey: str = None
 
     partType: PartType = PartType.PART_ROOT
@@ -103,6 +124,8 @@ class PartKey:
 @_dc.dataclass
 class DataDefinition:
 
+    """Define a dataset that can be stored and managed in the TRAC platform"""
+
     @_dc.dataclass
     class Delta:
 

tracdap/rt/metadata/file.py

@@ -12,6 +12,8 @@ from .object_id import *  # noqa
 @_dc.dataclass
 class FileDefinition:
 
+    """Describes a file object stored in the TRAC platform"""
+
     name: str = None
 
     extension: str = None