tracdap-runtime 0.9.0b1__py3-none-any.whl → 0.9.0b2__py3-none-any.whl

tracdap/rt/_impl/core/struct.py

@@ -37,6 +37,12 @@ import tracdap.rt._impl.core.type_system as _meta_types
 
 class StructProcessor:
 
+    JSON_FORMAT = "text/json"
+    JSON_ALT_FORMATS = ["json", ".json"]
+
+    YAML_FORMAT = "text/yaml"
+    YAML_ALT_FORMATS = ["yaml", ".yaml", "yml"]
+
     __primitive_types: dict[type, _meta.BasicType] = {
         bool: _meta.BasicType.BOOLEAN,
         int: _meta.BasicType.INTEGER,
@@ -68,13 +74,16 @@ class StructProcessor:
 
 
     @classmethod
-    def define_struct(cls, python_type: type) -> _meta.StructSchema:
+    def define_struct(cls, python_type: type) -> _meta.SchemaDefinition:
+
+        named_types = dict()
+        named_enums = dict()
 
         if _dc.is_dataclass(python_type):
-            return cls._define_struct_for_dataclass(python_type)
+            return cls._define_struct_for_dataclass(python_type, named_types, named_enums, type_stack=[])
 
         if _pyd and issubclass(python_type, _pyd.BaseModel):
-            return cls._define_struct_for_pydantic(python_type)
+            return cls._define_struct_for_pydantic(python_type, named_types, named_enums, type_stack=[])
 
         raise _ex.EUnexpected()
 
@@ -83,10 +92,10 @@ class StructProcessor:
 
         try:
 
-            if src_format == "yaml" or src_format == "yml":
+            if src_format == cls.YAML_FORMAT or src_format.lower() in cls.YAML_ALT_FORMATS:
                 config_dict = _yaml.safe_load(src)
 
-            elif src_format == "json":
+            elif src_format == cls.JSON_FORMAT or src_format.lower() in cls.JSON_ALT_FORMATS:
                 config_dict = _json.load(src)
 
             else:
@@ -113,111 +122,297 @@ class StructProcessor:
         StructQuoter.quote(struct, dst, dst_format)
 
     @classmethod
-    def parse_struct(cls, data: dict, schema: _meta.StructSchema = None, python_type: type = None) -> object:
+    def parse_struct(cls, data: dict, schema: _meta.SchemaDefinition = None, python_type: type = None) -> object:
 
         parser = StructParser()
         return parser.parse(python_type, data)
 
     @classmethod
-    def _define_struct_for_dataclass(cls, python_type: _dc.dataclass) -> _meta.StructSchema:
+    def _define_struct_for_dataclass(
+            cls, python_type: _dc.dataclass,
+            named_types: _tp.Dict[str, _meta.SchemaDefinition],
+            named_enums: _tp.Dict[str, _meta.EnumValues],
+            type_stack: _tp.List[str]) \
+            -> _meta.SchemaDefinition:
 
-        type_hints = _tp.get_type_hints(python_type)
-        trac_fields = dict()
+        try:
 
-        for dc_field in _dc.fields(python_type):
+            type_stack.append(cls._qualified_type_name(python_type))
 
-            field_name = dc_field.name
-            python_type = type_hints[field_name]
+            type_hints = _tp.get_type_hints(python_type)
+            trac_fields = list()
+
+            for field_index, dc_field in enumerate(_dc.fields(python_type)):
 
-            trac_field = cls._define_field(python_type, dc_field=dc_field)
-            trac_fields[field_name] = trac_field
+                field_name = dc_field.name
+                python_type = type_hints[field_name]
 
-        return _meta.StructSchema(fields=trac_fields)
+                trac_field = cls._define_field(
+                    field_name, field_index, python_type, dc_field=dc_field,
+                    named_types=named_types, named_enums=named_enums, type_stack=type_stack)
+
+                trac_fields.append(trac_field)
+
+            if len(type_stack) == 1:
+                return _meta.SchemaDefinition(
+                    schemaType=_meta.SchemaType.STRUCT_SCHEMA, fields=trac_fields,
+                    namedTypes=named_types, namedEnums=named_enums)
+            else:
+                return _meta.SchemaDefinition(
+                    schemaType=_meta.SchemaType.STRUCT_SCHEMA, fields=trac_fields)
+
+        finally:
+
+            type_stack.pop()
 
     @classmethod
-    def _define_struct_for_pydantic(cls, python_type: "type[_pyd.BaseModel]") -> _meta.StructSchema:
+    def _define_struct_for_pydantic(
+            cls, python_type: "type[_pyd.BaseModel]",
+            named_types: _tp.Dict[str, _meta.SchemaDefinition],
+            named_enums: _tp.Dict[str, _meta.EnumValues],
+            type_stack: _tp.List[str]) \
+            -> _meta.SchemaDefinition:
 
-        type_hints = _tp.get_type_hints(python_type)
-        trac_fields = dict()
+        try:
 
-        for field_name, pyd_field in python_type.model_fields.items():
+            type_stack.append(cls._qualified_type_name(python_type))
+
+            type_hints = _tp.get_type_hints(python_type)
+            trac_fields = list()
+
+            field_index = 0
+
+            for field_name, pyd_field in python_type.model_fields.items():
 
-            python_type = type_hints[field_name]
+                python_type = type_hints[field_name]
 
-            trac_field = cls._define_field(python_type, pyd_field=pyd_field)
+                trac_field = cls._define_field(
+                    field_name, field_index, python_type, pyd_field=pyd_field,
+                    named_types=named_types, named_enums=named_enums, type_stack=type_stack)
+
+                if trac_field is not None:
+                    trac_fields.append(trac_field)
+                    field_index += 1
+
+            if len(type_stack) == 1:
+                return _meta.SchemaDefinition(
+                    schemaType=_meta.SchemaType.STRUCT_SCHEMA, fields=trac_fields,
+                    namedTypes=named_types, namedEnums=named_enums)
+            else:
+                return _meta.SchemaDefinition(
+                    schemaType=_meta.SchemaType.STRUCT_SCHEMA, fields=trac_fields)
 
-            if trac_field is not None:
-                trac_fields[field_name] = trac_field
+        finally:
 
-        return _meta.StructSchema(fields=trac_fields)
+            type_stack.pop()
 
     @classmethod
     def _define_field(
-            cls, python_type: type, *,
-            dc_field: _dc.Field = None,
-            pyd_field: "_pyd.fields.FieldInfo" = None) \
-            -> _meta.StructField:
+            cls, name, index, python_type: type, optional=False, *,
+            named_types: _tp.Dict[str, _meta.SchemaDefinition],
+            named_enums: _tp.Dict[str, _meta.EnumValues],
+            type_stack: _tp.List[str],
+            dc_field: _dc.Field = None, pyd_field: "_pyd.fields.FieldInfo" = None) \
+            -> _meta.FieldSchema:
 
         if python_type in cls.__primitive_types:
-            return cls._define_primitive_field(python_type, dc_field=dc_field, pyd_field=pyd_field)
+
+            return cls._define_primitive_field(
+                name, index, python_type, optional,
+                dc_field=dc_field, pyd_field=pyd_field)
 
         elif any(map(lambda _t: isinstance(python_type, _t), cls.__generic_types)):
-            return cls._define_generic_field(python_type, pyd_field=pyd_field)
 
-        elif dc_field is not None and _dc.is_dataclass(python_type):
-            pass
+            return cls._define_generic_field(
+                name, index, python_type,
+                dc_field=dc_field, pyd_field=pyd_field,
+                named_types=named_types, named_enums=named_enums,
+                type_stack=type_stack)
+
+        elif isinstance(python_type, _enum.EnumMeta):
+
+            type_name = cls._qualified_type_name(python_type)
+
+            if type_name not in named_enums:
+                enum_values = cls._define_enum_values(python_type)
+                named_enums[type_name] = enum_values
+
+            return cls._define_enum_field(
+                name, index, python_type, optional,
+                dc_field=dc_field, pyd_field=pyd_field)
+
+        elif _dc.is_dataclass(python_type):
 
-        elif pyd_field is not None and issubclass(python_type, _pyd.BaseModel):
-            pass
+            type_name = cls._qualified_type_name(python_type)
+
+            if type_name in type_stack:
+                raise _ex.EValidation("Recursive types are not supported")
+
+            if type_name not in named_types:
+                struct_type = cls._define_struct_for_dataclass(python_type, named_types, named_enums, type_stack)
+                named_types[type_name] = struct_type
+
+            return _meta.FieldSchema(
+                fieldName=name,
+                fieldOrder=index,
+                fieldType=_meta.BasicType.STRUCT,
+                notNull=not optional,
+                namedType=type_name)
+
+        elif issubclass(python_type, _pyd.BaseModel):
+
+            type_name = cls._qualified_type_name(python_type)
+
+            if type_name in type_stack:
+                raise _ex.EValidation("Recursive types are not supported")
+
+            if type_name not in named_types:
+                struct_type = cls._define_struct_for_pydantic(python_type, named_types, named_enums, type_stack)
+                named_types[type_name] = struct_type
+
+            return _meta.FieldSchema(
+                fieldName=name,
+                fieldOrder=index,
+                fieldType=_meta.BasicType.STRUCT,
+                notNull=not optional,
+                namedType=type_name)
 
         else:
             raise _ex.ETracInternal("Cannot encode field type: " + str(python_type))
 
     @classmethod
     def _define_primitive_field(
-            cls, python_type: type, optional=False, *,
-            dc_field: _dc.Field = None,
-            pyd_field: "_pyd.fields.FieldInfo" = None) \
-            -> _meta.StructField:
+            cls, name: str, index: int, python_type: type, optional=False, *,
+            dc_field: _dc.Field = None, pyd_field: "_pyd.fields.FieldInfo" = None) \
+            -> _meta.FieldSchema:
+
+        default_value = None
+
+        if dc_field is not None:
+            if dc_field.default not in [_dc.MISSING, None]:
+                default_value = _meta_types.MetadataCodec.encode_value(dc_field.default)
+            elif dc_field.default_factory not in [_dc.MISSING, None]:
+                native_value = dc_field.default_factory()
+                default_value = _meta_types.MetadataCodec.encode_value(native_value)
+
+        elif pyd_field is not None:
+            if pyd_field.default not in [_pyd.fields.PydanticUndefined, None]:
+                default_value = _meta_types.MetadataCodec.encode_value(pyd_field.default)
+            elif pyd_field.default_factory not in [_pyd.fields.PydanticUndefined, None]:
+                native_value = pyd_field.default_factory()
+                default_value = _meta_types.MetadataCodec.encode_value(native_value)
+
+        return _meta.FieldSchema(
+            fieldName=name,
+            fieldOrder=index,
+            fieldType=cls.__primitive_types[python_type],
+            notNull=not optional,
+            defaultValue=default_value)
+
+    @classmethod
+    def _define_enum_field(
+            cls, name: str, index: int, enum_type: _enum.EnumMeta, optional=False, *,
+            dc_field: _dc.Field = None, pyd_field: "_pyd.fields.FieldInfo" = None) \
+            -> _meta.FieldSchema:
 
-        struct_field = _meta.StructField()
-        struct_field.fieldType = _meta.TypeDescriptor(basicType=cls.__primitive_types[python_type])
-        struct_field.notNull = not optional
+        default_value = None
 
-        if dc_field is not None and  dc_field.default is not _dc.MISSING:
-            struct_field.defaultValue = _meta_types.MetadataCodec.encode_value(dc_field.default)
+        if dc_field is not None and  dc_field.default not in [_dc.MISSING, None]:
+            default_value = _meta_types.MetadataCodec.encode_value(dc_field.default.name)
 
-        if pyd_field is not None and pyd_field.default is not _pyd.fields.PydanticUndefined:
-            struct_field.defaultValue = _meta_types.MetadataCodec.encode_value(pyd_field.default)
+        if pyd_field is not None and pyd_field.default not in [_pyd.fields.PydanticUndefined, None]:
+            default_value = _meta_types.MetadataCodec.encode_value(pyd_field.default.name)
 
-        return struct_field
+        return _meta.FieldSchema(
+            fieldName=name,
+            fieldOrder=index,
+            fieldType=_meta.BasicType.STRING,
+            categorical=True,
+            notNull=not optional,
+            namedEnum=cls._qualified_type_name(enum_type),
+            defaultValue=default_value)
+
+    @classmethod
+    def _define_enum_values(cls, enum_type: _enum.EnumMeta) -> _meta.EnumValues:
+
+        values = list(map(lambda value: value.name, enum_type))
+        return _meta.EnumValues(values=values)
 
     @classmethod
     def _define_generic_field(
-            cls, python_type: type, *,
-            dc_field: _dc.Field = None,
-            pyd_field: "_pyd.fields.FieldInfo" = None) -> _meta.StructField:
+            cls, name, index, python_type: type, *,
+            named_types: _tp.Dict[str, _meta.SchemaDefinition],
+            named_enums: _tp.Dict[str, _meta.EnumValues],
+            type_stack: _tp.List[str],
+            dc_field: _dc.Field = None, pyd_field: "_pyd.fields.FieldInfo" = None) \
+            -> _meta.FieldSchema:
 
         origin = _tp.get_origin(python_type)
         args = _tp.get_args(python_type)
 
         # types.NoneType not available in Python 3.9, so use type(None) instead
-        if origin in cls.__union_types and len(args) == 2 and args[1] is type(None):
-            optional_type = args[0]
-            return cls._define_primitive_field(optional_type, optional=True, dc_field=dc_field, pyd_field=pyd_field)
+        if origin in cls.__union_types and len(args) == 2 and type(None) in args:
+            optional_type = args[0] if args[1] is type(None) else args[1]
+            return cls._define_field(
+                name, index, optional_type, optional=True,
+                dc_field=dc_field, pyd_field=pyd_field,
+                named_types=named_types, named_enums=named_enums,
+                type_stack=type_stack)
 
         elif origin in [list, _tp.List]:
-            list_type = args[0]
-            pass
+
+            item_type = args[0]
+            item_field = cls._define_field(
+                "item", 0, item_type, optional=False,
+                named_types=named_types, named_enums=named_enums,
+                type_stack=type_stack)
+
+            return _meta.FieldSchema(
+                fieldName=name,
+                fieldOrder=index,
+                fieldType=_meta.BasicType.ARRAY,
+                notNull=True,
+                children=[item_field])
 
         elif origin in [dict, _tp.Dict]:
+
             key_type = args[0]
+            key_field = _meta.FieldSchema(
+                fieldName="key",
+                fieldOrder=0,
+                fieldType=_meta.BasicType.STRING,
+                notNull=True)
+
             value_type = args[1]
-            pass
+            value_field = cls._define_field(
+                "value", 1, value_type, optional=False,
+                named_types=named_types, named_enums=named_enums,
+                type_stack=type_stack)
+
+            return _meta.FieldSchema(
+                fieldName=name,
+                fieldOrder=index,
+                fieldType=_meta.BasicType.MAP,
+                notNull=True,
+                children=[key_field, value_field])
 
         else:
             raise _ex.ETracInternal("Cannot encode field type: " + str(python_type))
 
+    @classmethod
+    def _qualified_type_name(cls, python_type: type):
+
+        name = python_type.__name__
+        module = python_type.__module__
+
+        if module.startswith(cls.__SHIM_PREFIX):
+            shim_root_index = module.index(".", len(cls.__SHIM_PREFIX)) + 1
+            module = module[shim_root_index:]
+
+        return f"{module}.{name}"
+
+    __SHIM_PREFIX = "tracdap.shim."
+
 
 class StructParser:
 
@@ -476,19 +671,18 @@ class StructQuoter:
     # New implementation of STRUCT quoting, copied from config_parser
     # After a period of stabilization, config_parser will switch to this implementation
 
-    JSON_FORMAT = "json"
-    YAML_FORMAT = "yaml"
     INDENT = 3
 
     @classmethod
     def quote(cls, obj: _tp.Any, dst: _tp.TextIO, dst_format: str):
 
-        if dst_format.lower() == cls.JSON_FORMAT:
-            return cls.quote_json(obj, dst)
 
-        if dst_format.lower() == cls.YAML_FORMAT:
+        if dst_format == StructProcessor.YAML_FORMAT or dst_format.lower() in StructProcessor.YAML_ALT_FORMATS:
             return cls.quote_yaml(obj, dst)
 
+        if dst_format == StructProcessor.JSON_FORMAT or dst_format.lower() in StructProcessor.JSON_ALT_FORMATS:
+            return cls.quote_json(obj, dst)
+
         # TODO :This is probably an error in the user-supplied parameters
         raise _ex.ETracInternal(f"Unsupported output format [{dst_format}]")
 

tracdap/rt/_impl/core/util.py

@@ -21,6 +21,7 @@ import re
 import typing as tp
 import uuid
 
+import tracdap.rt.api as api
 import tracdap.rt.exceptions as ex
 import tracdap.rt.metadata as meta
 import tracdap.rt.config as cfg
@@ -121,55 +122,103 @@ def selector_for_latest(object_id: meta.TagHeader) -> meta.TagSelector:
         latestTag=True)
 
 
+def get_job_mapping(
+        selector: tp.Union[meta.TagHeader, meta.TagSelector],
+        job_config: cfg.JobConfig) \
+        -> meta.TagHeader:
+
+    obj_key = object_key(selector)
+    obj_id = job_config.objectMapping.get(obj_key)
+
+    if obj_id is not None:
+        return obj_id
+
+    obj_key_match = __OBJ_KEY_PATTERN.match(obj_key)
+
+    if not obj_key_match:
+        err = f"Missing required {selector.objectType.name} ID for [{object_key(selector)}]"
+        raise ex.ERuntimeValidation(err)
+
+    obj_type = obj_key_match.group(1)
+    obj_id = obj_key_match.group(2)
+    obj_ver = obj_key_match.group(3)
+    obj_ts = job_config.jobId.objectTimestamp
+
+    return meta.TagHeader(
+        meta.ObjectType.__members__[obj_type], obj_id,
+        int(obj_ver), obj_ts, 1, obj_ts)
+
+
 def get_job_metadata(
         selector: tp.Union[meta.TagHeader, meta.TagSelector],
         job_config: cfg.JobConfig,
         optional: bool = False) \
         -> tp.Optional[meta.ObjectDefinition]:
 
+    return __get_job_metadata_item(selector, job_config, job_config.objects, "object", optional)
+
+
+def get_job_metadata_tag(
+        selector: tp.Union[meta.TagHeader, meta.TagSelector],
+        job_config: cfg.JobConfig,
+        optional: bool = False) \
+        -> tp.Optional[meta.Tag]:
+
+    return __get_job_metadata_item(selector, job_config, job_config.tags, "tag", optional)
+
+
+__METADATA_TYPE = tp.TypeVar("__METADATA_TYPE")
+
+
+def __get_job_metadata_item(
+        selector: tp.Union[meta.TagHeader, meta.TagSelector], job_config: cfg.JobConfig,
+        metadata: tp.Dict[str, __METADATA_TYPE], metadata_type: str,
+        optional: bool = False) \
+        -> tp.Optional[__METADATA_TYPE]:
+
     obj_key = object_key(selector)
     obj_id = job_config.objectMapping.get(obj_key)
 
     if obj_id is not None:
         obj_key = object_key(obj_id)
 
-    obj = job_config.objects.get(obj_key)
+    item = metadata.get(obj_key)
 
-    if obj is not None:
-        return obj
+    if item is not None:
+        return item
 
     if optional:
         return None
 
-    err = f"Missing required {selector.objectType.name} object for [{object_key(selector)}]"
+    err = f"Missing required {selector.objectType.name} {metadata_type} for [{object_key(selector)}]"
     raise ex.ERuntimeValidation(err)
 
 
-def get_job_mapping(
-        selector: tp.Union[meta.TagHeader, meta.TagSelector],
-        job_config: cfg.JobConfig) \
-        -> meta.TagHeader:
+def attach_runtime_metadata(obj: tp.Any, metadata: api.RuntimeMetadata):
 
-    obj_key = object_key(selector)
-    obj_id = job_config.objectMapping.get(obj_key)
+    if hasattr(obj, "with_metadata"):
+        attach_func = getattr(obj, "with_metadata")
+        if isinstance(attach_func, tp.Callable):
+            return attach_func(metadata)
 
-    if obj_id is not None:
-        return obj_id
+    setattr(obj, "_metadata", metadata)
 
-    obj_key_match = __OBJ_KEY_PATTERN.match(obj_key)
+    return obj
 
-    if not obj_key_match:
-        err = f"Missing required {selector.objectType.name} ID for [{object_key(selector)}]"
-        raise ex.ERuntimeValidation(err)
 
-    obj_type = obj_key_match.group(1)
-    obj_id = obj_key_match.group(2)
-    obj_ver = obj_key_match.group(3)
-    obj_ts = job_config.jobId.objectTimestamp
+def retrieve_runtime_metadata(obj: tp.Any) -> tp.Optional[api.RuntimeMetadata]:
 
-    return meta.TagHeader(
-        meta.ObjectType.__members__[obj_type], obj_id,
-        int(obj_ver), obj_ts, 1, obj_ts)
+    if hasattr(obj, "metadata"):
+        metadata = getattr(obj, "metadata")
+        if isinstance(metadata, api.RuntimeMetadata):
+            return metadata
+
+    if hasattr(obj, "_metadata"):
+        metadata = getattr(obj, "_metadata")
+        if isinstance(metadata, api.RuntimeMetadata):
+            return metadata
+
+    return None
 
 
 def get_origin(metaclass: type):
@@ -296,3 +345,25 @@ def filter_model_stack_trace(full_stack: tb.StackSummary, checkout_directory: pa
         last_model_frame = first_model_frame + frame_index
 
     return full_stack[first_model_frame:last_model_frame+1]
+
+
+__T = tp.TypeVar("__T")
+
+def read_property(properties: tp.Dict[str, str], key: str, default: tp.Optional[__T] = None, convert: tp.Optional[tp.Type[__T]] = str) -> __T:
+
+    value = properties.get(key)
+
+    if value is None:
+        if default is not None:
+            value = default
+        else:
+            raise ex.EConfigParse(f"Missing required property: [{key}]")
+
+    try:
+        if convert is bool and isinstance(value, str):
+            return True if value.lower() == "true" else False
+        else:
+            return convert(value)
+
+    except (ValueError, TypeError):
+        raise ex.EConfigParse(f"Wrong property type: [{key}] = [{value}], expected type is [{convert}]")

tracdap/rt/_impl/exec/context.py

@@ -118,6 +118,19 @@ class TracContextImpl(_api.TracContext):
 
         return not data_view.is_empty()
 
+    def get_metadata(self, item_name: str) -> tp.Optional[_api.RuntimeMetadata]:
+
+        _val.validate_signature(self.get_metadata, item_name)
+
+        self.__val.check_item_valid_identifier(item_name, TracContextValidator.ITEM)
+        self.__val.check_item_defined_in_model(item_name, TracContextValidator.ITEM)
+        self.__val.check_item_available_in_context(item_name, TracContextValidator.ITEM)
+
+        obj = self.__local_ctx.get(item_name)
+
+        # Can be none if no metadata is attached
+        return _util.retrieve_runtime_metadata(obj)
+
     def get_schema(self, dataset_name: str) -> _meta.SchemaDefinition:
 
         _val.validate_signature(self.get_schema, dataset_name)
@@ -201,8 +214,12 @@ class TracContextImpl(_api.TracContext):
         self.__val.check_context_data_view_type(struct_name, data_view, _meta.ObjectType.DATA)
         self.__val.check_dataset_schema_defined(struct_name, data_view)
 
-        struct_data: dict = data_view.parts[part_key][0].content
-        return _struct.StructProcessor.parse_struct(struct_data, None, python_class)
+        struct_data = data_view.parts[part_key][0].content
+
+        if isinstance(struct_data, python_class):
+            return struct_data
+        else:
+            return _struct.StructProcessor.parse_struct(struct_data, None, python_class)
 
     def get_file(self, file_name: str) -> bytes:
 
@@ -371,16 +388,25 @@ class TracContextImpl(_api.TracContext):
         self.__val.check_item_valid_identifier(file_name, TracContextValidator.FILE)
         self.__val.check_item_is_model_output(file_name, TracContextValidator.FILE)
 
+        class DelayedClose(io.BytesIO):
+
+            def __init__(self):
+                super().__init__()
+
+            def close(self):
+                super().flush()
+
         @contextlib.contextmanager
         def memory_stream(stream: io.BytesIO):
             try:
                 yield stream
-                buffer = stream.getbuffer().tobytes()
-                self.put_file(file_name, buffer)
             finally:
-                stream.close()
+                with stream.getbuffer() as buffer:
+                    self.put_file(file_name, bytes(buffer))
+                if not stream.closed:
+                    io.BytesIO.close(stream)
 
-        return memory_stream(io.BytesIO())
+        return memory_stream(DelayedClose())
 
     def log(self) -> logging.Logger:
 
@@ -816,6 +842,7 @@ class TracContextErrorReporter:
 
 class TracContextValidator(TracContextErrorReporter):
 
+    ITEM = "Item"
     PARAMETER = "Parameter"
     DATASET = "Dataset"
     FILE = "File"
@@ -891,10 +918,10 @@ class TracContextValidator(TracContextErrorReporter):
         if schema is None:
             self._report_error(f"Schema not defined for dataset {dataset_name} in the current context")
 
-        if schema.schemaType == _meta.SchemaType.TABLE and (schema.table is None or not schema.table.fields):
+        if schema.schemaType == _meta.SchemaType.TABLE_SCHEMA and (schema.table is None or not schema.table.fields):
             self._report_error(f"Schema not defined for dataset {dataset_name} in the current context")
 
-        if schema.schemaType == _meta.SchemaType.STRUCT and (schema.struct is None or not schema.struct.fields):
+        if schema.schemaType == _meta.SchemaType.STRUCT_SCHEMA and not schema.fields:
             self._report_error(f"Schema not defined for dataset {dataset_name} in the current context")
 
     def check_dataset_schema_not_defined(self, dataset_name: str, data_view: _data.DataView):