mainsequence 4.3.0__tar.gz → 4.3.6__tar.gz

{mainsequence-4.3.0/mainsequence.egg-info → mainsequence-4.3.6}/PKG-INFO

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

{mainsequence-4.3.0 → mainsequence-4.3.6}/agent_scaffold/skills/data_publishing/data_nodes/SKILL.md

@@ -159,6 +159,7 @@ class PricesTable(PlatformTimeIndexMetaTable, Base):
         "risk analytics."
     )
     __time_index_name__ = "time_index"
+    __cadence__ = "1d"
     __index_names__ = ["time_index", "unique_identifier"]
 
     time_index: Mapped[datetime.datetime] = mapped_column(
@@ -197,6 +198,12 @@ autogenerate runs. Do not manually repeat the full grain unique index in
 `__table_args__`; add ordinary SQLAlchemy `Index(...)` entries only for
 additional lookup/performance paths.
 
+When the dataset has a known stable observation interval, declare `__cadence__`
+on the `PlatformTimeIndexMetaTable` model, for example `1m`, `5m`, `1h`, `1d`,
+`1w`, `1mo`, `1q`, or `1y`. Cadence is table metadata and should be included
+whenever possible; do not make it a DataNode runtime configuration field unless
+changing it actually changes the produced dataset identity.
+
 `PlatformTimeIndexMetaTable.register()` remains SDK plumbing for the migration
 workflow. Do not manually attach an existing UID, reconstruct a generic
 `MetaTable`, or use manual bind helpers as an authoring step.

{mainsequence-4.3.0 → mainsequence-4.3.6}/agent_scaffold/skills/data_publishing/meta_tables/SKILL.md

@@ -137,6 +137,11 @@ first version, use Alembic. Keep the SDK model as a normal
 `PlatformManagedMetaTable` or `PlatformTimeIndexMetaTable` catalog contract, and
 apply physical schema changes through the Alembic migration workflow.
 
+For `PlatformTimeIndexMetaTable`, declare `__cadence__` whenever the table has a
+known stable observation interval, for example `1m`, `5m`, `1h`, `1d`, `1w`,
+`1mo`, `1q`, or `1y`. Cadence is table metadata and belongs on the storage
+model when possible.
+
 Default-schema tables must leave SQLAlchemy `Table.schema` unset; do not write
 `__table_args__ = {"schema": "public"}` for the default PostgreSQL schema. Set
 schema metadata only for non-default schemas, using `__table_args__ = {"schema":

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence/cli/migrations.py

@@ -122,12 +122,21 @@ def _load_alembic_command(command_name: str) -> Any:
     return command
 
 
+def _coerce_alembic_version_path(version_path: str) -> str:
+    try:
+        from alembic import util
+    except ImportError as exc:
+        raise typer.BadParameter("Alembic is required for migration commands.") from exc
+    return str(util.coerce_resource_to_filename(version_path))
+
+
 def _emit_alembic_script_context(
     config: Any,
     *,
     target_revision: str | None = None,
 ) -> None:
     script_location = config.get_main_option("script_location")
+    version_locations = config.get_main_option("version_locations")
     version_table = config.get_main_option("version_table")
     version_table_schema = config.get_main_option("version_table_schema")
     version_table_label = (
@@ -135,9 +144,14 @@ def _emit_alembic_script_context(
         if version_table_schema not in (None, "")
         else version_table
     )
+    version_locations_label = (
+        version_locations.replace("\n", ", ") if version_locations else "<default>"
+    )
     _emit_status(
         "Alembic script context "
-        f"script_location={script_location} version_table={version_table_label}"
+        f"script_location={script_location} "
+        f"version_locations={version_locations_label} "
+        f"version_table={version_table_label}"
     )
     try:
         from alembic.script import ScriptDirectory
@@ -745,14 +759,17 @@ def revision(
     )
     _emit_alembic_script_context(config, target_revision=head)
     _emit_status(f"Starting Alembic revision now rev_id={resolved_rev_id}...")
+    revision_kwargs = {
+        "message": resolved_message,
+        "autogenerate": autogenerate,
+        "rev_id": resolved_rev_id,
+        "head": head,
+    }
+    version_path = migration.resolved_version_path()
+    if version_path is not None:
+        revision_kwargs["version_path"] = _coerce_alembic_version_path(version_path)
     with _forward_alembic_logging():
-        script = command.revision(
-            config,
-            message=resolved_message,
-            autogenerate=autogenerate,
-            rev_id=resolved_rev_id,
-            head=head,
-        )
+        script = command.revision(config, **revision_kwargs)
     _emit_status("Alembic revision finished.")
     _emit(
         {

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence/client/metatables/core.py

@@ -8,6 +8,7 @@ import gzip
 import json
 import math
 import os
+import re
 import time
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass
@@ -58,6 +59,24 @@ from ..utils import (
 DUCK_DB = "duck_db"
 SQLITE = "sqlite"
 LOCAL_DATA_SOURCE_CLASS_TYPES = {DUCK_DB, SQLITE}
+_TIME_INDEXED_CADENCE_RE = re.compile(
+    r"^[1-9][0-9]*(mo|s|m|h|d|w|q|y)$",
+    re.IGNORECASE,
+)
+
+
+def _normalize_time_indexed_cadence(value: Any) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).strip().lower()
+    if not normalized:
+        return None
+    if not _TIME_INDEXED_CADENCE_RE.fullmatch(normalized):
+        raise ValueError(
+            "cadence must be an interval token such as 1m, 5m, 1h, 1d, 1w, "
+            "1mo, 1q, or 1y."
+        )
+    return normalized
 
 
 def _duckdb_interface():
@@ -452,8 +471,43 @@ class MetaTableOperationScopeTable(BasePydanticModel):
 
 
 class MetaTableOperationScope(BasePydanticModel):
+    data_source_uid: str | None = Field(
+        default=None,
+        min_length=1,
+        validation_alias=AliasChoices("data_source_uid", "dataSourceUid"),
+        description=(
+            "Public UID of the DynamicTableDataSource that owns the compiled "
+            "SQL execution connection. If omitted, the SDK resolves the "
+            "configured project/session default data source. Scoped MetaTables "
+            "are the permission contract, not the source of execution routing."
+        ),
+    )
     tables: list[MetaTableOperationScopeTable] = Field(..., min_length=1)
 
+    model_config = ConfigDict(populate_by_name=True)
+
+    @model_validator(mode="after")
+    def resolve_default_data_source_uid(self):
+        if self.data_source_uid not in (None, ""):
+            self.data_source_uid = str(self.data_source_uid)
+            return self
+
+        try:
+            data_source = get_session_data_source()
+        except Exception as exc:
+            raise ValueError(
+                "MetaTable compiled SQL scope requires data_source_uid or a "
+                "configured project/session default data source."
+            ) from exc
+
+        uid = getattr(data_source, "uid", None) or getattr(data_source, "data_source_uid", None)
+        if uid in (None, ""):
+            raise ValueError(
+                "Configured project/session default data source does not expose a uid."
+            )
+        self.data_source_uid = str(uid)
+        return self
+
 
 class MetaTableOperationLimits(BasePydanticModel):
     max_rows: int | None = Field(default=None, ge=1)
@@ -632,6 +686,11 @@ class ManagedMetaTableFinalizeTableResult(BasePydanticModel):
     )
     table_kind: str = Field(..., description="Backend table kind after reconciliation.")
     time_indexed: bool = Field(..., description="Whether the MetaTable is time-indexed.")
+    cadence: str | None = Field(
+        None,
+        max_length=32,
+        description="Optional declared cadence for time-indexed MetaTables.",
+    )
     finalized: bool = Field(
         ...,
         description="True when this row was reconciled and activated by this call.",
@@ -660,6 +719,11 @@ class ManagedMetaTableFinalizeTableResult(BasePydanticModel):
         description="Per-table structured error when finalization did not activate this row.",
     )
 
+    @field_validator("cadence")
+    @classmethod
+    def _normalize_cadence(cls, value: str | None) -> str | None:
+        return _normalize_time_indexed_cadence(value)
+
     model_config = ConfigDict(extra="ignore")
 
 
@@ -1888,6 +1952,14 @@ class TimeIndexMetaTableRegistrationRequest(BasePydanticModel):
         default_factory=lambda: {"create_table": True, "if_not_exists": True}
     )
     time_index_name: str = Field(..., description="Canonical timestamp column name")
+    cadence: str | None = Field(
+        None,
+        max_length=32,
+        description=(
+            "Optional time-indexed cadence token such as 1m, 5m, 1h, 1d, "
+            "1w, 1mo, 1q, or 1y."
+        ),
+    )
     partition_strategy: str = Field(
         default="backend_default",
         description="Time-indexed MetaTable physical partitioning strategy",
@@ -1938,6 +2010,11 @@ class TimeIndexMetaTableRegistrationRequest(BasePydanticModel):
         data["table_contract"] = normalized_contract
         return data
 
+    @field_validator("cadence")
+    @classmethod
+    def _normalize_cadence(cls, value: str | None) -> str | None:
+        return _normalize_time_indexed_cadence(value)
+
 
 def _payload_get(obj: Any, key: str, default: Any = None) -> Any:
     if isinstance(obj, Mapping):
@@ -2078,6 +2155,11 @@ class TimeIndexedProfile(TimeIndexedProfileBase, BasePydanticModel):
         None, description="Public uid of the related TimeIndexMetaTable"
     )
     time_index_name: str = Field(..., max_length=100, description="Time index name")
+    cadence: str | None = Field(
+        None,
+        max_length=32,
+        description="Optional declared cadence for the time-indexed table.",
+    )
     partition_strategy: str | None = None
     last_time_index_value: datetime.datetime | None = Field(
         None, description="Last time index value"
@@ -2089,6 +2171,11 @@ class TimeIndexedProfile(TimeIndexedProfileBase, BasePydanticModel):
     physical_index_plan: dict[str, Any] | None = Field(
         None, description="Server-rendered physical index plan"
     )
+
+    @field_validator("cadence")
+    @classmethod
+    def _normalize_cadence(cls, value: str | None) -> str | None:
+        return _normalize_time_indexed_cadence(value)
     multi_index_stats: dict[str, Any] | None = Field(
         None, description="Canonical multi-index progress statistics"
     )
@@ -2928,15 +3015,6 @@ class TimeIndexMetaTable(MetaTable):
         "labels__in": "str",
         "labels__contains": "str",
     }
-    READ_QUERY_PARAMS: ClassVar[dict[str, str]] = {
-        "include_relations_detail": "bool",
-    }
-    READ_QUERY_PARAM_DESCRIPTIONS: ClassVar[dict[str, str]] = {
-        "include_relations_detail": (
-            "Expand related objects in the serializer response. "
-            "This changes response detail only and does not change which rows are returned."
-        ),
-    }
     build_configuration_json_schema: dict[str, Any] | None = Field(
         None,
         description="JSON schema describing the DataNode update build configuration.",

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence/meta_tables/compiled_sql/v1.py

@@ -34,8 +34,8 @@ def build_operation(
     Build and validate the TS Manager compiled-sql.v1 operation contract.
 
     This is the client-side protocol object. It is intentionally plain SQL plus
-    bound parameters and declared MetaTable scope, not a serialized SQLAlchemy
-    object.
+    bound parameters, an explicit execution data source, and declared MetaTable
+    scope, not a serialized SQLAlchemy object.
     """
 
     if parameters is None:
@@ -72,6 +72,7 @@ def compile_sqlalchemy_statement(
     statement: Any,
     *,
     operation: MetaTableOperation,
+    data_source_uid: str | None = None,
     scope_tables: Sequence[MetaTableOperationScopeTable | Mapping[str, Any]],
     limits: MetaTableOperationLimits | Mapping[str, Any] | None = None,
     dialect: MetaTableCompiledSQLDialect = "postgresql",
@@ -80,6 +81,11 @@ def compile_sqlalchemy_statement(
 ) -> MetaTableCompiledSQLOperation:
     """
     Compile a SQLAlchemy/Core statement into the TS Manager compiled-sql.v1 payload.
+
+    ``data_source_uid`` selects the DynamicTableDataSource connection. If it is
+    omitted, the SDK resolves the configured project/session default data source.
+    ``scope_tables`` remains the declared MetaTable permission scope for the
+    operation.
     """
 
     if dialect != "postgresql":
@@ -97,6 +103,7 @@ def compile_sqlalchemy_statement(
     )
     parameter_types = _compiled_sqlalchemy_parameter_types(compiled)
     scope = MetaTableOperationScope(
+        data_source_uid=data_source_uid,
         tables=[
             (
                 table

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence/meta_tables/data_nodes/data_nodes.py

@@ -211,7 +211,6 @@ class APIDataNode(DataAccessMixin):
     def build_from_table_name(cls, table_name: str) -> "APIDataNode":
         storage_table = TimeIndexMetaTable.get_or_none(
             physical_table_name=table_name,
-            include_relations_detail=True,
         )
         if storage_table is None:
             raise DoesNotExist(

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence/meta_tables/data_nodes/persist_managers.py

@@ -567,7 +567,6 @@ class APIPersistManager:
             result = TimeIndexMetaTable.get_or_none(
                 physical_table_name=self.storage_hash,
                 data_source__uid=self.data_source_uid,
-                include_relations_detail=True,
             )
             self._storage_table_future.set_result(result)
         except Exception as exc:

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence/meta_tables/migrations.py

@@ -101,6 +101,49 @@ class AlembicProviderPhysicalStateError(RuntimeError):
         )
 
 
+def _normalize_optional_alembic_location(value: Any, field_name: str) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        raise ValueError(f"AlembicMetaTableMigration {field_name} cannot be empty.")
+    return text
+
+
+def _normalize_alembic_version_locations(value: str | Sequence[str] | None) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    raw_locations: Sequence[str]
+    if isinstance(value, str):
+        raw_locations = [value]
+    else:
+        raw_locations = value
+
+    locations: list[str] = []
+    seen: set[str] = set()
+    for raw_location in raw_locations:
+        location = _normalize_optional_alembic_location(raw_location, "version_locations")
+        if location is None or location in seen:
+            continue
+        seen.add(location)
+        locations.append(location)
+    if not locations:
+        raise ValueError("AlembicMetaTableMigration version_locations cannot be empty.")
+    return tuple(locations)
+
+
+def _configure_alembic_version_locations(
+    config: Any,
+    version_locations: str | Sequence[str] | None,
+) -> tuple[str, ...]:
+    locations = _normalize_alembic_version_locations(version_locations)
+    if not locations:
+        return ()
+    config.set_main_option("version_locations", "\n".join(locations))
+    config.set_main_option("path_separator", "newline")
+    return locations
+
+
 class AlembicVersionMetaTable:
     """MetaTable catalog binding for Alembic's version table.
 
@@ -255,6 +298,8 @@ class AlembicMetaTableMigration:
     script_location: str
     target_metadata: Any
     alembic_registry: type[AlembicVersionMetaTable]
+    version_locations: str | Sequence[str] | None = None
+    version_path: str | None = None
     metatable_models: Sequence[type[Any]] = field(default_factory=tuple)
     after_register_metatables: Callable[[AlembicMetaTableCatalogRefreshContext], Any] | None = None
     include_name_hook: Any | None = None
@@ -273,6 +318,8 @@ class AlembicMetaTableMigration:
             self.after_register_metatables
         ):
             raise TypeError("after_register_metatables must be callable when provided.")
+        self.resolved_version_locations()
+        self.resolved_version_path()
         _normalize_provider_default_schemas(self.metatable_models)
         _ensure_provider_time_index_grain_indexes(self.metatable_models)
 
@@ -292,6 +339,23 @@ class AlembicMetaTableMigration:
     def version_table_schema(self) -> str | None:
         return self.alembic_registry.__alembic_version_schema__
 
+    def resolved_version_locations(self) -> tuple[str, ...]:
+        return _normalize_alembic_version_locations(self.version_locations)
+
+    def resolved_version_path(self) -> str | None:
+        explicit = _normalize_optional_alembic_location(self.version_path, "version_path")
+        if explicit is not None:
+            return explicit
+        locations = self.resolved_version_locations()
+        if len(locations) == 1:
+            return locations[0]
+        if len(locations) > 1:
+            raise ValueError(
+                "AlembicMetaTableMigration with multiple version_locations requires "
+                "an explicit version_path for revision generation."
+            )
+        return None
+
     def include_name(self, name: str | None, type_: str, parent_names: dict[str, Any]) -> bool:
         if self.include_name_hook is not None:
             return bool(self.include_name_hook(name, type_, parent_names))
@@ -750,6 +814,7 @@ def alembic_config_for_provider(
     if output_buffer is not None:
         config.output_buffer = output_buffer
     config.set_main_option("script_location", migration.script_location)
+    version_locations = _configure_alembic_version_locations(config, migration.version_locations)
     config.set_main_option("sqlalchemy.url", sqlalchemy_url.replace("%", "%%"))
     config.set_main_option("sqlalchemy.echo", "true")
     config.set_main_option("version_table", migration.version_table)
@@ -764,6 +829,8 @@ def alembic_config_for_provider(
     config.attributes["alembic_version_table"] = migration.alembic_version_table
     config.attributes["version_table"] = migration.version_table
     config.attributes["version_table_schema"] = migration.version_table_schema
+    config.attributes["version_locations"] = version_locations
+    config.attributes["version_path"] = migration.resolved_version_path()
     return config
 
 
@@ -805,6 +872,7 @@ def resolve_alembic_revision_metadata(
     *,
     script_location: str,
     revision: str,
+    version_locations: str | Sequence[str] | None = None,
 ) -> tuple[str, str | None]:
     try:
         from alembic.config import Config
@@ -814,6 +882,7 @@ def resolve_alembic_revision_metadata(
 
     config = Config()
     config.set_main_option("script_location", script_location)
+    _configure_alembic_version_locations(config, version_locations)
     script = ScriptDirectory.from_config(config)
     resolved = script.get_revision(revision)
     if resolved is None:
@@ -866,6 +935,9 @@ def _collection_create_row_from_registration_request(
     time_index_name = getattr(request, "time_index_name", None)
     if time_index_name not in (None, ""):
         row["time_index_name"] = str(time_index_name)
+    cadence = getattr(request, "cadence", None)
+    if cadence not in (None, ""):
+        row["cadence"] = str(cadence)
     partition_strategy = getattr(request, "partition_strategy", None)
     if partition_strategy not in (None, ""):
         row["partition_strategy"] = str(partition_strategy)

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence/meta_tables/sqlalchemy_contracts.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import contextlib
 import contextvars
 import json
+import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from typing import Any, ClassVar
@@ -37,6 +38,10 @@ DEFAULT_PLATFORM_MANAGED_PROVISIONING = {
 }
 SERVER_GENERATED_UUID_DEFAULT = "gen_random_uuid()"
 DEFAULT_POSTGRES_SCHEMA = "public"
+_TIME_INDEXED_CADENCE_RE = re.compile(
+    r"^[1-9][0-9]*(mo|s|m|h|d|w|q|y)$",
+    re.IGNORECASE,
+)
 _PLATFORM_MANAGED_MIGRATION_REGISTRATION_CONTEXT: contextvars.ContextVar[bool] = (
     contextvars.ContextVar(
         "mainsequence_platform_managed_migration_registration_context",
@@ -292,6 +297,7 @@ class PlatformTimeIndexMetaTable(PlatformManagedMetaTable):
     """
 
     __time_index_meta_table__: ClassVar[TimeIndexMetaTable | None] = None
+    __cadence__: ClassVar[str | None] = None
 
     __mapper_args__ = _sqlalchemy_declared_attr.directive(_time_index_mapper_args)
 
@@ -505,6 +511,7 @@ def time_indexed_registration_request_from_sqlalchemy_model(
         model_or_table,
         storage_layout=storage_layout,
     )
+    resolved_cadence = _resolve_time_index_cadence(model_or_table)
     columns = _iter_columns(table)
     _validate_time_index_contract(
         columns=columns,
@@ -520,6 +527,7 @@ def time_indexed_registration_request_from_sqlalchemy_model(
             time_index_name=resolved_time_index_name,
             index_names=resolved_index_names,
             storage_layout=resolved_storage_layout,
+            cadence=resolved_cadence,
         ),
         hash_namespace=resolved_hash_namespace,
         extra_hash_components=resolved_extra_hash_components,
@@ -559,6 +567,7 @@ def time_indexed_registration_request_from_sqlalchemy_model(
         labels=_resolve_labels(model_or_table, labels=labels),
         provisioning=_resolve_provisioning(model_or_table, provisioning=provisioning),
         time_index_name=resolved_time_index_name,
+        cadence=resolved_cadence,
         table_contract={
             "version": "relational-table.v1",
             "table_kind": "time_indexed",
@@ -571,6 +580,7 @@ def time_indexed_registration_request_from_sqlalchemy_model(
                 "time_indexed": {
                     "time_index_name": resolved_time_index_name,
                     "index_names": resolved_index_names,
+                    **({"cadence": resolved_cadence} if resolved_cadence else {}),
                     **(
                         {"storage_layout": dict(resolved_storage_layout)}
                         if resolved_storage_layout
@@ -1246,6 +1256,7 @@ def _configured_table_storage_identity(model_or_table: Any, *, table: Any) -> di
         time_index_name=time_index_name,
         index_names=index_names,
         storage_layout=_resolve_time_index_storage_layout(model_or_table),
+        cadence=_resolve_time_index_cadence(model_or_table),
     )
 
 
@@ -1260,12 +1271,14 @@ def _time_index_table_storage_identity(
     time_index_name: str,
     index_names: Sequence[str],
     storage_layout: Mapping[str, Any] | None,
+    cadence: str | None,
 ) -> dict[str, Any]:
     return _time_index_storage_identity(
         table_storage_identity=_table_storage_identity(table),
         time_index_name=time_index_name,
         index_names=index_names,
         storage_layout=storage_layout,
+        cadence=cadence,
     )
 
 
@@ -1275,12 +1288,14 @@ def _time_index_table_items_storage_identity(
     time_index_name: str,
     index_names: Sequence[str],
     storage_layout: Mapping[str, Any] | None,
+    cadence: str | None,
 ) -> dict[str, Any]:
     return _time_index_storage_identity(
         table_storage_identity=_table_items_storage_identity(table_items),
         time_index_name=time_index_name,
         index_names=index_names,
         storage_layout=storage_layout,
+        cadence=cadence,
     )
 
 
@@ -1290,12 +1305,15 @@ def _time_index_storage_identity(
     time_index_name: str,
     index_names: Sequence[str],
     storage_layout: Mapping[str, Any] | None,
+    cadence: str | None,
 ) -> dict[str, Any]:
     profile: dict[str, Any] = {
         "kind": "time_indexed",
         "time_index_name": str(time_index_name),
         "index_names": [str(name) for name in index_names],
     }
+    if cadence:
+        profile["cadence"] = cadence
     if storage_layout:
         profile["storage_layout"] = dict(storage_layout)
     return {
@@ -1399,10 +1417,28 @@ def _resolve_time_index_storage_layout(
     if not isinstance(resolved, Mapping):
         raise ValueError(
             "PlatformTimeIndexMetaTable storage_layout must be a mapping when provided."
-        )
+    )
     return resolved
 
 
+def _resolve_time_index_cadence(model_or_table: Any) -> str | None:
+    resolved = (
+        getattr(model_or_table, "__cadence__", None)
+        or getattr(model_or_table, "__dynamic_table_cadence__", None)
+    )
+    if resolved in (None, ""):
+        return None
+    normalized = str(resolved).strip().lower()
+    if not normalized:
+        return None
+    if not _TIME_INDEXED_CADENCE_RE.fullmatch(normalized):
+        raise ValueError(
+            "PlatformTimeIndexMetaTable cadence must be an interval token such as "
+            "1m, 5m, 1h, 1d, 1w, 1mo, 1q, or 1y."
+        )
+    return normalized
+
+
 def _dynamic_table_info_value(model_or_table: Any, key: str) -> Any:
     dynamic_table = _table_info_value(model_or_table, "dynamic_table")
     if isinstance(dynamic_table, Mapping):

{mainsequence-4.3.0 → mainsequence-4.3.6/mainsequence.egg-info}/PKG-INFO

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

{mainsequence-4.3.0 → mainsequence-4.3.6}/mainsequence.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 mainsequence = mainsequence.cli.cli:app
+ms = mainsequence.cli.cli:app

{mainsequence-4.3.0 → mainsequence-4.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "4.3.0"
+version = "4.3.6"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.11"
@@ -60,6 +60,7 @@ Homepage = "https://github.com/mainsequence-sdk/mainsequence-sdk"
 Issues = "https://github.com/mainsequence-sdk/mainsequence-sdk/issues"
 [project.scripts]
 mainsequence = "mainsequence.cli.cli:app"
+ms = "mainsequence.cli.cli:app"
 
 # PEP 621 dependencies (published requirements)
 [dependency-groups]