mainsequence 3.16.0__tar.gz → 3.17.0__tar.gz

{mainsequence-3.16.0 → mainsequence-3.17.0}/PKG-INFO

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

{mainsequence-3.16.0 → mainsequence-3.17.0}/mainsequence/cli/api.py

@@ -1958,6 +1958,89 @@ def list_data_node_storages(
         raise ApiError(f"Data node storages fetch failed: {e}")
 
 
+def list_simple_table_storages(
+    *,
+    filters: dict[str, Any] | None = None,
+    timeout: int | None = None,
+) -> list[dict[str, Any]]:
+    """
+    List simple table storages via SDK client model.
+
+    Single source of truth:
+      - delegates filtering and payload parsing to `SimpleTableStorage.filter()`
+    """
+    try:
+        storages = _run_sdk_model_operation(
+            module_name="mainsequence.client.models_simple_tables",
+            class_name="SimpleTableStorage",
+            operation=lambda ClientSimpleTableStorage: ClientSimpleTableStorage.filter(
+                timeout=timeout,
+                **dict(filters or {}),
+            ),
+        )
+        return [_sdk_object_to_dict(storage) for storage in storages]
+    except Exception as e:
+        if isinstance(e, (ApiError, NotLoggedIn)):
+            raise
+        raise ApiError(f"Simple table storages fetch failed: {e}")
+
+
+def get_simple_table_storage(
+    storage_id: int | str,
+    *,
+    timeout: int | None = None,
+) -> dict[str, Any]:
+    """
+    Retrieve one simple table storage via SDK client model.
+    """
+    try:
+        storage = _run_sdk_model_operation(
+            module_name="mainsequence.client.models_simple_tables",
+            class_name="SimpleTableStorage",
+            operation=lambda ClientSimpleTableStorage: ClientSimpleTableStorage.get(
+                pk=int(storage_id),
+                timeout=timeout,
+            ),
+        )
+        return _sdk_object_to_dict(storage)
+    except Exception as e:
+        err_name = type(e).__name__
+        if err_name == "NotFoundError":
+            raise ApiError(f"Simple table storage not found: {storage_id}")
+        if isinstance(e, (ApiError, NotLoggedIn)):
+            raise
+        raise ApiError(f"Simple table storage fetch failed: {e}")
+
+
+def delete_simple_table_storage(
+    storage_id: int | str,
+    *,
+    timeout: int | None = None,
+) -> dict[str, Any]:
+    """
+    Delete one simple table storage via SDK client model.
+    """
+    try:
+        def _delete(ClientSimpleTableStorage):
+            storage = ClientSimpleTableStorage.get(pk=int(storage_id), timeout=timeout)
+            payload = _sdk_object_to_dict(storage)
+            storage.delete(timeout=timeout)
+            return payload
+
+        return _run_sdk_model_operation(
+            module_name="mainsequence.client.models_simple_tables",
+            class_name="SimpleTableStorage",
+            operation=_delete,
+        )
+    except Exception as e:
+        err_name = type(e).__name__
+        if err_name == "NotFoundError":
+            raise ApiError(f"Simple table storage not found: {storage_id}")
+        if isinstance(e, (ApiError, NotLoggedIn)):
+            raise
+        raise ApiError(f"Simple table storage deletion failed: {e}")
+
+
 def list_data_node_org_unique_identifiers(
     *,
     timeout: int | None = None,

{mainsequence-3.16.0 → mainsequence-3.17.0}/mainsequence/cli/cli.py

@@ -79,6 +79,7 @@ from .api import (
     delete_project_image,
     delete_resource_release,
     delete_secret,
+    delete_simple_table_storage,
     fetch_project_env_text,
     get_constant,
     get_current_user_profile,
@@ -93,6 +94,7 @@ from .api import (
     get_projects,
     get_resource_release,
     get_secret,
+    get_simple_table_storage,
     list_constant_users_can_edit,
     list_constant_users_can_view,
     list_constants,
@@ -116,6 +118,7 @@ from .api import (
     list_secret_users_can_edit,
     list_secret_users_can_view,
     list_secrets,
+    list_simple_table_storages,
     list_team_users_can_edit,
     list_team_users_can_view,
     prime_sync_project_after_commit_sdk,
@@ -185,6 +188,7 @@ app = typer.Typer(help="MainSequence CLI (login + project operations)")
 
 constants = typer.Typer(help="Constant commands")
 secrets = typer.Typer(help="Secret commands")
+simple_table = typer.Typer(help="Simple table commands")
 organization = typer.Typer(help="Organization commands")
 organization_teams_group = typer.Typer(help="Organization team commands")
 markets = typer.Typer(help="Markets commands")
@@ -203,6 +207,10 @@ sdk = typer.Typer(help="SDK utilities (latest version, status)")
 
 app.add_typer(constants, name="constants")
 app.add_typer(secrets, name="secrets")
+app.add_typer(simple_table, name="simple_table")
+app.add_typer(simple_table, name="simple-table", hidden=True)
+app.add_typer(simple_table, name="simple_tables", hidden=True)
+app.add_typer(simple_table, name="simple-tables", hidden=True)
 app.add_typer(organization, name="organization")
 app.add_typer(markets, name="markets")
 app.add_typer(data_node_storage_group, name="data-node")
@@ -236,6 +244,7 @@ PROJECT_RESOURCE_MODEL_REF = "mainsequence.client.models_helpers.ProjectResource
 DATA_NODE_STORAGE_MODEL_REF = "mainsequence.client.models_tdag.DataNodeStorage"
 CONSTANT_MODEL_REF = "mainsequence.client.models_tdag.Constant"
 SECRET_MODEL_REF = "mainsequence.client.models_tdag.Secret"
+SIMPLE_TABLE_STORAGE_MODEL_REF = "mainsequence.client.models_simple_tables.SimpleTableStorage"
 TEAM_MODEL_REF = "mainsequence.client.models_user.Team"
 PORTFOLIO_MODEL_REF = "mainsequence.client.models_vam.Portfolio"
 ASSET_TRANSLATION_TABLE_MODEL_REF = "mainsequence.client.models_vam.AssetTranslationTable"
@@ -2916,6 +2925,129 @@ def _secrets_delete_impl(
     print_kv("Deleted Secret", _format_secret_preview(deleted))
 
 
+def _format_simple_table_storage_preview(storage: dict[str, object]) -> list[tuple[str, str]]:
+    columns = storage.get("columns")
+    foreign_keys = storage.get("foreign_keys")
+    incoming_fks = storage.get("incoming_fks")
+    indexes_meta = storage.get("indexes_meta")
+    return [
+        ("ID", str(storage.get("id") or "-")),
+        ("Source Class", str(storage.get("source_class_name") or "-")),
+        ("Data Source", _format_data_node_storage_data_source(storage.get("data_source"))),
+        ("Columns", str(len(columns)) if isinstance(columns, list) else "-"),
+        ("Foreign Keys", str(len(foreign_keys)) if isinstance(foreign_keys, list) else "-"),
+        ("Incoming FKs", str(len(incoming_fks)) if isinstance(incoming_fks, list) else "-"),
+        ("Indexes", str(len(indexes_meta)) if isinstance(indexes_meta, list) else "-"),
+        ("Open For Everyone", str(storage.get("open_for_everyone"))),
+        ("Creation Date", str(storage.get("creation_date") or "-")),
+    ]
+
+
+def _simple_tables_list_impl(
+    timeout: int | None,
+    filter_entries: list[str] | None,
+    show_filters: bool,
+) -> None:
+    filters = _resolve_cli_list_filters(
+        model_ref=SIMPLE_TABLE_STORAGE_MODEL_REF,
+        filter_entries=filter_entries,
+        show_filters=show_filters,
+        command_label="Simple Tables",
+    )
+    _require_login()
+
+    try:
+        storages = list_simple_table_storages(timeout=timeout, filters=filters)
+    except ApiError as e:
+        error(f"Simple tables fetch failed: {e}")
+        raise typer.Exit(1)
+
+    rows: list[list[str]] = []
+    for storage in storages:
+        columns = storage.get("columns")
+        rows.append(
+            [
+                str(storage.get("id") or "-"),
+                str(storage.get("source_class_name") or "-"),
+                _format_data_node_storage_data_source(storage.get("data_source")),
+                str(len(columns)) if isinstance(columns, list) else "-",
+                str(storage.get("open_for_everyone")),
+                str(storage.get("creation_date") or "-"),
+            ]
+        )
+
+    if rows:
+        print_table(
+            "Simple Tables",
+            ["ID", "Source Class", "Data Source", "Columns", "Open", "Creation Date"],
+            rows,
+        )
+    else:
+        info("No simple tables.")
+    info(f"Total simple tables: {len(storages)}")
+
+
+def _simple_tables_detail_impl(
+    *,
+    storage_id: int,
+    timeout: int | None,
+) -> None:
+    _require_login()
+
+    try:
+        storage = get_simple_table_storage(storage_id, timeout=timeout)
+    except ApiError as e:
+        error(f"Simple table fetch failed: {e}")
+        raise typer.Exit(1)
+
+    print_kv("Simple Table", _format_simple_table_storage_preview(storage))
+    print_kv(
+        "Simple Table Details",
+        [
+            ("Schema", _format_json_value(storage.get("schema") or storage.get("simple_table_schema"))),
+            ("Build Configuration", _format_json_value(storage.get("build_configuration"))),
+            ("Source Code Git Hash", str(storage.get("time_serie_source_code_git_hash") or "-")),
+            ("Organization Owner", str(storage.get("organization_owner") or "-")),
+            ("Created By User", str(storage.get("created_by_user") or "-")),
+            ("Columns Payload", _format_json_value(storage.get("columns"))),
+            ("Foreign Keys Payload", _format_json_value(storage.get("foreign_keys"))),
+            ("Incoming FKs Payload", _format_json_value(storage.get("incoming_fks"))),
+            ("Indexes Payload", _format_json_value(storage.get("indexes_meta"))),
+        ],
+    )
+
+
+def _simple_tables_delete_impl(
+    *,
+    storage_id: int,
+    timeout: int | None,
+) -> None:
+    _require_login()
+
+    try:
+        storage = get_simple_table_storage(storage_id, timeout=timeout)
+    except ApiError as e:
+        error(f"Simple table fetch failed: {e}")
+        raise typer.Exit(1)
+
+    verification_value = str(storage.get("source_class_name") or storage.get("id") or storage_id)
+    _require_delete_verification(
+        preview_title="Simple Table Delete Preview",
+        preview_items=_format_simple_table_storage_preview(storage),
+        verification_value=verification_value,
+        verification_label="source class name" if storage.get("source_class_name") else "simple table id",
+    )
+
+    try:
+        deleted = delete_simple_table_storage(storage_id, timeout=timeout)
+    except ApiError as e:
+        error(f"Simple table deletion failed: {e}")
+        raise typer.Exit(1)
+
+    success(f"Simple table deleted: id={storage_id}")
+    print_kv("Deleted Simple Table", _format_simple_table_storage_preview(deleted))
+
+
 def _data_node_storage_list_impl(
     timeout: int | None,
     filter_entries: list[str] | None,
@@ -3086,6 +3218,44 @@ def _print_data_node_storage_search_section(
     return len(storages)
 
 
+@simple_table.command("list")
+def simple_tables_list_cmd(
+    filter_entries: list[str] | None = typer.Option(None, "--filter", help=LIST_FILTER_OPTION_HELP),
+    show_filters: bool = typer.Option(False, "--show-filters", help="Show the filters supported by this list command and exit."),
+    timeout: int | None = typer.Option(None, "--timeout", help="Request timeout in seconds"),
+):
+    """
+    List simple table storages visible to the authenticated user.
+    """
+    _simple_tables_list_impl(
+        timeout=timeout,
+        filter_entries=filter_entries,
+        show_filters=show_filters,
+    )
+
+
+@simple_table.command("detail")
+def simple_tables_detail_cmd(
+    storage_id: int = typer.Argument(..., help="Simple table storage ID."),
+    timeout: int | None = typer.Option(None, "--timeout", help="Request timeout in seconds"),
+):
+    """
+    Show one simple table storage in detail.
+    """
+    _simple_tables_detail_impl(storage_id=storage_id, timeout=timeout)
+
+
+@simple_table.command("delete")
+def simple_tables_delete_cmd(
+    storage_id: int = typer.Argument(..., help="Simple table storage ID."),
+    timeout: int | None = typer.Option(None, "--timeout", help="Request timeout in seconds"),
+):
+    """
+    Delete one simple table storage.
+    """
+    _simple_tables_delete_impl(storage_id=storage_id, timeout=timeout)
+
+
 @constants.command("list")
 def constants_list_cmd(
     filter_entries: list[str] | None = typer.Option(None, "--filter", help=LIST_FILTER_OPTION_HELP),

{mainsequence-3.16.0 → mainsequence-3.17.0}/mainsequence/client/__init__.py

@@ -1,8 +1,8 @@
 from mainsequence.logconf import logger
 
 from .agent import *
-from .data_filters import *
 from .models_helpers import *
+from .models_simple_tables import *
 from .models_tdag import *
 from .models_user import *
 from .models_vam import *

{mainsequence-3.16.0 → mainsequence-3.17.0}/mainsequence/client/base.py

@@ -6,8 +6,6 @@ from typing import Any, ClassVar
 
 from pydantic import BaseModel, ConfigDict
 
-from mainsequence import logger
-
 from .exceptions import ApiError, raise_for_response
 from .utils import (
     API_ENDPOINT,
@@ -632,21 +630,69 @@ class BaseObjectOrm:
 
         body = r.json()
 
-        def recursive_update(obj, update_dict):
+        def _iter_field_aliases(field_info) -> set[str]:
+            aliases: set[str] = set()
+
+            for attr_name in ("alias", "serialization_alias"):
+                alias_value = getattr(field_info, attr_name, None)
+                if isinstance(alias_value, str) and alias_value:
+                    aliases.add(alias_value)
+
+            validation_alias = getattr(field_info, "validation_alias", None)
+            if isinstance(validation_alias, str) and validation_alias:
+                aliases.add(validation_alias)
+            elif validation_alias is not None:
+                choices = getattr(validation_alias, "choices", None)
+                if choices is not None:
+                    for choice in choices:
+                        if isinstance(choice, str) and choice:
+                            aliases.add(choice)
+                else:
+                    path = getattr(validation_alias, "path", None)
+                    if isinstance(path, (list, tuple)) and len(path) == 1 and isinstance(path[0], str):
+                        aliases.add(path[0])
+
+            return aliases
+
+        def _resolve_model_field_name(obj, raw_key: str) -> str:
+            if not isinstance(obj, BaseModel):
+                return raw_key
+
+            model_fields = getattr(type(obj), "model_fields", {})
+            if raw_key in model_fields:
+                return raw_key
+
+            for field_name, field_info in model_fields.items():
+                if raw_key in _iter_field_aliases(field_info):
+                    return field_name
+
+            return raw_key
+
+        def recursive_update(obj, update_dict, path=()):
             for k, v in update_dict.items():
+                current_path = (*path, k)
+                field_name = _resolve_model_field_name(obj, k)
                 # Get the existing nested object, defaulting to None if it doesn't exist
-                nested_obj = getattr(obj, k, None)
+                nested_obj = getattr(obj, field_name, None)
 
                 # Only recurse if the update value is a dict AND the existing
                 # attribute is an instance of a Pydantic model.
                 if isinstance(v, dict) and isinstance(nested_obj, BaseModel):
-                    recursive_update(nested_obj, v)
+                    recursive_update(nested_obj, v, path=current_path)
                 else:
                     # Otherwise, just set the value directly.
                     try:
-                        setattr(obj, k, v)
-                    except Exception as e:
-                        logger.exception(e)
+                        setattr(obj, field_name, v)
+                    except Exception as exc:
+                        field_path = ".".join(current_path)
+                        response_fragment = repr({k: v})
+                        if len(response_fragment) > 300:
+                            response_fragment = f"{response_fragment[:297]}..."
+                        raise ValueError(
+                            f"Failed to apply PATCH response to {type(obj).__name__} at field "
+                            f"'{field_path}'. Response fragment: {response_fragment}. "
+                            f"Original error: {exc}"
+                        ) from exc
 
             return obj