tracdap-runtime 0.8.0b3__py3-none-any.whl → 0.8.0rc1__py3-none-any.whl

tracdap/rt/_impl/core/type_system.py

@@ -133,9 +133,13 @@ class MetadataCodec:
 
         if basic_type == _meta.BasicType.ARRAY:
             items = value.arrayValue.items
-            return list(map(lambda x: MetadataCodec._decode_value_for_type(x, type_desc.arrayType), items))
+            return list(MetadataCodec._decode_value_for_type(x, type_desc.arrayType) for x in items)
 
-        raise _ex.ETracInternal(f"Decoding value type [{basic_type}] is not supported yet")
+        if basic_type == _meta.BasicType.MAP:
+            items = value.mapValue.entries.items()
+            return dict((k, MetadataCodec._decode_value_for_type(v, type_desc.mapType)) for k, v in items)
+
+        raise _ex.ETracInternal(f"Cannot decode value of type [{basic_type}]")
 
     @classmethod
     def encode_value(cls, value: tp.Any) -> _meta.Value:
@@ -183,19 +187,36 @@ class MetadataCodec:
             if any(map(lambda x: type(x) != array_raw_type, value)):
                 raise _ex.ETracInternal("Cannot encode a list with values of different types")
 
-            encoded_items = list(map(lambda x: cls.convert_value(x, array_trac_type), value))
+            encoded_items = list(map(lambda x: cls.convert_value(x, array_trac_type, True), value))
 
             return _meta.Value(
                 _meta.TypeDescriptor(_meta.BasicType.ARRAY, arrayType=array_trac_type),
                 arrayValue=_meta.ArrayValue(encoded_items))
 
-        raise _ex.ETracInternal(f"Value type [{type(value)}] is not supported yet")
+        if isinstance(value, dict):
+
+            if len(value) == 0:
+                raise _ex.ETracInternal("Cannot encode an empty dict")
+
+            map_raw_type = type(next(iter(value.values())))
+            map_trac_type = TypeMapping.python_to_trac(map_raw_type)
+
+            if any(map(lambda x: type(x) != array_raw_type, value.values())):
+                raise _ex.ETracInternal("Cannot encode a dict with values of different types")
+
+            encoded_entries = dict(map(lambda kv: (kv[0], cls.convert_value(kv[1], map_trac_type, True)), value.items()))
+
+            return _meta.Value(
+                _meta.TypeDescriptor(_meta.BasicType.ARRAY, mapType=map_trac_type),
+                mapValue=_meta.MapValue(encoded_entries))
+
+        raise _ex.ETracInternal(f"Cannot encode value of type [{type(value).__name__}]")
 
     @classmethod
-    def convert_value(cls, raw_value: tp.Any, type_desc: _meta.TypeDescriptor):
+    def convert_value(cls, raw_value: tp.Any, type_desc: _meta.TypeDescriptor, nested: bool = False):
 
         if type_desc.basicType == _meta.BasicType.BOOLEAN:
-            return cls.convert_boolean_value(raw_value)
+            return cls.convert_boolean_value(raw_value, nested)
 
         if type_desc.basicType == _meta.BasicType.INTEGER:
             return cls.convert_integer_value(raw_value)
@@ -218,78 +239,97 @@ class MetadataCodec:
         if type_desc.basicType == _meta.BasicType.ARRAY:
             return cls.convert_array_value(raw_value, type_desc.arrayType)
 
+        if type_desc.basicType == _meta.BasicType.MAP:
+            return cls.convert_map_value(raw_value, type_desc.mapType)
+
         raise _ex.ETracInternal(f"Conversion to value type [{type_desc.basicType.name}] is not supported yet")
 
     @staticmethod
     def convert_array_value(raw_value: tp.List[tp.Any], array_type: _meta.TypeDescriptor) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.ARRAY, array_type)
+        type_desc = _meta.TypeDescriptor(basicType=_meta.BasicType.ARRAY, arrayType=array_type)
 
         if not isinstance(raw_value, list):
-            msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.ARRAY.name}"
+            msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.ARRAY.name}"
             raise _ex.ETracInternal(msg)
 
-        items = list(map(lambda x: MetadataCodec.convert_value(x, array_type), raw_value))
+        items = list(map(lambda x: MetadataCodec.convert_value(x, array_type, True), raw_value))
 
         return _meta.Value(type_desc, arrayValue=_meta.ArrayValue(items))
 
     @staticmethod
-    def convert_boolean_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_map_value(raw_value: tp.Dict[str, tp.Any], map_type: _meta.TypeDescriptor) -> _meta.Value:
+
+        type_desc = _meta.TypeDescriptor(basicType=_meta.BasicType.MAP, mapType=map_type)
+
+        if not isinstance(raw_value, dict):
+            msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.MAP.name}"
+            raise _ex.ETracInternal(msg)
+
+        entries = dict(map(lambda kv: (kv[0], MetadataCodec.convert_value(kv[1], map_type, True)), raw_value.items()))
+
+        return _meta.Value(type_desc, mapValue=_meta.MapValue(entries))
+
+    @staticmethod
+    def convert_boolean_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.BOOLEAN)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.BOOLEAN) if not nested else None
 
         if isinstance(raw_value, bool):
             return _meta.Value(type_desc, booleanValue=raw_value)
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.BOOLEAN.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.BOOLEAN.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_integer_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_integer_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.INTEGER)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.INTEGER) if not nested else None
 
-        if isinstance(raw_value, int):
+        # isinstance(bool_value, int) returns True! An explicit check is needed
+        if isinstance(raw_value, int) and not isinstance(raw_value, bool):
             return _meta.Value(type_desc, integerValue=raw_value)
 
         if isinstance(raw_value, float) and raw_value.is_integer():
             return _meta.Value(type_desc, integerValue=int(raw_value))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.INTEGER.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.INTEGER.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_float_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_float_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.FLOAT)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.FLOAT) if not nested else None
 
         if isinstance(raw_value, float):
             return _meta.Value(type_desc, floatValue=raw_value)
 
-        if isinstance(raw_value, int):
+        # isinstance(bool_value, int) returns True! An explicit check is needed
+        if isinstance(raw_value, int) and not isinstance(raw_value, bool):
             return _meta.Value(type_desc, floatValue=float(raw_value))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.FLOAT.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.FLOAT.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_decimal_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_decimal_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.DECIMAL)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.DECIMAL) if not nested else None
 
         if isinstance(raw_value, decimal.Decimal):
             return _meta.Value(type_desc, decimalValue=_meta.DecimalValue(str(raw_value)))
 
-        if isinstance(raw_value, int) or isinstance(raw_value, float):
+        # isinstance(bool_value, int) returns True! An explicit check is needed
+        if isinstance(raw_value, int) or isinstance(raw_value, float) and not isinstance(raw_value, bool):
             return _meta.Value(type_desc, decimalValue=_meta.DecimalValue(str(raw_value)))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.DECIMAL.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.DECIMAL.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_string_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_string_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.STRING)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.STRING) if not nested else None
 
         if isinstance(raw_value, str):
             return _meta.Value(type_desc, stringValue=raw_value)
@@ -301,13 +341,13 @@ class MetadataCodec:
 
             return _meta.Value(type_desc, stringValue=str(raw_value))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.STRING.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.STRING.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_date_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_date_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATE)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATE) if not nested else None
 
         if isinstance(raw_value, dt.date):
             return _meta.Value(type_desc, dateValue=_meta.DateValue(isoDate=raw_value.isoformat()))
@@ -316,13 +356,13 @@ class MetadataCodec:
             date_value = dt.date.fromisoformat(raw_value)
             return _meta.Value(type_desc, dateValue=_meta.DateValue(isoDate=date_value.isoformat()))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.DATE.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.DATE.name}"
         raise _ex.ETracInternal(msg)
 
     @staticmethod
-    def convert_datetime_value(raw_value: tp.Any) -> _meta.Value:
+    def convert_datetime_value(raw_value: tp.Any, nested: bool = False) -> _meta.Value:
 
-        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATETIME)
+        type_desc = _meta.TypeDescriptor(_meta.BasicType.DATETIME) if not nested else None
 
         if isinstance(raw_value, dt.datetime):
             return _meta.Value(type_desc, datetimeValue=_meta.DatetimeValue(isoDatetime=raw_value.isoformat()))
@@ -331,5 +371,5 @@ class MetadataCodec:
             datetime_value = dt.datetime.fromisoformat(raw_value)
             return _meta.Value(type_desc, datetimeValue=_meta.DatetimeValue(isoDatetime=datetime_value.isoformat()))
 
-        msg = f"Value of type [{type(raw_value)}] cannot be converted to {_meta.BasicType.DATETIME.name}"
+        msg = f"Value of type [{type(raw_value).__name__}] cannot be converted to {_meta.BasicType.DATETIME.name}"
         raise _ex.ETracInternal(msg)

tracdap/rt/_impl/core/validation.py

@@ -67,9 +67,17 @@ class SkipValidation(tp.Generic[T_SKIP_VAL]):
 
 class _TypeValidator:
 
-    # 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])
+    # Support both new and old styles for generic, union and optional types
+    # Old-style annotations are still valid, even when the new style is fully supported
+    __generic_metaclass = [
+        types.GenericAlias,
+        type(tp.List[object]),
+        type(tp.Optional[object])
+    ]
+
+    # UnionType was added to the types module in Python 3.10, we support 3.9 (Jan 2025)
+    if hasattr(types, "UnionType"):
+        __generic_metaclass.append(types.UnionType)
 
     # Cache method signatures to avoid inspection on every call
     # Inspecting a function signature can take ~ half a second in Python 3.7
@@ -204,7 +212,7 @@ class _TypeValidator:
             if value.skip_type == expected_type:
                 return True
 
-        if isinstance(expected_type, cls.__generic_metaclass):
+        if any(map(lambda _t: isinstance(expected_type, _t),  cls.__generic_metaclass)):
 
             origin = util.get_origin(expected_type)
             args = util.get_args(expected_type)
@@ -240,6 +248,33 @@ class _TypeValidator:
                     all(map(lambda k: cls._validate_type(key_type, k), value.keys())) and \
                     all(map(lambda v: cls._validate_type(value_type, v), value.values()))
 
+            if origin is type:
+
+                if not isinstance(value, type):
+                    return False
+
+                type_arg = args[0]
+
+                if type_arg == tp.Any:
+                    return True
+
+                if isinstance(type_arg, tp.TypeVar):
+
+                    constraints =  util.get_constraints(type_arg)
+                    bound = util.get_bound(type_arg)
+
+                    if constraints:
+                        if not any(map(lambda c: expected_type == c, constraints)):
+                            return False
+
+                    if bound:
+                        if not issubclass(expected_type, bound):
+                            return False
+
+                    # So long as constraints / bound are ok, any type matches a generic type var
+                    return True
+
+
             if origin.__module__.startswith("tracdap.rt.api."):
                 return isinstance(value, origin)
 
@@ -274,7 +309,7 @@ class _TypeValidator:
     @classmethod
     def _type_name(cls, type_var: tp.Type, qualified: bool = False) -> str:
 
-        if isinstance(type_var, cls.__generic_metaclass):
+        if any(map(lambda _t: isinstance(type_var, _t),  cls.__generic_metaclass)):
 
             origin = util.get_origin(type_var)
             args = util.get_args(type_var)
@@ -291,7 +326,11 @@ class _TypeValidator:
 
             if origin is list:
                 list_type = cls._type_name(args[0])
-                return f"List[{list_type}]"
+                return f"list[{list_type}]"
+
+            if origin is type:
+                type_arg = cls._type_name(args[0])
+                return f"type[{type_arg}]"
 
             raise ex.ETracInternal(f"Validation of [{origin.__name__}] generic parameters is not supported yet")
 
@@ -457,18 +496,20 @@ class StaticValidator:
             else:
                 return
 
-        fields = socket.schema.table.fields
-        field_names = list(map(lambda f: f.fieldName, fields))
-        property_type = f"field in [{socket_name}]"
+        if socket.schema.schemaType == meta.SchemaType.TABLE:
 
-        if len(fields) == 0:
-            cls._fail(f"Invalid schema for [{socket_name}]: No fields defined")
+            fields = socket.schema.table.fields
+            field_names = list(map(lambda f: f.fieldName, fields))
+            property_type = f"field in [{socket_name}]"
 
-        cls._valid_identifiers(field_names, property_type)
-        cls._case_insensitive_duplicates(field_names, property_type)
+            if len(fields) == 0:
+                cls._fail(f"Invalid schema for [{socket_name}]: No fields defined")
 
-        for field in fields:
-            cls._check_single_field(field, property_type)
+            cls._valid_identifiers(field_names, property_type)
+            cls._case_insensitive_duplicates(field_names, property_type)
+
+            for field in fields:
+                cls._check_single_field(field, property_type)
 
     @classmethod
     def _check_socket_file_type(cls, socket_name, socket):

tracdap/rt/_impl/exec/context.py

@@ -29,6 +29,7 @@ import tracdap.rt.exceptions as _ex
 import tracdap.rt._impl.core.data as _data
 import tracdap.rt._impl.core.logging as _logging
 import tracdap.rt._impl.core.storage as _storage
+import tracdap.rt._impl.core.struct as _struct
 import tracdap.rt._impl.core.type_system as _types
 import tracdap.rt._impl.core.util as _util
 import tracdap.rt._impl.core.validation as _val
@@ -184,7 +185,25 @@ class TracContextImpl(_api.TracContext):
     def get_polars_table(self, dataset_name: str) -> "_data.polars.DataFrame":
 
         return self.get_table(dataset_name, _eapi.POLARS)
-    
+
+    def get_struct(self, struct_name: str, python_class: type[_eapi.STRUCT_TYPE] = None) -> _eapi.STRUCT_TYPE:
+
+        _val.validate_signature(self.get_struct, struct_name, python_class)
+
+        self.__val.check_item_valid_identifier(struct_name, TracContextValidator.DATASET)
+        self.__val.check_item_defined_in_model(struct_name, TracContextValidator.DATASET)
+        self.__val.check_item_available_in_context(struct_name, TracContextValidator.DATASET)
+
+        data_view: _data.DataView = self.__local_ctx.get(struct_name)
+        part_key = _data.DataPartKey.for_root()
+
+        self.__val.check_context_object_type(struct_name, data_view, _data.DataView)
+        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)
+
     def get_file(self, file_name: str) -> bytes:
 
         _val.validate_signature(self.get_file, file_name)
@@ -199,7 +218,7 @@ class TracContextImpl(_api.TracContext):
         self.__val.check_context_data_view_type(file_name, file_view, _meta.ObjectType.FILE)
         self.__val.check_file_content_present(file_name, file_view)
         
-        return file_view.file_item.raw_bytes
+        return file_view.file_item.content
 
     def get_file_stream(self, file_name: str) -> tp.ContextManager[tp.BinaryIO]:
 
@@ -274,13 +293,15 @@ class TracContextImpl(_api.TracContext):
         # Prefer static schemas for data conformance
 
         if static_schema is not None:
-            schema = _data.DataMapping.trac_to_arrow_schema(static_schema)
+            trac_schema = static_schema
+            native_schema = _data.DataMapping.trac_to_arrow_schema(static_schema)
         else:
-            schema = data_view.arrow_schema
+            trac_schema = _data.DataMapping.arrow_to_trac_schema(data_view.arrow_schema)
+            native_schema = data_view.arrow_schema
 
         # Data conformance is applied automatically inside the converter, if schema != None
-        table = converter.to_internal(dataset, schema)
-        item = _data.DataItem(_meta.ObjectType.DATA, schema, table)
+        table = converter.to_internal(dataset, native_schema)
+        item = _data.DataItem.for_table(table, native_schema, trac_schema)
 
         updated_view = _data.DataMapping.add_item_to_view(data_view, part_key, item)
 
@@ -293,7 +314,34 @@ class TracContextImpl(_api.TracContext):
     def put_polars_table(self, dataset_name: str, dataset: "_data.polars.DataFrame"):
 
         self.put_table(dataset_name, dataset, _eapi.POLARS)
-    
+
+    def put_struct(self, struct_name: str, struct: _eapi.STRUCT_TYPE):
+
+        _val.validate_signature(self.put_struct, struct_name, struct)
+
+        self.__val.check_item_valid_identifier(struct_name, TracContextValidator.DATASET)
+        self.__val.check_item_is_model_output(struct_name, TracContextValidator.DATASET)
+
+        static_schema = self.__get_static_schema(self.__model_def, struct_name)
+        data_view = self.__local_ctx.get(struct_name)
+        part_key = _data.DataPartKey.for_root()
+
+        if data_view is None:
+            if static_schema is not None:
+                data_view = _data.DataView.for_trac_schema(static_schema)
+            else:
+                data_view = _data.DataView.create_empty()
+
+        self.__val.check_context_object_type(struct_name, data_view, _data.DataView)
+        self.__val.check_context_data_view_type(struct_name, data_view, _meta.ObjectType.DATA)
+        self.__val.check_dataset_schema_defined(struct_name, data_view)
+        self.__val.check_dataset_part_not_present(struct_name, data_view, part_key)
+
+        data_item = _data.DataItem.for_struct(struct)
+        updated_view = _data.DataMapping.add_item_to_view(data_view, part_key, data_item)
+
+        self.__local_ctx[struct_name] = updated_view
+
     def put_file(self, file_name: str, file_content: tp.Union[bytes, bytearray]):
 
         _val.validate_signature(self.put_file, file_name, file_content)
@@ -840,7 +888,13 @@ class TracContextValidator(TracContextErrorReporter):
 
         schema = data_view.trac_schema if data_view is not None else None
 
-        if schema is None or schema.table is None or not schema.table.fields:
+        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):
+            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):
             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):
@@ -945,12 +999,12 @@ class TracContextValidator(TracContextErrorReporter):
 
     def check_file_content_present(self, file_name: str, file_view: _data.DataView):
 
-        if file_view.file_item is None or not file_view.file_item.raw_bytes:
+        if file_view.file_item is None or file_view.file_item.content is None:
             self._report_error(f"File content is missing or empty for [{file_name}] in the current context")
 
     def check_file_content_not_present(self, file_name: str, file_view: _data.DataView):
 
-        if file_view.file_item is not None and file_view.file_item.raw_bytes:
+        if file_view.file_item is not None and file_view.file_item.content is not None:
             self._report_error(f"File content is already present for [{file_name}] in the current context")
 
     def check_storage_valid_identifier(self, storage_key):

tracdap/rt/_impl/exec/dev_mode.py

@@ -38,12 +38,12 @@ DEV_MODE_JOB_CONFIG = [
     re.compile(r"job\.\w+\.model"),
     re.compile(r"job\.\w+\.flow"),
 
-    re.compile(r".*\.jobs\.\d+\.\w+\.parameters\.\w+"),
-    re.compile(r".*\.jobs\.\d+\.\w+\.inputs\.\w+"),
-    re.compile(r".*\.jobs\.\d+\.\w+\.outputs\.\w+"),
-    re.compile(r".*\.jobs\.\d+\.\w+\.models\.\w+"),
-    re.compile(r".*\.jobs\.\d+\.\w+\.model"),
-    re.compile(r".*\.jobs\.\d+\.\w+\.flow")
+    re.compile(r".*\.jobs\[\d+]\.\w+\.parameters\.\w+"),
+    re.compile(r".*\.jobs\[\d+]\.\w+\.inputs\.\w+"),
+    re.compile(r".*\.jobs\[\d+]\.\w+\.outputs\.\w+"),
+    re.compile(r".*\.jobs\[\d+]\.\w+\.models\.\w+"),
+    re.compile(r".*\.jobs\[\d+]\.\w+\.model"),
+    re.compile(r".*\.jobs\[\d+]\.\w+\.flow")
 ]
 
 DEV_MODE_SYS_CONFIG = []
@@ -765,10 +765,15 @@ class DevModeTranslator:
             else:
                 p_spec = param_specs[p_name]
 
-                cls._log.info(f"Encoding parameter [{p_name}] as {p_spec.paramType.basicType.name}")
+                try:
+                    cls._log.info(f"Encoding parameter [{p_name}] as {p_spec.paramType.basicType.name}")
+                    encoded_value = _types.MetadataCodec.convert_value(p_value, p_spec.paramType)
+                    encoded_values[p_name] = encoded_value
 
-                encoded_value = _types.MetadataCodec.convert_value(p_value, p_spec.paramType)
-                encoded_values[p_name] = encoded_value
+                except Exception as e:
+                    msg = f"Failed to encode parameter [{p_name}]: {str(e)}"
+                    cls._log.error(msg)
+                    raise _ex.EConfigParse(msg) from e
 
         return encoded_values
 
@@ -842,7 +847,7 @@ class DevModeTranslator:
         if isinstance(data_value, str):
             storage_path = data_value
             storage_key = self._sys_config.storage.defaultBucket
-            storage_format = self.infer_format(storage_path, self._sys_config.storage)
+            storage_format = self.infer_format(storage_path, self._sys_config.storage, schema)
             snap_version = 1
 
         elif isinstance(data_value, dict):
@@ -853,7 +858,7 @@ class DevModeTranslator:
                 raise _ex.EConfigParse(f"Invalid configuration for input [{data_key}] (missing required value 'path'")
 
             storage_key = data_value.get("storageKey") or self._sys_config.storage.defaultBucket
-            storage_format = data_value.get("format") or self.infer_format(storage_path, self._sys_config.storage)
+            storage_format = data_value.get("format") or self.infer_format(storage_path, self._sys_config.storage, schema)
             snap_version = 1
 
         else:
@@ -939,12 +944,18 @@ class DevModeTranslator:
         return file_id
 
     @staticmethod
-    def infer_format(storage_path: str, storage_config: _cfg.StorageConfig):
+    def infer_format(storage_path: str, storage_config: _cfg.StorageConfig, schema: tp.Optional[_meta.SchemaDefinition]):
+
+        schema_type = schema.schemaType if schema and schema.schemaType else _meta.SchemaType.TABLE
 
         if re.match(r'.*\.\w+$', storage_path):
             extension = pathlib.Path(storage_path).suffix
-            codec = _storage.FormatManager.get_data_format(extension, format_options={})
-            return codec.format_code()
+            # Only try to map TABLE codecs through IDataFormat for now
+            if schema_type == _meta.SchemaType.TABLE:
+                codec = _storage.FormatManager.get_data_format(extension, format_options={})
+                return codec.format_code()
+            else:
+                return extension[1:] if extension.startswith(".") else extension
 
         else:
             return storage_config.defaultFormat