mainsequence 4.1.2__tar.gz → 4.1.3__tar.gz

{mainsequence-4.1.2 → mainsequence-4.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.1.2
+Version: 4.1.3
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.1.2 → mainsequence-4.1.3}/mainsequence/client/dtype_codec.py

@@ -163,9 +163,7 @@ def record_definitions_to_column_dtypes_map(
         )
 
     if duplicate_columns:
-        raise ValueError(
-            f"Duplicate DataNode record column names: {sorted(duplicate_columns)}"
-        )
+        raise ValueError(f"Duplicate DataNode record column names: {sorted(duplicate_columns)}")
 
     return column_dtypes_map
 
@@ -247,10 +245,14 @@ def token_to_pandas_series(
     is_time_index: bool = False,
     nullable: bool = True,
 ) -> pd.Series:
-    normalized = TIMESTAMP_TZ if is_time_index else normalize_dtype_token(
-        token,
-        remote=False,
-        allow_naive_datetime=True,
+    normalized = (
+        TIMESTAMP_TZ
+        if is_time_index
+        else normalize_dtype_token(
+            token,
+            remote=False,
+            allow_naive_datetime=True,
+        )
     )
     if normalized == TIMESTAMP_TZ:
         return pd.to_datetime(series, errors="coerce", utc=True)
@@ -319,17 +321,15 @@ def _serialize_timestamp_tz_value(value: Any) -> str | None:
         raise ValueError(
             f"Remote datetime value {value!r} must include an explicit timezone offset or Z."
         )
-    if isinstance(value, (pd.Timestamp, datetime.datetime)) and not _timestamp_is_timezone_aware(value):
-        raise ValueError(
-            f"Remote datetime value {value!r} must be timezone-aware."
-        )
+    if isinstance(value, (pd.Timestamp, datetime.datetime)) and not _timestamp_is_timezone_aware(
+        value
+    ):
+        raise ValueError(f"Remote datetime value {value!r} must be timezone-aware.")
     timestamp = pd.to_datetime(value, errors="raise", utc=True)
     if not isinstance(timestamp, pd.Timestamp):
         timestamp = pd.Timestamp(timestamp).tz_convert("UTC")
     if timestamp.tzinfo is None:
-        raise ValueError(
-            f"Remote datetime value {value!r} must be timezone-aware."
-        )
+        raise ValueError(f"Remote datetime value {value!r} must be timezone-aware.")
     timestamp = timestamp.tz_convert("UTC")
     return timestamp.isoformat().replace("+00:00", "Z")
 
@@ -375,11 +375,8 @@ def prepare_dataframe_for_remote_write(
         if column_name not in prepared.columns:
             continue
         normalized = normalize_dtype_token(token, remote=True)
-        if normalized not in {DATE, TIMESTAMP_TZ}:
-            continue
         prepared[column_name] = [
-            serialize_remote_value(value, normalized)
-            for value in prepared[column_name].tolist()
+            serialize_remote_value(value, normalized) for value in prepared[column_name].tolist()
         ]
     return prepared
 
@@ -459,7 +456,11 @@ def sqlalchemy_type_to_token(column_type: Any, *, remote: bool = True) -> str:
                     "by the remote TS Manager contract."
                 )
             return LOCAL_DATETIME_NAIVE
-        if timezone is True or "with time zone" in normalized_backend or "timestamptz" in normalized_backend:
+        if (
+            timezone is True
+            or "with time zone" in normalized_backend
+            or "timestamptz" in normalized_backend
+        ):
             return TIMESTAMP_TZ
         if remote:
             raise ValueError(

{mainsequence-4.1.2 → mainsequence-4.1.3}/mainsequence/client/models_metatables.py

@@ -1244,9 +1244,6 @@ class MetaTable(BasePydanticModel, LabelableObjectMixin, ShareableObjectMixin, B
         )
 
 
-LOGICAL_COLUMN_DTYPES_ATTR = "mainsequence_column_dtypes_map"
-
-
 def _warn_legacy_compat(message: str, *, stacklevel: int = 3) -> None:
     warnings.warn(
         f"Deprecated TDAG compatibility path: {message}",
@@ -2143,7 +2140,6 @@ class DataNodeUpdate(TableUpdateNode, BaseObjectOrm):
         remote_dtypes: bool = True,
         allow_naive_datetime: bool = False,
     ):
-        logical_column_dtypes_map = data_frame.attrs.get(LOGICAL_COLUMN_DTYPES_ATTR)
         record_column_dtypes_map = record_definitions_to_column_dtypes_map(
             records,
             remote=remote_dtypes,
@@ -2178,40 +2174,6 @@ class DataNodeUpdate(TableUpdateNode, BaseObjectOrm):
                 "DataNode records declare columns not present in the DataFrame: "
                 f"{missing_record_columns}"
             )
-        if logical_column_dtypes_map is not None:
-            logical_column_dtypes_map = normalize_column_dtypes_map(
-                logical_column_dtypes_map,
-                remote=remote_dtypes,
-                allow_naive_datetime=allow_naive_datetime,
-            )
-            missing_logical_columns = [
-                column_name
-                for column_name in logical_column_dtypes_map
-                if column_name not in data_frame.columns
-            ]
-            if missing_logical_columns:
-                raise ValueError(
-                    "Logical column dtype contract contains columns not present "
-                    f"in the DataFrame: {missing_logical_columns}"
-                )
-            conflicting_declared_dtypes = {
-                column_name: {
-                    "record_dtype": record_column_dtypes_map[column_name],
-                    "logical_dtype": logical_column_dtypes_map[column_name],
-                }
-                for column_name in logical_column_dtypes_map
-                if (
-                    column_name in record_column_dtypes_map
-                    and logical_column_dtypes_map[column_name]
-                    != record_column_dtypes_map[column_name]
-                )
-            }
-            if conflicting_declared_dtypes:
-                raise ValueError(
-                    "Logical column dtype contract conflicts with DataNode records: "
-                    f"{conflicting_declared_dtypes}"
-                )
-            column_dtypes_map.update(logical_column_dtypes_map)
         column_dtypes_map.update(record_column_dtypes_map)
 
         data_frame = data_frame.replace({np.nan: None})
@@ -3970,10 +3932,70 @@ class UpdateStatistics(BaseUpdateStatistics):
 def _assign_nested_coordinate(root: dict[Any, Any], keys: list[Any], value: Any) -> None:
     if not keys:
         return
+    normalized_keys = [_normalize_update_stat_key(key) for key in keys]
     sub = root
-    for key in keys[:-1]:
-        sub = sub.setdefault(key, {})
-    sub[keys[-1]] = value
+    for key in normalized_keys[:-1]:
+        existing = sub.setdefault(key, {})
+        if not isinstance(existing, dict):
+            raise ValueError("Update statistics coordinate keys collide after JSON normalization.")
+        sub = existing
+    final_key = normalized_keys[-1]
+    if final_key in sub:
+        raise ValueError("Update statistics coordinate keys collide after JSON normalization.")
+    sub[final_key] = value
+
+
+def _normalize_update_stat_key(key: Any) -> str:
+    if isinstance(key, str):
+        return key
+    if isinstance(key, np.generic):
+        key = key.item()
+    if isinstance(key, datetime.datetime):
+        value = serialize_to_json({"_": key})["_"]
+        return str(value)
+    if isinstance(key, datetime.date):
+        return key.isoformat()
+    if key is None:
+        return "null"
+    if isinstance(key, bool):
+        return "true" if key else "false"
+    if isinstance(key, int | float):
+        try:
+            return json.dumps(key, allow_nan=False)
+        except (TypeError, ValueError):
+            return str(key)
+
+    normalized = serialize_to_json({key: None})
+    normalized_key = next(iter(normalized.keys()))
+    if normalized_key is None:
+        return "null"
+    if isinstance(normalized_key, bool):
+        return "true" if normalized_key else "false"
+    if isinstance(normalized_key, int | float):
+        try:
+            return json.dumps(normalized_key, allow_nan=False)
+        except (TypeError, ValueError):
+            return str(normalized_key)
+    return str(normalized_key)
+
+
+def _normalize_update_stat_mapping_keys(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        normalized: dict[str, Any] = {}
+        for key, item in value.items():
+            normalized_key = _normalize_update_stat_key(key)
+            if normalized_key in normalized:
+                raise ValueError(
+                    "Update statistics coordinate keys collide after JSON normalization: "
+                    f"{normalized_key!r}."
+                )
+            normalized[normalized_key] = _normalize_update_stat_mapping_keys(item)
+        return normalized
+    if isinstance(value, list):
+        return [_normalize_update_stat_mapping_keys(item) for item in value]
+    if isinstance(value, tuple):
+        return [_normalize_update_stat_mapping_keys(item) for item in value]
+    return value
 
 
 def get_index_progress_chunk_stats(chunk_df, time_index_name, index_names):
@@ -4081,6 +4103,11 @@ class LastUpdateMultiIndexStatsPayload(BaseModel):
     index_progress: dict[str, Any] = Field(default_factory=dict)
     index_min: dict[str, Any] = Field(default_factory=dict)
 
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_mapping_keys(cls, value: Any) -> Any:
+        return _normalize_update_stat_mapping_keys(value)
+
     def to_payload(self) -> dict[str, Any]:
         return {
             "_GLOBAL_": self.global_stats,
@@ -4099,6 +4126,11 @@ class LastUpdateIndexTimePayload(BaseModel):
     multi_index_stats: LastUpdateMultiIndexStatsPayload | None = None
     multi_index_column_stats: dict[str, Any] | None = Field(default_factory=dict)
 
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_mapping_keys(cls, value: Any) -> Any:
+        return _normalize_update_stat_mapping_keys(value)
+
     @model_validator(mode="after")
     def _validate_shape(self):
         top_level_progress_keys = [
@@ -4164,7 +4196,8 @@ def build_last_update_index_time_payload(
             }
         )
 
-    return LastUpdateIndexTimePayload.model_validate(raw_payload).to_nested_payload()
+    normalized_payload = _normalize_update_stat_mapping_keys(raw_payload)
+    return LastUpdateIndexTimePayload.model_validate(normalized_payload).to_nested_payload()
 
 
 class HistoricalUpdateRecord:

{mainsequence-4.1.2 → mainsequence-4.1.3}/mainsequence/client/utils.py

@@ -9,11 +9,11 @@ import socket
 import subprocess
 import threading
 import time
-import uuid
 from dataclasses import dataclass, field
 from decimal import Decimal
 from enum import Enum
 from typing import TypedDict
+from uuid import UUID, getnode
 
 import psutil
 import pytz
@@ -761,6 +761,9 @@ def serialize_to_json(kwargs):
         if isinstance(v, Decimal):
             return str(v)
 
+        if isinstance(v, UUID):
+            return str(v)
+
         if isinstance(v, datetime.datetime):
             dt = v
             if dt.tzinfo is None:
@@ -776,13 +779,19 @@ def serialize_to_json(kwargs):
                 return v.model_dump()
 
         if isinstance(v, dict):
-            return {k: to_jsonable(x) for k, x in v.items()}
+            return {to_json_key(k): to_jsonable(x) for k, x in v.items()}
         if isinstance(v, (list, tuple)):
             return [to_jsonable(x) for x in v]
 
         return v
 
-    return {k: to_jsonable(v) for k, v in kwargs.items()}
+    def to_json_key(value):
+        key = to_jsonable(value)
+        if key is None or isinstance(key, str | int | float | bool):
+            return key
+        return str(key)
+
+    return {to_json_key(k): to_jsonable(v) for k, v in kwargs.items()}
 
 
 def _linux_machine_id() -> str | None:
@@ -839,7 +848,7 @@ def bios_uuid() -> str:
         return mid
 
     # Tier 4 – MAC address (uuid.getnode). Always available.
-    return f"{uuid.getnode():012x}"
+    return f"{getnode():012x}"
 
 
 def _install_retry_adapters_in_place(

{mainsequence-4.1.2 → mainsequence-4.1.3}/mainsequence/meta_tables/data_nodes/build_operations.py

@@ -13,6 +13,7 @@ from enum import Enum
 from functools import singledispatch
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
+from uuid import UUID
 
 from pydantic import BaseModel
 
@@ -111,6 +112,11 @@ def _(value: datetime.datetime) -> str:
     return value.isoformat()
 
 
+@serialize_argument.register(UUID)
+def _(value: UUID) -> str:
+    return str(value)
+
+
 @serialize_argument.register(BaseModel)
 def _(value: BaseModel) -> dict[str, Any]:
     """Serialization logic for any Pydantic BaseModel."""

{mainsequence-4.1.2 → mainsequence-4.1.3}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -438,11 +438,22 @@ class BasePersistManager:
                 data=temp_df,
                 data_source=self.data_source,
                 overwrite=overwrite,
+                source_table_schema=self._source_table_schema(),
             )
 
             persisted = True
         return persisted
 
+    def _source_table_schema(self) -> dict[str, Any]:
+        time_index_name, index_names, column_dtypes_map = (
+            self.storage_metadata._require_time_indexed_table_contract()
+        )
+        return {
+            "time_index_name": time_index_name,
+            "index_names": list(index_names),
+            "column_dtypes_map": dict(column_dtypes_map),
+        }
+
     def get_update_statistics_for_table(self) -> UpdateStatistics:
         return self.storage_metadata.get_data_updates()
 

{mainsequence-4.1.2 → mainsequence-4.1.3}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.1.2
+Version: 4.1.3
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.1.2 → mainsequence-4.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "4.1.2"
+version = "4.1.3"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.11"

{mainsequence-4.1.2 → mainsequence-4.1.3}/tests/test_build_operations_hashing.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import datetime
 import os
+import uuid
 
 import pytest
 from pydantic import BaseModel, Field
@@ -24,6 +25,10 @@ def _hashes(payload):
     return build_operations.hash_signature({"config": serialized_payload})
 
 
+class UUIDNodeConfig(BaseModel):
+    account_uid: uuid.UUID
+
+
 def test_create_config_crops_hash_prefix_to_postgres_identifier_limit(monkeypatch):
     monkeypatch.setattr(build_operations, "POD_PROJECT", None, raising=False)
 
@@ -211,6 +216,35 @@ def test_platform_time_index_metadata_config_hashes_by_bound_metadata_uid(monkey
     )
 
 
+def test_uuid_config_values_serialize_hash_and_rebuild(monkeypatch):
+    monkeypatch.setattr(build_operations, "POD_PROJECT", None, raising=False)
+
+    account_uid = uuid.UUID("00000000-0000-4000-8000-000000000001")
+    other_account_uid = uuid.UUID("00000000-0000-4000-8000-000000000002")
+
+    serialized = build_operations.serialize_argument(UUIDNodeConfig(account_uid=account_uid))
+    assert serialized["serialized_model"]["account_uid"] == str(account_uid)
+
+    hashes_a = _hashes(UUIDNodeConfig(account_uid=account_uid))
+    hashes_b = _hashes(UUIDNodeConfig(account_uid=account_uid))
+    hashes_c = _hashes(UUIDNodeConfig(account_uid=other_account_uid))
+
+    assert hashes_a == hashes_b
+    assert hashes_a != hashes_c
+
+    config = build_operations.create_config(
+        ts_class_name="UUIDConfigNode",
+        kwargs={"config": UUIDNodeConfig(account_uid=account_uid)},
+    )
+    rebuilt = build_operations.DeserializerManager().rebuild_serialized_config(
+        config.local_initial_configuration,
+        time_serie_class_name="UUIDConfigNode",
+    )
+
+    assert rebuilt["config"].account_uid == account_uid
+    assert isinstance(rebuilt["config"].account_uid, uuid.UUID)
+
+
 def test_plain_dict_with_pydantic_model_import_path_key_is_not_treated_as_wrapper(monkeypatch):
     monkeypatch.setattr(build_operations, "POD_PROJECT", None, raising=False)
 

{mainsequence-4.1.2 → mainsequence-4.1.3}/tests/test_data_node_update_flow.py

@@ -3,6 +3,7 @@ import datetime
 import gzip
 import json
 from types import SimpleNamespace
+from uuid import UUID
 
 import pandas as pd
 import pytest
@@ -127,6 +128,72 @@ def test_post_data_frame_in_chunks_serializes_remote_temporal_payload_columns(mo
     ]
 
 
+def test_post_data_frame_in_chunks_serializes_remote_uuid_payload_columns(monkeypatch):
+    captured = {}
+
+    class FakeResponse:
+        status_code = 200
+        text = ""
+        content = b'{"ok": true}'
+
+        @staticmethod
+        def json():
+            return {"ok": True}
+
+    def _fake_make_request(*, s, loaders, payload, r_type, url, time_out=None):
+        captured["payload"] = payload
+        captured["r_type"] = r_type
+        captured["url"] = url
+        return FakeResponse()
+
+    monkeypatch.setattr(models_metatables, "make_request", _fake_make_request)
+    monkeypatch.setattr(
+        models_metatables.DataNodeUpdate,
+        "build_session",
+        classmethod(lambda cls: object()),
+    )
+
+    account_uid = UUID("00000000-0000-4000-8000-000000000001")
+    frame = pd.DataFrame(
+        {
+            "time_index": [pd.Timestamp("2026-05-29T13:40:00Z")],
+            "account_uid": [account_uid],
+            "unique_identifier": ["AAPL"],
+            "quantity": [12.0],
+        }
+    )
+
+    models_metatables.DataNodeUpdate.post_data_frame_in_chunks(
+        serialized_data_frame=frame,
+        data_node_update=_minimal_update(),
+        index_names=["time_index", "account_uid", "unique_identifier"],
+        time_index_name="time_index",
+        column_dtypes_map={
+            "time_index": "timestamp with time zone",
+            "account_uid": "uuid",
+            "unique_identifier": "string",
+            "quantity": "float64",
+        },
+    )
+
+    decoded = _decode_compressed_payload(captured["payload"])
+    assert decoded == [
+        {
+            "time_index": "2026-05-29T13:40:00Z",
+            "account_uid": str(account_uid),
+            "unique_identifier": "AAPL",
+            "quantity": 12.0,
+        }
+    ]
+    json.dumps(captured["payload"]["json"], allow_nan=False)
+    assert captured["payload"]["json"]["chunk_stats"]["index_progress"] == {
+        str(account_uid): {"AAPL": "2026-05-29T13:40:00Z"}
+    }
+    assert captured["payload"]["json"]["chunk_stats"]["index_min"] == {
+        str(account_uid): {"AAPL": "2026-05-29T13:40:00Z"}
+    }
+
+
 def test_set_start_of_execution_prefers_canonical_update_stats(monkeypatch):
     class FakeResponse:
         status_code = 201
@@ -243,6 +310,50 @@ def test_last_update_payload_model_rejects_unknown_keys_generically():
         )
 
 
+def test_last_update_payload_builder_normalizes_nested_coordinate_keys():
+    account_uid = UUID("00000000-0000-4000-8000-000000000001")
+    raw_payload = {
+        "global_index_progress": {
+            "max": _dt(3),
+            "min": _dt(0),
+        },
+        "index_progress": {account_uid: {101: _dt(2)}},
+        "index_min": {account_uid: {101: _dt(0)}},
+        "multi_index_column_stats": {
+            "quantity": {
+                account_uid: {
+                    101: {
+                        "min": _dt(0),
+                        "max": _dt(2),
+                    }
+                }
+            }
+        },
+    }
+
+    payload = models_metatables.LastUpdateIndexTimePayload.model_validate(
+        raw_payload
+    ).to_nested_payload()
+    builder_payload = models_metatables.build_last_update_index_time_payload(
+        **raw_payload,
+    )
+
+    account_key = str(account_uid)
+    assert payload["multi_index_stats"]["index_progress"] == {account_key: {"101": _dt(2)}}
+    assert payload["multi_index_stats"]["index_min"] == {account_key: {"101": _dt(0)}}
+    assert payload["multi_index_column_stats"] == {
+        "quantity": {
+            account_key: {
+                "101": {
+                    "min": _dt(0),
+                    "max": _dt(2),
+                }
+            }
+        }
+    }
+    assert builder_payload == payload
+
+
 def test_set_last_update_index_time_from_update_stats_sends_canonical_payload(monkeypatch):
     captured = {}
 
@@ -335,6 +446,28 @@ def test_get_index_progress_chunk_stats_for_three_index_frame():
     assert grouped_dates is not None
 
 
+def test_get_index_progress_chunk_stats_normalizes_uuid_coordinate_keys():
+    account_uid = UUID("00000000-0000-4000-8000-000000000001")
+    df = pd.DataFrame(
+        {
+            "time_index": [_dt(0), _dt(2)],
+            "account_uid": [account_uid, account_uid],
+            "unique_identifier": ["asset-1", "asset-1"],
+            "value": [1, 2],
+        }
+    )
+
+    stats, grouped_dates = models_metatables.get_index_progress_chunk_stats(
+        df,
+        time_index_name="time_index",
+        index_names=["time_index", "account_uid", "unique_identifier"],
+    )
+
+    assert stats["index_progress"] == {str(account_uid): {"asset-1": _dt(2)}}
+    assert stats["index_min"] == {str(account_uid): {"asset-1": _dt(0)}}
+    assert grouped_dates is not None
+
+
 def test_set_last_update_index_time_rejects_legacy_per_asset_backend_payload(monkeypatch):
     def _unexpected_make_request(**_kwargs):
         raise AssertionError("legacy backend payload should fail before make_request")

{mainsequence-4.1.2 → mainsequence-4.1.3}/tests/test_run_configuration.py

@@ -214,6 +214,70 @@ def test_persist_manager_build_update_details_uses_update_details_resource():
     assert patched == [("data-node-update-44", {})]
 
 
+def test_persist_manager_passes_storage_contract_schema_to_update():
+    captured = {}
+
+    class UpdateResource:
+        build_configuration = {}
+
+        def upsert_data_into_table(self, **kwargs):
+            captured.update(kwargs)
+            return self
+
+    storage_metadata = TimeIndexMetaData.model_construct(
+        uid="data-node-storage-44",
+        data_source_uid="data-source-uid",
+        data_source=SimpleNamespace(
+            related_resource=SimpleNamespace(class_type="postgres"),
+        ),
+        time_indexed_profile=models_metatables.TimeIndexedProfile(
+            related_table_uid="data-node-storage-44",
+            time_index_name="time_index",
+            index_names=["time_index", "account_uid", "unique_identifier"],
+            column_dtypes_map={
+                "time_index": "timestamp with time zone",
+                "account_uid": "uuid",
+                "unique_identifier": "string",
+                "quantity": "float64",
+            },
+            storage_layout={
+                "time_index": "time_index",
+                "identity_dimensions": ["account_uid", "unique_identifier"],
+            },
+            physical_index_plan={
+                "uniqueness": {
+                    "columns": ["time_index", "account_uid", "unique_identifier"],
+                },
+            },
+        ),
+    )
+    storage_table = _platform_storage_model(storage_metadata)
+    manager = BasePersistManager(
+        update_hash="account-holdings-update-hash",
+        storage_table=storage_table,
+        data_node_update=UpdateResource(),
+    )
+    df = pd.DataFrame(
+        {"quantity": [12.0]},
+        index=pd.MultiIndex.from_tuples(
+            [("2026-05-30T12:00:00Z", "account-a", "AAPL")],
+            names=["time_index", "account_uid", "unique_identifier"],
+        ),
+    )
+
+    assert manager.persist_updated_data(df) is True
+    assert captured["source_table_schema"] == {
+        "time_index_name": "time_index",
+        "index_names": ["time_index", "account_uid", "unique_identifier"],
+        "column_dtypes_map": {
+            "time_index": "timestamp with time zone",
+            "account_uid": "uuid",
+            "unique_identifier": "string",
+            "quantity": "float64",
+        },
+    }
+
+
 def test_data_node_storage_accepts_namespace():
     storage = TimeIndexMetaData(
         uid="data-node-storage-12",