mainsequence 4.1.3__tar.gz → 4.1.4__tar.gz

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

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

{mainsequence-4.1.3 → mainsequence-4.1.4}/mainsequence/client/base.py

@@ -1,6 +1,5 @@
 import inspect
 import os
-import warnings
 from collections.abc import Callable, Iterable
 from datetime import datetime
 from typing import Any, ClassVar
@@ -98,13 +97,12 @@ class BaseObjectOrm:
         "JobRun": "pods/job-run",
         "Constant": "pods/constant",
         "Secret": "pods/secret",
-        "ProjectBaseImage":"pods/project-base-image",
-        "ProjectImage":"pods/project-image",
+        "ProjectBaseImage": "pods/project-base-image",
+        "ProjectImage": "pods/project-image",
         "GithubOrganization": "pods/github-organization",
-        "ProjectResource":"pods/project-resource",
-        "ResourceRelease":"pods/resource-release",
-        "Bucket":"pods/bucket",
-
+        "ProjectResource": "pods/project-resource",
+        "ResourceRelease": "pods/resource-release",
+        "Bucket": "pods/bucket",
     }
     ROOT_URL = API_ENDPOINT
     LOADERS = loaders
@@ -527,7 +525,6 @@ class BaseObjectOrm:
             )
             raise_for_response(r)
 
-
             data = r.json()
             data["orm_class"] = cls.__name__
             return cls(**data)
@@ -540,7 +537,6 @@ class BaseObjectOrm:
         if len(candidates) > 1:
             raise ApiError(f"Multiple objects returned for {cls.__name__} with filters={filters}")
 
-
         return candidates[0]
 
     @classmethod
@@ -556,8 +552,6 @@ class BaseObjectOrm:
 
     @staticmethod
     def serialize_for_json(kwargs):
-
-
         return serialize_to_json(kwargs)
 
     @classmethod
@@ -598,15 +592,6 @@ class BaseObjectOrm:
 
         return cls(**r.json())
 
-    @classmethod
-    def _warn_internal_id_compatibility(cls, method_name: str, replacement_name: str) -> None:
-        warnings.warn(
-            f"{cls.__name__}.{method_name}() is an internal-only compatibility shim; "
-            f"use {cls.__name__}.{replacement_name}() with uid instead.",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-
     @classmethod
     def _destroy_by_reference(cls, public_reference, *args, timeout=None, **kwargs):
         base_url = cls.get_object_url()
@@ -632,11 +617,6 @@ class BaseObjectOrm:
         if r.status_code != 204:
             raise_for_response(r)
 
-    @classmethod
-    def _destroy_by_id_compat(cls, instance_id, *args, timeout=None, **kwargs):
-        cls._warn_internal_id_compatibility("_destroy_by_id_compat", "destroy_by_uid")
-        return cls._destroy_by_reference(instance_id, *args, timeout=timeout, **kwargs)
-
     @classmethod
     def destroy_by_uid(cls, uid: str, *args, timeout=None, **kwargs):
         return cls._destroy_by_reference(uid, *args, timeout=timeout, **kwargs)
@@ -679,7 +659,11 @@ class BaseObjectOrm:
                             aliases.add(choice)
                 else:
                     path = getattr(validation_alias, "path", None)
-                    if isinstance(path, (list, tuple)) and len(path) == 1 and isinstance(path[0], str):
+                    if (
+                        isinstance(path, (list, tuple))
+                        and len(path) == 1
+                        and isinstance(path[0], str)
+                    ):
                         aliases.add(path[0])
 
             return aliases
@@ -734,11 +718,6 @@ class BaseObjectOrm:
         # Otherwise return a new instance
         return cls(**body)
 
-    @classmethod
-    def _patch_by_id_compat(cls, instance_id, *args, _into=None, **kwargs):
-        cls._warn_internal_id_compatibility("_patch_by_id_compat", "patch_by_uid")
-        return cls._patch_by_reference(instance_id, *args, _into=_into, **kwargs)
-
     @classmethod
     def patch_by_uid(cls, uid: str, *args, _into=None, **kwargs):
         return cls._patch_by_reference(uid, *args, _into=_into, **kwargs)

{mainsequence-4.1.3 → mainsequence-4.1.4}/mainsequence/client/data_sources_interfaces/duckdb.py

@@ -22,7 +22,7 @@ from ..dtype_codec import (
     token_to_pandas_dtype,
     token_to_pandas_series,
 )
-from ..utils import DataFrequency, UniqueIdentifierRangeMap
+from ..utils import DataFrequency
 
 
 def get_logger():
@@ -711,8 +711,6 @@ class DuckDBInterface:
         dimension_filters: dict[str, list[Any]] | None = None,
         index_coordinates: list[dict[str, Any]] | None = None,
         dimension_range_map: list[dict[str, Any]] | None = None,
-        ids: list[str] | None = None,
-        unique_identifier_range_map: dict[str, dict[str, Any]] | None = None,
         max_rows: int | None = None,
         now: datetime.datetime | None = None,
     ) -> tuple[
@@ -971,45 +969,6 @@ class DuckDBInterface:
                 f"time_index_name {time_index_name!r} must be present in index_names {index_names!r}"
             )
 
-        identity_dimensions = [name for name in index_names if name != time_index_name]
-        uses_legacy_unique_identifier = identity_dimensions == ["unique_identifier"]
-
-        if ids is not None and unique_identifier_range_map is not None:
-            raise ValueError("Cannot provide both 'ids' and 'unique_identifier_range_map'.")
-        if ids is not None and not uses_legacy_unique_identifier:
-            raise ValueError("Legacy 'ids' reads are valid only for unique_identifier tables.")
-        if unique_identifier_range_map is not None and not uses_legacy_unique_identifier:
-            raise ValueError(
-                "Legacy 'unique_identifier_range_map' reads are valid only for "
-                "unique_identifier tables."
-            )
-        if unique_identifier_range_map is not None and normalized_dimension_range_map is not None:
-            raise ValueError(
-                "Cannot provide both 'unique_identifier_range_map' and 'dimension_range_map'."
-            )
-
-        # If ids are given without a range map, create a simple one from start/end
-        if ids and (normalized_dimension_range_map is None):
-            normalized_dimension_range_map = [
-                {
-                    "coordinate": {"unique_identifier": uid},
-                    "start_date": start_ts.to_pydatetime() if start_ts is not None else None,
-                    "start_date_operand": ">=",
-                    "end_date": (
-                        (end_ts or _to_utc_ts(now)).to_pydatetime()
-                        if (end_ts or now) is not None
-                        else None
-                    ),
-                    "end_date_operand": "<=",
-                }
-                for uid in ids
-            ]
-        if unique_identifier_range_map is not None:
-            normalized_dimension_range_map = [
-                {"coordinate": {"unique_identifier": uid}, **dict(info)}
-                for uid, info in unique_identifier_range_map.items()
-            ]
-
         # Compute global window from inputs
         if normalized_dimension_range_map:
             eff_start = _effective_start_from_range_map(normalized_dimension_range_map)
@@ -1192,10 +1151,7 @@ class DuckDBInterface:
         dimension_filters: dict[str, list[Any]] | None = None,
         index_coordinates: list[dict[str, Any]] | None = None,
         dimension_range_map: list[dict[str, Any]] | None = None,
-        ids: list[str] | None = None,
         columns: list[str] | None = None,
-        unique_identifier_range_map: UniqueIdentifierRangeMap | None = None,
-        column_range_descriptor: dict[str, UniqueIdentifierRangeMap] | None = None,
     ) -> pd.DataFrame:
         """
         Reads data from the specified table, with optional filtering.
@@ -1207,18 +1163,10 @@ class DuckDBInterface:
             end (Optional[datetime.datetime]): Maximum temporal-column filter.
             great_or_equal (bool): If True, use >= for start date comparison. Defaults to True.
             less_or_equal (bool): If True, use <= for end date comparison. Defaults to True.
-            ids (Optional[List[str]]): List of specific unique_identifiers to include.
             columns (Optional[List[str]]): Specific columns to select. Reads all if None.
-            unique_identifier_range_map (Optional[UniqueIdentifierRangeMap]):
-                A map where keys are unique_identifiers and values are dicts specifying
-                date ranges (start_date, end_date, start_date_operand, end_date_operand)
-                for that identifier. Mutually exclusive with 'ids'.
 
         Returns:
             pd.DataFrame: The queried data, or an empty DataFrame if the table doesn't exist.
-
-        Raises:
-            ValueError: If both `ids` and `unique_identifier_range_map` are provided.
         """
 
         def qident(name: str) -> str:
@@ -1248,39 +1196,10 @@ class DuckDBInterface:
                 f"time_index_name {time_index_name!r} must be present in index_names {index_names!r}"
             )
         identity_dimensions = [name for name in index_names if name != time_index_name]
-        uses_legacy_unique_identifier = identity_dimensions == ["unique_identifier"]
-
-        if ids is not None and unique_identifier_range_map is not None:
-            raise ValueError("Cannot provide both 'ids' and 'unique_identifier_range_map'.")
-        if ids is not None and not uses_legacy_unique_identifier:
-            raise ValueError("Legacy 'ids' reads are valid only for unique_identifier tables.")
-        if unique_identifier_range_map is not None and not uses_legacy_unique_identifier:
-            raise ValueError(
-                "Legacy 'unique_identifier_range_map' reads are valid only for "
-                "unique_identifier tables."
-            )
-        if unique_identifier_range_map is not None and dimension_range_map is not None:
-            raise ValueError(
-                "Cannot provide both 'unique_identifier_range_map' and 'dimension_range_map'."
-            )
-        if column_range_descriptor is not None:
-            raise NotImplementedError("DuckDB column_range_descriptor reads are not supported.")
-
-        if ids:
-            dimension_filters = dict(dimension_filters or {})
-            if "unique_identifier" in dimension_filters:
-                raise ValueError("Cannot provide both 'ids' and a unique_identifier filter.")
-            dimension_filters["unique_identifier"] = list(ids)
-
-        if unique_identifier_range_map is not None:
-            dimension_range_map = [
-                {"coordinate": {"unique_identifier": uid}, **dict(info)}
-                for uid, info in unique_identifier_range_map.items()
-            ]
 
         logger.debug(
             f"Duck DB: Reading from table '{table}' with filters: start={start}, end={end}, "
-            f"ids={ids is not None}, columns={columns}, range_map={dimension_range_map is not None}"
+            f"columns={columns}, range_map={dimension_range_map is not None}"
         )
 
         if not self.table_exists(table):

{mainsequence-4.1.3 → mainsequence-4.1.4}/mainsequence/client/data_sources_interfaces/sqlite.py

@@ -16,7 +16,6 @@ from ..dtype_codec import (
     token_to_backend_type,
     token_to_pandas_series,
 )
-from ..utils import UniqueIdentifierRangeMap
 
 
 def get_logger():
@@ -192,7 +191,6 @@ class SQLiteInterface:
         *,
         index_names: list[str],
         time_index_name: str,
-        **_: Any,
     ) -> None:
         self._validate_index(index_names, time_index_name)
         if df.empty:
@@ -254,8 +252,6 @@ class SQLiteInterface:
         dimension_filters: dict[str, list[Any]] | None = None,
         index_coordinates: list[dict[str, Any]] | None = None,
         dimension_range_map: list[dict[str, Any]] | None = None,
-        ids: list[str] | None = None,
-        unique_identifier_range_map: dict[str, dict[str, Any]] | None = None,
         max_rows: int | None = None,
         now: datetime.datetime | None = None,
     ) -> tuple[
@@ -265,42 +261,9 @@ class SQLiteInterface:
         dict[str, Any],
     ]:
         self._validate_index(index_names, time_index_name)
-        identity_dimensions = [name for name in index_names if name != time_index_name]
-        uses_legacy_unique_identifier = identity_dimensions == ["unique_identifier"]
-
-        if ids is not None and unique_identifier_range_map is not None:
-            raise ValueError("Cannot provide both 'ids' and 'unique_identifier_range_map'.")
-        if ids is not None and not uses_legacy_unique_identifier:
-            raise ValueError("Legacy 'ids' reads are valid only for unique_identifier tables.")
-        if unique_identifier_range_map is not None and not uses_legacy_unique_identifier:
-            raise ValueError(
-                "Legacy 'unique_identifier_range_map' reads are valid only for "
-                "unique_identifier tables."
-            )
-        if unique_identifier_range_map is not None and dimension_range_map is not None:
-            raise ValueError(
-                "Cannot provide both 'unique_identifier_range_map' and 'dimension_range_map'."
-            )
-
         normalized_dimension_range_map = (
             None if dimension_range_map is None else [dict(item) for item in dimension_range_map]
         )
-        if ids and normalized_dimension_range_map is None:
-            normalized_dimension_range_map = [
-                {
-                    "coordinate": {"unique_identifier": uid},
-                    "start_date": start,
-                    "start_date_operand": ">=",
-                    "end_date": end or now,
-                    "end_date_operand": "<=",
-                }
-                for uid in ids
-            ]
-        if unique_identifier_range_map is not None:
-            normalized_dimension_range_map = [
-                {"coordinate": {"unique_identifier": uid}, **dict(info)}
-                for uid, info in unique_identifier_range_map.items()
-            ]
 
         diagnostics = {
             "limited": False,
@@ -324,42 +287,9 @@ class SQLiteInterface:
         dimension_filters: dict[str, list[Any]] | None = None,
         index_coordinates: list[dict[str, Any]] | None = None,
         dimension_range_map: list[dict[str, Any]] | None = None,
-        ids: list[str] | None = None,
         columns: list[str] | None = None,
-        unique_identifier_range_map: UniqueIdentifierRangeMap | None = None,
-        column_range_descriptor: dict[str, UniqueIdentifierRangeMap] | None = None,
-        **_: Any,
     ) -> pd.DataFrame:
         self._validate_index(index_names, time_index_name)
-        identity_dimensions = [name for name in index_names if name != time_index_name]
-        uses_legacy_unique_identifier = identity_dimensions == ["unique_identifier"]
-
-        if ids is not None and unique_identifier_range_map is not None:
-            raise ValueError("Cannot provide both 'ids' and 'unique_identifier_range_map'.")
-        if ids is not None and not uses_legacy_unique_identifier:
-            raise ValueError("Legacy 'ids' reads are valid only for unique_identifier tables.")
-        if unique_identifier_range_map is not None and not uses_legacy_unique_identifier:
-            raise ValueError(
-                "Legacy 'unique_identifier_range_map' reads are valid only for "
-                "unique_identifier tables."
-            )
-        if unique_identifier_range_map is not None and dimension_range_map is not None:
-            raise ValueError(
-                "Cannot provide both 'unique_identifier_range_map' and 'dimension_range_map'."
-            )
-        if column_range_descriptor is not None:
-            raise NotImplementedError("SQLite column_range_descriptor reads are not supported.")
-
-        if ids:
-            dimension_filters = dict(dimension_filters or {})
-            if "unique_identifier" in dimension_filters:
-                raise ValueError("Cannot provide both 'ids' and a unique_identifier filter.")
-            dimension_filters["unique_identifier"] = list(ids)
-        if unique_identifier_range_map is not None:
-            dimension_range_map = [
-                {"coordinate": {"unique_identifier": uid}, **dict(info)}
-                for uid, info in unique_identifier_range_map.items()
-            ]
 
         if not self.table_exists(table):
             logger.warning(f"Table '{table}' does not exist in {self.db_path}.")
@@ -382,6 +312,7 @@ class SQLiteInterface:
         sql_parts = [f"SELECT {select_sql} FROM {self._qident(table)}"]
         where_clauses: list[str] = []
         params: list[Any] = []
+        identity_dimensions = [name for name in index_names if name != time_index_name]
 
         def validate_dimension_name(name: str) -> None:
             if name not in identity_dimensions: