tracdap-runtime 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

tracdap/rt/_exec/context.py

@@ -19,13 +19,13 @@ import typing as tp
 import re
 import traceback
 
-import pandas as pd
-
 import tracdap.rt.api as _api
+import tracdap.rt.api.experimental as _eapi
 import tracdap.rt.metadata as _meta
 import tracdap.rt.exceptions as _ex
 import tracdap.rt._impl.type_system as _types  # 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
 import tracdap.rt._impl.validation as _val  # noqa
 
@@ -55,12 +55,11 @@ class TracContextImpl(_api.TracContext):
             Output views will contain schemas but no data.
     """
 
-    __DEFAULT_TEMPORAL_OBJECTS = False
-
     def __init__(self,
                  model_def: _meta.ModelDefinition,
                  model_class: _api.TracModel.__class__,
                  local_ctx: tp.Dict[str, tp.Any],
+                 dynamic_outputs: tp.List[str] = None,
                  checkout_directory: pathlib.Path = None):
 
         self.__ctx_log = _util.logger_for_object(self)
@@ -68,12 +67,14 @@ class TracContextImpl(_api.TracContext):
 
         self.__model_def = model_def
         self.__model_class = model_class
-        self.__local_ctx = local_ctx or {}
+        self.__local_ctx = local_ctx if local_ctx is not None else {}
+        self.__dynamic_outputs = dynamic_outputs if dynamic_outputs is not None else []
 
         self.__val = TracContextValidator(
             self.__ctx_log,
             self.__model_def,
             self.__local_ctx,
+            self.__dynamic_outputs,
             checkout_directory)
 
     def get_parameter(self, parameter_name: str) -> tp.Any:
@@ -131,18 +132,22 @@ class TracContextImpl(_api.TracContext):
         else:
             return copy.deepcopy(data_view.trac_schema)
 
-    def get_pandas_table(self, dataset_name: str, use_temporal_objects: tp.Optional[bool] = None) -> pd.DataFrame:
+    def get_table(self, dataset_name: str, framework: _eapi.DataFramework[_eapi.DATA_API], **framework_args) -> _eapi.DATA_API:
 
-        _val.validate_signature(self.get_pandas_table, dataset_name, use_temporal_objects)
+        _val.validate_signature(self.get_table, dataset_name, framework)
+        _val.require_package(framework.protocol_name, framework.api_type)
 
         self.__val.check_dataset_valid_identifier(dataset_name)
         self.__val.check_dataset_defined_in_model(dataset_name)
         self.__val.check_dataset_available_in_context(dataset_name)
+        self.__val.check_data_framework_args(framework, framework_args)
 
         static_schema = self.__get_static_schema(self.__model_def, dataset_name)
         data_view = self.__local_ctx.get(dataset_name)
         part_key = _data.DataPartKey.for_root()
 
+        converter = _data.DataConverter.for_framework(framework, **framework_args)
+
         self.__val.check_context_object_type(dataset_name, data_view, _data.DataView)
         self.__val.check_dataset_schema_defined(dataset_name, data_view)
         self.__val.check_dataset_part_present(dataset_name, data_view, part_key)
@@ -155,10 +160,18 @@ class TracContextImpl(_api.TracContext):
         else:
             schema = data_view.arrow_schema
 
-        if use_temporal_objects is None:
-            use_temporal_objects = self.__DEFAULT_TEMPORAL_OBJECTS
+        table = _data.DataMapping.view_to_arrow(data_view, part_key)
+
+        # Data conformance is applied automatically inside the converter, if schema != None
+        return converter.from_internal(table, schema)
 
-        return _data.DataMapping.view_to_pandas(data_view, part_key, schema, use_temporal_objects)
+    def get_pandas_table(self, dataset_name: str, use_temporal_objects: tp.Optional[bool] = None)  -> "_data.pandas.DataFrame":
+
+        return self.get_table(dataset_name, _eapi.PANDAS, use_temporal_objects=use_temporal_objects)
+
+    def get_polars_table(self, dataset_name: str) -> "_data.polars.DataFrame":
+
+        return self.get_table(dataset_name, _eapi.POLARS)
 
     def put_schema(self, dataset_name: str, schema: _meta.SchemaDefinition):
 
@@ -190,18 +203,29 @@ class TracContextImpl(_api.TracContext):
 
         self.__local_ctx[dataset_name] = updated_view
 
-    def put_pandas_table(self, dataset_name: str, dataset: pd.DataFrame):
+    def put_table(
+            self, dataset_name: str, dataset: _eapi.DATA_API,
+            framework: tp.Optional[_eapi.DataFramework[_eapi.DATA_API]] = None,
+            **framework_args):
+
+        _val.validate_signature(self.put_table, dataset_name, dataset, framework)
 
-        _val.validate_signature(self.put_pandas_table, dataset_name, dataset)
+        if framework is None:
+            framework = _data.DataConverter.get_framework(dataset)
+
+        _val.require_package(framework.protocol_name, framework.api_type)
 
         self.__val.check_dataset_valid_identifier(dataset_name)
         self.__val.check_dataset_is_model_output(dataset_name)
-        self.__val.check_provided_dataset_type(dataset, pd.DataFrame)
+        self.__val.check_provided_dataset_type(dataset, framework.api_type)
+        self.__val.check_data_framework_args(framework, framework_args)
 
         static_schema = self.__get_static_schema(self.__model_def, dataset_name)
         data_view = self.__local_ctx.get(dataset_name)
         part_key = _data.DataPartKey.for_root()
 
+        converter = _data.DataConverter.for_framework(framework)
+
         if data_view is None:
             if static_schema is not None:
                 data_view = _data.DataView.for_trac_schema(static_schema)
@@ -219,13 +243,22 @@ class TracContextImpl(_api.TracContext):
         else:
             schema = data_view.arrow_schema
 
-        # Data conformance is applied inside these conversion functions
+        # Data conformance is applied automatically inside the converter, if schema != None
+        table = converter.to_internal(dataset, schema)
+        item = _data.DataItem(schema, table)
 
-        updated_item = _data.DataMapping.pandas_to_item(dataset, schema)
-        updated_view = _data.DataMapping.add_item_to_view(data_view, part_key, updated_item)
+        updated_view = _data.DataMapping.add_item_to_view(data_view, part_key, item)
 
         self.__local_ctx[dataset_name] = updated_view
 
+    def put_pandas_table(self, dataset_name: str, dataset: "_data.pandas.DataFrame"):
+
+        self.put_table(dataset_name, dataset, _eapi.PANDAS)
+
+    def put_polars_table(self, dataset_name: str, dataset: "_data.polars.DataFrame"):
+
+        self.put_table(dataset_name, dataset, _eapi.POLARS)
+
     def log(self) -> logging.Logger:
 
         _val.validate_signature(self.log)
@@ -260,22 +293,367 @@ class TracContextImpl(_api.TracContext):
         return schema_def
 
 
-class TracContextValidator:
-
-    __VALID_IDENTIFIER = re.compile("^[a-zA-Z_]\\w*$",)
-    __RESERVED_IDENTIFIER = re.compile("^(trac_|_)\\w*")
+class TracDataContextImpl(TracContextImpl, _eapi.TracDataContext):
 
     def __init__(
-            self, log: logging.Logger,
-            model_def: _meta.ModelDefinition,
-            local_ctx: tp.Dict[str, tp.Any],
-            checkout_directory: pathlib.Path):
+            self, model_def: _meta.ModelDefinition, model_class: _api.TracModel.__class__,
+            local_ctx: tp.Dict[str, tp.Any], dynamic_outputs: tp.List[str],
+            storage_map: tp.Dict[str, tp.Union[_eapi.TracFileStorage, _eapi.TracDataStorage]],
+            checkout_directory: pathlib.Path = None):
+
+        super().__init__(model_def, model_class, local_ctx, dynamic_outputs, checkout_directory)
 
-        self.__log = log
         self.__model_def = model_def
         self.__local_ctx = local_ctx
+        self.__dynamic_outputs = dynamic_outputs
+        self.__storage_map = storage_map
+        self.__checkout_directory = checkout_directory
+
+        self.__val = self._TracContextImpl__val  # noqa
+
+    def get_file_storage(self, storage_key: str) -> _eapi.TracFileStorage:
+
+        _val.validate_signature(self.get_file_storage, storage_key)
+
+        self.__val.check_storage_valid_identifier(storage_key)
+        self.__val.check_storage_available(self.__storage_map, storage_key)
+        self.__val.check_storage_type(self.__storage_map, storage_key, _eapi.TracFileStorage)
+
+        return self.__storage_map[storage_key]
+
+    def get_data_storage(
+            self, storage_key: str,
+            framework: _eapi.DataFramework[_eapi.DATA_API],
+            **framework_args) -> _eapi.TracDataStorage[_eapi.DATA_API]:
+
+        _val.validate_signature(self.get_file_storage, storage_key)
+
+        self.__val.check_storage_valid_identifier(storage_key)
+        self.__val.check_storage_available(self.__storage_map, storage_key)
+        self.__val.check_storage_type(self.__storage_map, storage_key, _eapi.TracDataStorage)
+        self.__val.check_data_framework_args(framework, framework_args)
+
+        storage = self.__storage_map[storage_key]
+        converter = _data.DataConverter.for_framework(framework, **framework_args)
+
+        # Create a shallow copy of the storage impl with a converter for the requested data framework
+        # At some point we will need a storage factory class, bc the internal data API can also be different
+        storage = copy.copy(storage)
+        storage._TracDataStorageImpl__converter = converter
+
+        return storage
+
+    def add_data_import(self, dataset_name: str):
+
+        _val.validate_signature(self.add_data_import, dataset_name)
+
+        self.__val.check_dataset_valid_identifier(dataset_name)
+        self.__val.check_dataset_not_defined_in_model(dataset_name)
+        self.__val.check_dataset_not_available_in_context(dataset_name)
+
+        self.__local_ctx[dataset_name] = _data.DataView.create_empty()
+        self.__dynamic_outputs.append(dataset_name)
+
+    def set_source_metadata(self, dataset_name: str, storage_key: str, source_info: tp.Union[_eapi.FileStat, str]):
+
+        _val.validate_signature(self.set_source_metadata, dataset_name, storage_key, source_info)
+
+        self.__val.check_dataset_valid_identifier(dataset_name)
+        self.__val.check_dataset_available_in_context(dataset_name)
+        self.__val.check_storage_valid_identifier(storage_key)
+        self.__val.check_storage_available(self.__storage_map, storage_key)
+
+        storage = self.__storage_map[storage_key]
+
+        if isinstance(storage, _eapi.TracFileStorage):
+            if not isinstance(source_info, _eapi.FileStat):
+                self.__val.report_public_error(f"Expected storage_info to be a FileStat, [{storage_key}] refers to file storage")
+
+        if isinstance(storage, _eapi.TracDataStorage):
+            if not isinstance(source_info, str):
+                self.__val.report_public_error(f"Expected storage_info to be a table name, [{storage_key}] refers to dadta storage")
+
+        pass  # Not implemented yet, only required when imports are sent back to the platform
+
+    def set_attribute(self, dataset_name: str, attribute_name: str, value: tp.Any):
+
+        _val.validate_signature(self.set_attribute, dataset_name, attribute_name, value)
+
+        pass  # Not implemented yet, only required when imports are sent back to the platform
+
+    def set_schema(self, dataset_name: str, schema: _meta.SchemaDefinition):
+
+        _val.validate_signature(self.set_schema, dataset_name, schema)
+
+        # Forward to existing method (these should be swapped round)
+        self.put_schema(dataset_name, schema)
+
+
+class TracFileStorageImpl(_eapi.TracFileStorage):
+
+    def __init__(self, storage_key: str, storage_impl: _storage.IFileStorage, write_access: bool, checkout_directory):
+
+        self.__storage_key = storage_key
+
+        self.__exists = lambda sp: storage_impl.exists(sp)
+        self.__size = lambda sp: storage_impl.size(sp)
+        self.__stat = lambda sp: storage_impl.stat(sp)
+        self.__ls = lambda sp, rec: storage_impl.ls(sp, rec)
+        self.__read_byte_stream = lambda sp: storage_impl.read_byte_stream(sp)
+
+        if write_access:
+            self.__mkdir = lambda sp, rec: storage_impl.mkdir(sp, rec)
+            self.__rm = lambda sp: storage_impl.rm(sp)
+            self.__rmdir = lambda sp: storage_impl.rmdir(sp)
+            self.__write_byte_stream = lambda sp: storage_impl.write_byte_stream(sp)
+        else:
+            self.__mkdir = None
+            self.__rm = None
+            self.__rmdir = None
+            self.__write_byte_stream = None
+
+        self.__log = _util.logger_for_object(self)
+        self.__val = TracStorageValidator(self.__log, checkout_directory, self.__storage_key)
+
+    def get_storage_key(self) -> str:
+
+        _val.validate_signature(self.get_storage_key)
+
+        return self.__storage_key
+
+    def exists(self, storage_path: str) -> bool:
+
+        _val.validate_signature(self.exists, storage_path)
+
+        self.__val.check_operation_available(self.exists, self.__exists)
+        self.__val.check_storage_path_is_valid(storage_path)
+
+        return self.__exists(storage_path)
+
+    def size(self, storage_path: str) -> int:
+
+        _val.validate_signature(self.size, storage_path)
+
+        self.__val.check_operation_available(self.size, self.__size)
+        self.__val.check_storage_path_is_valid(storage_path)
+
+        return self.__size(storage_path)
+
+    def stat(self, storage_path: str) -> _eapi.FileStat:
+
+        _val.validate_signature(self.stat, storage_path)
+
+        self.__val.check_operation_available(self.stat, self.__stat)
+        self.__val.check_storage_path_is_valid(storage_path)
+
+        stat = self.__stat(storage_path)
+        return _eapi.FileStat(**stat.__dict__)
+
+    def ls(self, storage_path: str, recursive: bool = False) -> tp.List[_eapi.FileStat]:
+
+        _val.validate_signature(self.ls, storage_path, recursive)
+
+        self.__val.check_operation_available(self.ls, self.__ls)
+        self.__val.check_storage_path_is_valid(storage_path)
+
+        listing = self.__ls(storage_path, recursive)
+        return list(_eapi.FileStat(**stat.__dict__) for stat in listing)
+
+    def mkdir(self, storage_path: str, recursive: bool = False):
+
+        _val.validate_signature(self.mkdir, storage_path, recursive)
+
+        self.__val.check_operation_available(self.mkdir, self.__mkdir)
+        self.__val.check_storage_path_is_valid(storage_path)
+        self.__val.check_storage_path_is_not_root(storage_path)
+
+        self.__mkdir(storage_path, recursive)
+
+    def rm(self, storage_path: str):
+
+        _val.validate_signature(self.rm, storage_path)
+
+        self.__val.check_operation_available(self.rm, self.__rm)
+        self.__val.check_storage_path_is_valid(storage_path)
+        self.__val.check_storage_path_is_not_root(storage_path)
+
+        self.__rm(storage_path)
+
+    def rmdir(self, storage_path: str):
+
+        _val.validate_signature(self.rmdir, storage_path)
+
+        self.__val.check_operation_available(self.rmdir, self.__rmdir)
+        self.__val.check_storage_path_is_valid(storage_path)
+        self.__val.check_storage_path_is_not_root(storage_path)
+
+        self.__rmdir(storage_path)
+
+    def read_byte_stream(self, storage_path: str) -> tp.ContextManager[tp.BinaryIO]:
+
+        _val.validate_signature(self.read_byte_stream, storage_path)
+
+        self.__val.check_operation_available(self.read_byte_stream, self.__read_byte_stream)
+        self.__val.check_storage_path_is_valid(storage_path)
+
+        return self.__read_byte_stream(storage_path)
+
+    def read_bytes(self, storage_path: str) -> bytes:
+
+        _val.validate_signature(self.read_bytes, storage_path)
+
+        self.__val.check_operation_available(self.read_bytes, self.__read_byte_stream)
+        self.__val.check_storage_path_is_valid(storage_path)
+
+        return super().read_bytes(storage_path)
+
+    def write_byte_stream(self, storage_path: str) -> tp.ContextManager[tp.BinaryIO]:
+
+        _val.validate_signature(self.write_byte_stream, storage_path)
+
+        self.__val.check_operation_available(self.write_byte_stream, self.__write_byte_stream)
+        self.__val.check_storage_path_is_valid(storage_path)
+        self.__val.check_storage_path_is_not_root(storage_path)
+
+        return self.__write_byte_stream(storage_path)
+
+    def write_bytes(self, storage_path: str, data: bytes):
+
+        _val.validate_signature(self.write_bytes, storage_path)
+
+        self.__val.check_operation_available(self.write_bytes, self.__write_byte_stream)
+        self.__val.check_storage_path_is_valid(storage_path)
+        self.__val.check_storage_path_is_not_root(storage_path)
+
+        super().write_bytes(storage_path, data)
+
+
+class TracDataStorageImpl(_eapi.TracDataStorage[_eapi.DATA_API]):
+
+    def __init__(
+            self, storage_key: str, storage_impl: _storage.IDataStorageBase[_data.T_INTERNAL_DATA, _data.T_INTERNAL_SCHEMA],
+            data_converter: _data.DataConverter[_eapi.DATA_API, _data.T_INTERNAL_DATA, _data.T_INTERNAL_SCHEMA],
+            write_access: bool, checkout_directory):
+
+        self.__storage_key = storage_key
+        self.__converter = data_converter
+
+        self.__has_table = lambda tn: storage_impl.has_table(tn)
+        self.__list_tables = lambda: storage_impl.list_tables()
+        self.__read_table = lambda tn: storage_impl.read_table(tn)
+        self.__native_read_query = lambda q, ps: storage_impl.native_read_query(q, **ps)
+
+        if write_access:
+            self.__create_table = lambda tn, s: storage_impl.create_table(tn, s)
+            self.__write_table = lambda tn, ds: storage_impl.write_table(tn, ds)
+        else:
+            self.__create_table = None
+            self.__write_table = None
+
+        self.__log = _util.logger_for_object(self)
+        self.__val = TracStorageValidator(self.__log, checkout_directory, self.__storage_key)
+
+    def has_table(self, table_name: str) -> bool:
+
+        _val.validate_signature(self.has_table, table_name)
+
+        self.__val.check_operation_available(self.has_table, self.__has_table)
+        self.__val.check_table_name_is_valid(table_name)
+        self.__val.check_storage_path_is_valid(table_name)
+
+        try:
+            return self.__has_table(table_name)
+        except _ex.EStorageRequest as e:
+            self.__val.report_public_error(e)
+
+    def list_tables(self) -> tp.List[str]:
+
+        _val.validate_signature(self.list_tables)
+
+        self.__val.check_operation_available(self.list_tables, self.__list_tables)
+
+        try:
+            return self.__list_tables()
+        except _ex.EStorageRequest as e:
+            self.__val.report_public_error(e)
+
+    def create_table(self, table_name: str, schema: _api.SchemaDefinition):
+
+        _val.validate_signature(self.create_table, table_name, schema)
+
+        self.__val.check_operation_available(self.create_table, self.__create_table)
+        self.__val.check_table_name_is_valid(table_name)
+        self.__val.check_storage_path_is_valid(table_name)
+
+        arrow_schema = _data.DataMapping.trac_to_arrow_schema(schema)
+
+        try:
+            self.__create_table(table_name, arrow_schema)
+        except _ex.EStorageRequest as e:
+            self.__val.report_public_error(e)
+
+    def read_table(self, table_name: str) -> _eapi.DATA_API:
+
+        _val.validate_signature(self.read_table, table_name)
+
+        self.__val.check_operation_available(self.read_table, self.__read_table)
+        self.__val.check_table_name_is_valid(table_name)
+        self.__val.check_table_name_not_reserved(table_name)
+
+        try:
+            raw_data = self.__read_table(table_name)
+            return self.__converter.from_internal(raw_data)
+
+        except _ex.EStorageRequest as e:
+            self.__val.report_public_error(e)
+
+    def native_read_query(self, query: str, **parameters) -> _eapi.DATA_API:
+
+        _val.validate_signature(self.native_read_query, query, **parameters)
+
+        self.__val.check_operation_available(self.native_read_query, self.__native_read_query)
+
+        # TODO: validate query and parameters
+        # Some validation is performed by the impl
+
+        try:
+            raw_data = self.__native_read_query(query, **parameters)
+            return self.__converter.from_internal(raw_data)
+
+        except _ex.EStorageRequest as e:
+            self.__val.report_public_error(e)
+
+    def write_table(self, table_name: str, dataset: _eapi.DATA_API):
+
+        _val.validate_signature(self.write_table, table_name, dataset)
+
+        self.__val.check_operation_available(self.read_table, self.__read_table)
+        self.__val.check_table_name_is_valid(table_name)
+        self.__val.check_table_name_not_reserved(table_name)
+        self.__val.check_provided_dataset_type(dataset, self.__converter.framework.api_type)
+
+        try:
+            raw_data = self.__converter.to_internal(dataset)
+            self.__write_table(table_name, raw_data)
+
+        except _ex.EStorageRequest as e:
+            self.__val.report_public_error(e)
+
+
+class TracContextErrorReporter:
+
+    _VALID_IDENTIFIER = re.compile("^[a-zA-Z_]\\w*$",)
+    _RESERVED_IDENTIFIER = re.compile("^(trac_|_)\\w*")
+
+    def __init__(self, log: logging.Logger, checkout_directory: pathlib.Path):
+
+        self.__log = log
         self.__checkout_directory = checkout_directory
 
+    def report_public_error(self, exception: Exception):
+
+        self._report_error(str(exception), exception)
+
     def _report_error(self, message, cause: Exception = None):
 
         full_stack = traceback.extract_stack()
@@ -292,12 +670,38 @@ class TracContextValidator:
         else:
             raise _ex.ERuntimeValidation(message)
 
+    @staticmethod
+    def _type_name(type_: type):
+
+        module = type_.__module__
+
+        if module is None or module == str.__class__.__module__ or module == tp.__name__:
+            return _val.type_name(type_, False)
+        else:
+            return _val.type_name(type_, True)
+
+
+class TracContextValidator(TracContextErrorReporter):
+
+    def __init__(
+            self, log: logging.Logger,
+            model_def: _meta.ModelDefinition,
+            local_ctx: tp.Dict[str, tp.Any],
+            dynamic_outputs: tp.List[str],
+            checkout_directory: pathlib.Path):
+
+        super().__init__(log, checkout_directory)
+
+        self.__model_def = model_def
+        self.__local_ctx = local_ctx
+        self.__dynamic_outputs = dynamic_outputs
+
     def check_param_valid_identifier(self, param_name: str):
 
         if param_name is None:
             self._report_error(f"Parameter name is null")
 
-        if not self.__VALID_IDENTIFIER.match(param_name):
+        if not self._VALID_IDENTIFIER.match(param_name):
             self._report_error(f"Parameter name {param_name} is not a valid identifier")
 
     def check_param_defined_in_model(self, param_name: str):
@@ -315,9 +719,17 @@ class TracContextValidator:
         if dataset_name is None:
             self._report_error(f"Dataset name is null")
 
-        if not self.__VALID_IDENTIFIER.match(dataset_name):
+        if not self._VALID_IDENTIFIER.match(dataset_name):
             self._report_error(f"Dataset name {dataset_name} is not a valid identifier")
 
+    def check_dataset_not_defined_in_model(self, dataset_name: str):
+
+        if dataset_name  in self.__model_def.inputs or dataset_name in self.__model_def.outputs:
+            self._report_error(f"Dataset {dataset_name} is already defined in the model")
+
+        if dataset_name  in self.__model_def.parameters:
+            self._report_error(f"Dataset name {dataset_name} is already in use as a model parameter")
+
     def check_dataset_defined_in_model(self, dataset_name: str):
 
         if dataset_name not in self.__model_def.inputs and dataset_name not in self.__model_def.outputs:
@@ -325,17 +737,18 @@ class TracContextValidator:
 
     def check_dataset_is_model_output(self, dataset_name: str):
 
-        if dataset_name not in self.__model_def.outputs:
+        if dataset_name not in self.__model_def.outputs and dataset_name not in self.__dynamic_outputs:
             self._report_error(f"Dataset {dataset_name} is not defined as a model output")
 
     def check_dataset_is_dynamic_output(self, dataset_name: str):
 
         model_output: _meta.ModelOutputSchema = self.__model_def.outputs.get(dataset_name)
+        dynamic_output = dataset_name in self.__dynamic_outputs
 
-        if model_output is None:
+        if model_output is None and not dynamic_output:
             self._report_error(f"Dataset {dataset_name} is not defined as a model output")
 
-        if not model_output.dynamic:
+        if model_output and not model_output.dynamic:
             self._report_error(f"Model output {dataset_name} is not a dynamic output")
 
     def check_dataset_available_in_context(self, item_name: str):
@@ -343,6 +756,11 @@ class TracContextValidator:
         if item_name not in self.__local_ctx:
             self._report_error(f"Dataset {item_name} is not available in the current context")
 
+    def check_dataset_not_available_in_context(self, item_name: str):
+
+        if item_name in self.__local_ctx:
+            self._report_error(f"Dataset {item_name} already exists in the current context")
+
     def check_dataset_schema_defined(self, dataset_name: str, data_view: _data.DataView):
 
         schema = data_view.trac_schema if data_view is not None else None
@@ -415,12 +833,114 @@ class TracContextValidator:
                 f"The object referenced by [{item_name}] in the current context has the wrong type" +
                 f" (expected {expected_type_name}, got {actual_type_name})")
 
-    @staticmethod
-    def _type_name(type_: type):
+    def check_data_framework_args(self, framework: _eapi.DataFramework, framework_args: tp.Dict[str, tp.Any]):
 
-        module = type_.__module__
+        expected_args = _data.DataConverter.get_framework_args(framework)
+        unexpected_args = list(filter(lambda arg: arg not in expected_args, framework_args.keys()))
+
+        if any(unexpected_args):
+            unknown_args = ", ".join(unexpected_args)
+            self._report_error(f"Using [{framework}], some arguments were not recognized: [{unknown_args}]")
+
+        for arg_name, arg_type in expected_args.items():
+
+            arg_value = framework_args.get(arg_name)
+
+            if _val.check_type(arg_type, arg_value):
+                continue
+
+            if arg_value is None:
+                self._report_error(f"Using [{framework}], required argument [{arg_name}] is missing")
+
+            else:
+                expected_type_name = self._type_name(arg_type)
+                actual_type_name = self._type_name(type(arg_value))
+
+                self._report_error(
+                    f"Using [{framework}], argument [{arg_name}] has the wrong type" +
+                    f" (expected {expected_type_name}, got {actual_type_name})")
+
+    def check_storage_valid_identifier(self, storage_key):
+
+        if storage_key is None:
+            self._report_error(f"Storage key is null")
+
+        if not self._VALID_IDENTIFIER.match(storage_key):
+            self._report_error(f"Storage key {storage_key} is not a valid identifier")
+
+    def check_storage_available(self, storage_map: tp.Dict, storage_key: str):
+
+        storage_instance = storage_map.get(storage_key)
+
+        if storage_instance is None:
+            self._report_error(f"Storage not available for storage key [{storage_key}]")
+
+    def check_storage_type(
+            self, storage_map: tp.Dict, storage_key: str,
+            storage_type: tp.Union[_eapi.TracFileStorage.__class__]):
+
+        storage_instance = storage_map.get(storage_key)
+
+        if not isinstance(storage_instance, storage_type):
+            if storage_type == _eapi.TracFileStorage:
+                self._report_error(f"Storage key [{storage_key}] refers to data storage, not file storage")
+            else:
+                self._report_error(f"Storage key [{storage_key}] refers to file storage, not data storage")
 
-        if module is None or module == str.__class__.__module__:
-            return type_.__qualname__
 
-        return module + '.' + type_.__name__
+class TracStorageValidator(TracContextErrorReporter):
+
+    def __init__(self, log, checkout_directory, storage_key):
+        super().__init__(log, checkout_directory)
+        self.__storage_key = storage_key
+
+    def check_operation_available(self, public_func: tp.Callable, impl_func: tp.Callable):
+
+        if impl_func is None:
+            self._report_error(f"Operation [{public_func.__name__}] is not available for storage [{self.__storage_key}]")
+
+    def check_storage_path_is_valid(self, storage_path: str):
+
+        if _val.StorageValidator.storage_path_is_empty(storage_path):
+            self._report_error(f"Storage path is None or empty")
+
+        if _val.StorageValidator.storage_path_invalid(storage_path):
+            self._report_error(f"Storage path [{storage_path}] contains invalid characters")
+
+        if _val.StorageValidator.storage_path_not_relative(storage_path):
+            self._report_error(f"Storage path [{storage_path}] is not a relative path")
+
+        if _val.StorageValidator.storage_path_outside_root(storage_path):
+            self._report_error(f"Storage path [{storage_path}] is outside the storage root")
+
+    def check_storage_path_is_not_root(self, storage_path: str):
+
+        if _val.StorageValidator.storage_path_is_empty(storage_path):
+            self._report_error(f"Storage path [{storage_path}] is not allowed")
+
+    def check_table_name_is_valid(self, table_name: str):
+
+        if table_name is None:
+            self._report_error(f"Table name is null")
+
+        if not self._VALID_IDENTIFIER.match(table_name):
+            self._report_error(f"Table name {table_name} is not a valid identifier")
+
+    def check_table_name_not_reserved(self, table_name: str):
+
+        if self._RESERVED_IDENTIFIER.match(table_name):
+            self._report_error(f"Table name {table_name} is a reserved identifier")
+
+    def check_provided_dataset_type(self, dataset: tp.Any, expected_type: type):
+
+        if dataset is None:
+            self._report_error(f"Provided dataset is null")
+
+        if not isinstance(dataset, expected_type):
+
+            expected_type_name = self._type_name(expected_type)
+            actual_type_name = self._type_name(type(dataset))
+
+            self._report_error(
+                f"Provided dataset is the wrong type" +
+                f" (expected {expected_type_name}, got {actual_type_name})")