UncountablePythonSDK 0.0.126__py3-none-any.whl → 0.0.142.dev0__py3-none-any.whl

uncountable/integration/queue_runner/worker.py

@@ -87,30 +87,32 @@ def run_queued_job(
             base_span=span,
             profile_metadata=job_details.profile_metadata,
             job_definition=job_details.job_definition,
+            queued_job_uuid=queued_job.queued_job_uuid,
         )
-        try:
-            client = construct_uncountable_client(
-                profile_meta=job_details.profile_metadata, logger=job_logger
-            )
-            batch_processor = AsyncBatchProcessor(client=client)
-
-            payload = _resolve_queued_job_payload(queued_job)
-
-            args = JobArguments(
-                job_definition=job_details.job_definition,
-                client=client,
-                batch_processor=batch_processor,
-                profile_metadata=job_details.profile_metadata,
-                logger=job_logger,
-                payload=payload,
-            )
-
-            return execute_job(
-                args=args,
-                profile_metadata=job_details.profile_metadata,
-                job_definition=job_details.job_definition,
-                job_uuid=queued_job.queued_job_uuid,
-            )
-        except BaseException as e:
-            job_logger.log_exception(e)
-            return job_definition_t.JobResult(success=False)
+        with job_logger.resource_tracking():
+            try:
+                client = construct_uncountable_client(
+                    profile_meta=job_details.profile_metadata, logger=job_logger
+                )
+                batch_processor = AsyncBatchProcessor(client=client)
+
+                payload = _resolve_queued_job_payload(queued_job)
+
+                args = JobArguments(
+                    job_definition=job_details.job_definition,
+                    client=client,
+                    batch_processor=batch_processor,
+                    profile_metadata=job_details.profile_metadata,
+                    logger=job_logger,
+                    payload=payload,
+                    job_uuid=queued_job.queued_job_uuid,
+                )
+
+                return execute_job(
+                    args=args,
+                    profile_metadata=job_details.profile_metadata,
+                    job_definition=job_details.job_definition,
+                )
+            except BaseException as e:
+                job_logger.log_exception(e)
+                return job_definition_t.JobResult(success=False)

uncountable/integration/scheduler.py

@@ -6,6 +6,7 @@ import time
 from dataclasses import dataclass
 from datetime import UTC
 from enum import StrEnum
+from typing import assert_never
 
 from opentelemetry.trace import get_current_span
 
@@ -16,6 +17,7 @@ from uncountable.integration.queue_runner.command_server import (
     check_health,
 )
 from uncountable.integration.queue_runner.queue_runner import start_queue_runner
+from uncountable.integration.queue_runner.types import RESTART_EXIT_CODE
 from uncountable.integration.telemetry import Logger
 
 SHUTDOWN_TIMEOUT_SECS = 30
@@ -55,6 +57,19 @@ class ProcessInfo:
                 return self.process.poll()
 
 
+@dataclass(kw_only=True)
+class ProcessAlarmRestart:
+    process: ProcessInfo
+
+
+@dataclass(kw_only=True)
+class ProcessAlarmShutdownAll:
+    pass
+
+
+ProcessAlarm = ProcessAlarmRestart | ProcessAlarmShutdownAll
+
+
 def handle_shutdown(logger: Logger, processes: dict[ProcessName, ProcessInfo]) -> None:
     logger.log_info("received shutdown command, shutting down sub-processes")
     for proc_info in processes.values():
@@ -129,12 +144,21 @@ def restart_process(
             logger.log_info("uwsgi restarted successfully")
 
 
-def check_process_alive(
+def check_process_alarms(
     logger: Logger, processes: dict[ProcessName, ProcessInfo]
-) -> None:
+) -> ProcessAlarm | None:
     for proc_info in processes.values():
         if not proc_info.is_alive:
-            restart_process(logger, proc_info, processes)
+            if proc_info.exitcode == RESTART_EXIT_CODE:
+                logger.log_warning(
+                    f"process {proc_info.name} requested restart! restarting"
+                )
+                return ProcessAlarmRestart(process=proc_info)
+            logger.log_error(
+                f"process {proc_info.name} shut down unexpectedly! shutting down scheduler; exit code is {proc_info.exitcode}"
+            )
+            return ProcessAlarmShutdownAll()
+    return None
 
 
 def _wait_queue_runner_online() -> None:
@@ -166,16 +190,24 @@ def main() -> None:
         processes[process.name] = process
         logger.log_info(f"started process {process.name}")
 
-    runner_process = multiprocessing.Process(target=start_queue_runner)
-    runner_process.start()
-    add_process(ProcessInfo(name=ProcessName.QUEUE_RUNNER, process=runner_process))
+    def _start_queue_runner() -> None:
+        runner_process = multiprocessing.Process(target=start_queue_runner)
+        runner_process.start()
+        add_process(
+            ProcessInfo(
+                name=ProcessName.QUEUE_RUNNER,
+                process=runner_process,
+            )
+        )
 
-    try:
-        _wait_queue_runner_online()
-    except Exception as e:
-        logger.log_exception(e)
-        handle_shutdown(logger, processes=processes)
-        return
+        try:
+            _wait_queue_runner_online()
+        except Exception as e:
+            logger.log_exception(e)
+            handle_shutdown(logger, processes=processes)
+            return
+
+    _start_queue_runner()
 
     cron_process = multiprocessing.Process(target=cron_target)
     cron_process.start()
@@ -189,7 +221,26 @@ def main() -> None:
 
     try:
         while True:
-            check_process_alive(logger, processes=processes)
+            process_alarm = check_process_alarms(logger, processes=processes)
+            match process_alarm:
+                case ProcessAlarmRestart():
+                    match process_alarm.process.name:
+                        case ProcessName.QUEUE_RUNNER:
+                            del processes[ProcessName.QUEUE_RUNNER]
+                            _start_queue_runner()
+                        case ProcessName.CRON_SERVER | ProcessName.UWSGI:
+                            raise NotImplementedError(
+                                f"restarting {process_alarm.process.name} not yet implemented"
+                            )
+                        case _:
+                            assert_never(process_alarm.process.name)
+                case ProcessAlarmShutdownAll():
+                    handle_shutdown(logger, processes)
+                    sys.exit(1)
+                case None:
+                    pass
+                case _:
+                    assert_never(process_alarm)
             time.sleep(1)
     except KeyboardInterrupt:
         handle_shutdown(logger, processes=processes)

uncountable/integration/server.py

@@ -11,7 +11,11 @@ from apscheduler.triggers.cron import CronTrigger
 from opentelemetry.trace import get_current_span
 from sqlalchemy.engine.base import Engine
 
+from uncountable.core.environment import get_local_admin_server_port
 from uncountable.integration.cron import CronJobArgs, cron_job_executor
+from uncountable.integration.queue_runner.command_server.command_client import (
+    send_vaccuum_queued_jobs_message,
+)
 from uncountable.integration.telemetry import Logger
 from uncountable.types import base_t, job_definition_t
 from uncountable.types.job_definition_t import (
@@ -21,6 +25,14 @@ from uncountable.types.job_definition_t import (
 
 _MAX_APSCHEDULER_CONCURRENT_JOBS = 1
 
+VACCUUM_QUEUED_JOBS_JOB_ID = "vacuum_queued_jobs"
+
+STATIC_JOB_IDS = {VACCUUM_QUEUED_JOBS_JOB_ID}
+
+
+def vaccuum_queued_jobs() -> None:
+    send_vaccuum_queued_jobs_message(port=get_local_admin_server_port())
+
 
 class IntegrationServer:
     _scheduler: BaseScheduler
@@ -36,11 +48,27 @@ class IntegrationServer:
         )
         self._server_logger = Logger(get_current_span())
 
+    def _register_static_jobs(self) -> None:
+        all_job_ids = {job.id for job in self._scheduler.get_jobs()}
+        if VACCUUM_QUEUED_JOBS_JOB_ID in all_job_ids:
+            self._scheduler.remove_job(VACCUUM_QUEUED_JOBS_JOB_ID)
+
+        self._scheduler.add_job(
+            vaccuum_queued_jobs,
+            max_instances=1,
+            coalesce=True,
+            trigger=CronTrigger.from_crontab("5 4 * * 4"),
+            name="Vaccuum queued jobs",
+            id=VACCUUM_QUEUED_JOBS_JOB_ID,
+            kwargs={},
+            misfire_grace_time=None,
+        )
+
     def register_jobs(self, profiles: list[job_definition_t.ProfileMetadata]) -> None:
-        valid_job_ids = []
+        valid_job_ids: set[str] = set()
         for profile_metadata in profiles:
             for job_defn in profile_metadata.jobs:
-                valid_job_ids.append(job_defn.id)
+                valid_job_ids.add(job_defn.id)
                 match job_defn:
                     case CronJobDefinition():
                         # Add to ap scheduler
@@ -90,10 +118,11 @@ class IntegrationServer:
                         pass
                     case _:
                         assert_never(job_defn)
-        all_jobs = self._scheduler.get_jobs()
-        for job in all_jobs:
-            if job.id not in valid_job_ids:
-                self._scheduler.remove_job(job.id)
+        all_job_ids = {job.id for job in self._scheduler.get_jobs()}
+        invalid_job_ids = all_job_ids.difference(valid_job_ids.union(STATIC_JOB_IDS))
+
+        for job_id in invalid_job_ids:
+            self._scheduler.remove_job(job_id)
 
     def serve_forever(self) -> None:
         signal.pause()
@@ -106,6 +135,7 @@ class IntegrationServer:
 
     def __enter__(self) -> "IntegrationServer":
         self._start_apscheduler()
+        self._register_static_jobs()
         return self
 
     def __exit__(

uncountable/integration/telemetry.py

@@ -1,18 +1,24 @@
 import functools
 import json
 import os
+import threading
 import time
 import traceback
+import types
 import typing
 from contextlib import contextmanager
 from enum import StrEnum
 from typing import Generator, assert_never, cast
 
+import psutil
 from opentelemetry import _logs, trace
 from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk._logs import Logger as OTELLogger
-from opentelemetry.sdk._logs import LoggerProvider, LogRecord
+from opentelemetry.sdk._logs import (
+    LoggerProvider,
+    LogRecord,
+)
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, ConsoleLogExporter
 from opentelemetry.sdk.resources import Attributes, Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -95,8 +101,27 @@ class Logger:
     def current_trace_id(self) -> int | None:
         return self.current_span.get_span_context().trace_id
 
-    def _patch_attributes(self, attributes: Attributes | None) -> Attributes:
-        return attributes or {}
+    def _patch_attributes(
+        self,
+        attributes: Attributes | None,
+        *,
+        message: str | None = None,
+        severity: LogSeverity | None = None,
+    ) -> Attributes:
+        patched_attributes = {**(attributes if attributes is not None else {})}
+        if message is not None:
+            patched_attributes["message"] = message
+        elif "body" in patched_attributes:
+            patched_attributes["message"] = patched_attributes["body"]
+
+        if severity is not None:
+            patched_attributes["status"] = severity.lower()
+        elif "severity_text" in patched_attributes and isinstance(
+            patched_attributes["severity_text"], str
+        ):
+            patched_attributes["status"] = patched_attributes["severity_text"].lower()
+
+        return patched_attributes
 
     def _emit_log(
         self, message: str, *, severity: LogSeverity, attributes: Attributes | None
@@ -106,7 +131,9 @@ class Logger:
             body=message,
             severity_text=severity,
             timestamp=time.time_ns(),
-            attributes=self._patch_attributes(attributes),
+            attributes=self._patch_attributes(
+                message=message, severity=severity, attributes=attributes
+            ),
             span_id=self.current_span_id,
             trace_id=self.current_trace_id,
             trace_flags=DEFAULT_TRACE_OPTIONS,
@@ -140,7 +167,9 @@ class Logger:
         attributes: Attributes | None = None,
     ) -> None:
         traceback_str = "".join(traceback.format_exception(exception))
-        patched_attributes = self._patch_attributes(attributes)
+        patched_attributes = self._patch_attributes(
+            message=message, severity=LogSeverity.ERROR, attributes=attributes
+        )
         self.current_span.record_exception(
             exception=exception, attributes=patched_attributes
         )
@@ -159,6 +188,76 @@ class Logger:
             yield self
 
 
+class PerJobResourceTracker:
+    def __init__(self, logger: "JobLogger", sample_interval: float = 0.5) -> None:
+        self.logger = logger
+        self.sample_interval = sample_interval
+        self._process = psutil.Process(os.getpid())
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+
+        self.max_rss: int = 0
+        self.start_cpu_times: psutil._common.pcputimes | None = None
+        self.end_cpu_times: psutil._common.pcputimes | None = None
+        self.start_wall_time: float | None = None
+        self.end_wall_time: float | None = None
+
+    def start(self) -> None:
+        self.start_cpu_times = self._process.cpu_times()
+        self.start_wall_time = time.monotonic()
+
+        def _monitor() -> None:
+            try:
+                while not self._stop_event.is_set():
+                    rss = self._process.memory_info().rss
+                    self.max_rss = max(self.max_rss, rss)
+                    time.sleep(self.sample_interval)
+            except Exception:
+                self._stop_event.set()
+
+        self._thread = threading.Thread(target=_monitor, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join()
+        self.end_cpu_times = self._process.cpu_times()
+        self.end_wall_time = time.monotonic()
+
+    def __enter__(self) -> typing.Self:
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        self.stop()
+        stats = dict(self.summary())
+        self.logger.log_info("Job resource usage summary", attributes=stats)
+
+    def summary(self) -> Attributes:
+        assert self.start_cpu_times is not None
+        assert self.end_cpu_times is not None
+        assert self.start_wall_time is not None
+        assert self.end_wall_time is not None
+
+        cpu_user = self.end_cpu_times.user - self.start_cpu_times.user
+        cpu_sys = self.end_cpu_times.system - self.start_cpu_times.system
+        cpu_total = cpu_user + cpu_sys
+        elapsed = self.end_wall_time - self.start_wall_time
+        return {
+            "cpu_user_s": round(cpu_user, 3),
+            "cpu_system_s": round(cpu_sys, 3),
+            "cpu_total_s": round(cpu_total, 3),
+            "wall_time_s": round(elapsed, 3),
+            "peak_rss_mb": round(self.max_rss / (1024 * 1024), 2),
+        }
+
+
 class JobLogger(Logger):
     def __init__(
         self,
@@ -166,20 +265,31 @@ class JobLogger(Logger):
         base_span: Span,
         profile_metadata: job_definition_t.ProfileMetadata,
         job_definition: job_definition_t.JobDefinition,
+        queued_job_uuid: str,
     ) -> None:
         self.profile_metadata = profile_metadata
         self.job_definition = job_definition
+        self.queued_job_uuid = queued_job_uuid
         super().__init__(base_span)
 
-    def _patch_attributes(self, attributes: Attributes | None) -> Attributes:
+    def _patch_attributes(
+        self,
+        attributes: Attributes | None,
+        *,
+        message: str | None = None,
+        severity: LogSeverity | None = None,
+    ) -> Attributes:
         patched_attributes: dict[str, base_t.JsonValue] = {
-            **(attributes if attributes is not None else {})
+            **super()._patch_attributes(
+                attributes=attributes, message=message, severity=severity
+            )
         }
         patched_attributes["profile.name"] = self.profile_metadata.name
         patched_attributes["profile.base_url"] = self.profile_metadata.base_url
         patched_attributes["job.name"] = self.job_definition.name
         patched_attributes["job.id"] = self.job_definition.id
         patched_attributes["job.definition_type"] = self.job_definition.type
+        patched_attributes["job.queued_job_uuid"] = self.queued_job_uuid
         match self.job_definition:
             case job_definition_t.CronJobDefinition():
                 patched_attributes["job.definition.cron_spec"] = (
@@ -205,6 +315,9 @@ class JobLogger(Logger):
                 assert_never(self.job_definition.executor)
         return _cast_attributes(patched_attributes)
 
+    def resource_tracking(self) -> PerJobResourceTracker:
+        return PerJobResourceTracker(self)
+
 
 @contextmanager
 def push_scope_optional(

uncountable/integration/webhook_server/entrypoint.py

@@ -73,6 +73,8 @@ def register_route(
 
 
 def main() -> None:
+    app.add_url_rule("/health", "health", lambda: ("OK", 200))
+
     profiles = load_profiles()
     for profile_metadata in profiles:
         server_logger = Logger(get_current_span())

uncountable/types/__init__.py

@@ -2,6 +2,7 @@
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file
+from .api.notebooks import add_notebook_content as add_notebook_content_t
 from .api.recipes import add_recipe_to_project as add_recipe_to_project_t
 from .api.recipes import add_time_series_data as add_time_series_data_t
 from .api.recipes import archive_recipes as archive_recipes_t
@@ -36,8 +37,10 @@ from . import entity_t as entity_t
 from .api.batch import execute_batch as execute_batch_t
 from .api.batch import execute_batch_load_async as execute_batch_load_async_t
 from . import experiment_groups_t as experiment_groups_t
+from .api.runsheet import export_default_runsheet as export_default_runsheet_t
 from .api.entity import export_entities as export_entities_t
 from . import exports_t as exports_t
+from .api.listing import fetch_listing as fetch_listing_t
 from . import field_values_t as field_values_t
 from . import fields_t as fields_t
 from . import generic_upload_t as generic_upload_t
@@ -70,12 +73,15 @@ from . import integration_session_t as integration_session_t
 from . import integrations_t as integrations_t
 from .api.uploader import invoke_uploader as invoke_uploader_t
 from . import job_definition_t as job_definition_t
+from .api.entity import list_aggregate as list_aggregate_t
 from .api.entity import list_entities as list_entities_t
 from .api.id_source import list_id_source as list_id_source_t
+from . import listing_t as listing_t
 from .api.entity import lock_entity as lock_entity_t
 from .api.recipes import lock_recipes as lock_recipes_t
 from .api.entity import lookup_entity as lookup_entity_t
 from .api.id_source import match_id_source as match_id_source_t
+from . import notices_t as notices_t
 from . import notifications_t as notifications_t
 from . import outputs_t as outputs_t
 from . import overrides_t as overrides_t
@@ -93,6 +99,7 @@ from . import recipe_output_metadata_t as recipe_output_metadata_t
 from . import recipe_tags_t as recipe_tags_t
 from . import recipe_workflow_steps_t as recipe_workflow_steps_t
 from . import recipes_t as recipes_t
+from .api.integrations import register_sockets_token as register_sockets_token_t
 from .api.recipes import remove_recipe_from_project as remove_recipe_from_project_t
 from .api.recipe_links import remove_recipe_link as remove_recipe_link_t
 from .api.entity import resolve_entity_ids as resolve_entity_ids_t
@@ -100,6 +107,7 @@ from .api.outputs import resolve_output_conditions as resolve_output_conditions_
 from . import response_t as response_t
 from .api.triggers import run_trigger as run_trigger_t
 from . import secret_retrieval_t as secret_retrieval_t
+from .api.entity import set_barcode as set_barcode_t
 from .api.permissions import set_core_permissions as set_core_permissions_t
 from .api.entity import set_entity_field_values as set_entity_field_values_t
 from .api.inputs import set_input_attribute_values as set_input_attribute_values_t
@@ -112,6 +120,7 @@ from .api.recipes import set_recipe_output_annotations as set_recipe_output_anno
 from .api.recipes import set_recipe_output_file as set_recipe_output_file_t
 from .api.recipes import set_recipe_outputs as set_recipe_outputs_t
 from .api.recipes import set_recipe_tags as set_recipe_tags_t
+from .api.recipes import set_recipe_total as set_recipe_total_t
 from .api.entity import set_values as set_values_t
 from . import sockets_t as sockets_t
 from .api.entity import transition_entity_phase as transition_entity_phase_t
@@ -129,6 +138,7 @@ from . import workflows_t as workflows_t
 
 
 __all__: list[str] = [
+    "add_notebook_content_t",
     "add_recipe_to_project_t",
     "add_time_series_data_t",
     "archive_recipes_t",
@@ -163,8 +173,10 @@ __all__: list[str] = [
     "execute_batch_t",
     "execute_batch_load_async_t",
     "experiment_groups_t",
+    "export_default_runsheet_t",
     "export_entities_t",
     "exports_t",
+    "fetch_listing_t",
     "field_values_t",
     "fields_t",
     "generic_upload_t",
@@ -197,12 +209,15 @@ __all__: list[str] = [
     "integrations_t",
     "invoke_uploader_t",
     "job_definition_t",
+    "list_aggregate_t",
     "list_entities_t",
     "list_id_source_t",
+    "listing_t",
     "lock_entity_t",
     "lock_recipes_t",
     "lookup_entity_t",
     "match_id_source_t",
+    "notices_t",
     "notifications_t",
     "outputs_t",
     "overrides_t",
@@ -220,6 +235,7 @@ __all__: list[str] = [
     "recipe_tags_t",
     "recipe_workflow_steps_t",
     "recipes_t",
+    "register_sockets_token_t",
     "remove_recipe_from_project_t",
     "remove_recipe_link_t",
     "resolve_entity_ids_t",
@@ -227,6 +243,7 @@ __all__: list[str] = [
     "response_t",
     "run_trigger_t",
     "secret_retrieval_t",
+    "set_barcode_t",
     "set_core_permissions_t",
     "set_entity_field_values_t",
     "set_input_attribute_values_t",
@@ -239,6 +256,7 @@ __all__: list[str] = [
     "set_recipe_output_file_t",
     "set_recipe_outputs_t",
     "set_recipe_tags_t",
+    "set_recipe_total_t",
     "set_values_t",
     "sockets_t",
     "transition_entity_phase_t",

uncountable/types/api/entity/list_aggregate.py

@@ -0,0 +1,79 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+import dataclasses
+from pkgs.serialization import serial_class
+from ... import base_t
+
+__all__: list[str] = [
+    "Arguments",
+    "AttributeValue",
+    "ColumnAccess",
+    "ColumnResults",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+]
+
+ENDPOINT_METHOD = "GET"
+ENDPOINT_PATH = "api/external/entity/list_aggregate"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.entity.list_aggregate.AttributeValue",
+    unconverted_values={"value"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class AttributeValue:
+    name: str
+    value: base_t.JsonValue
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.entity.list_aggregate.Arguments",
+    unconverted_values={"attribute_values"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Arguments:
+    config_reference: str
+    attribute_values: list[AttributeValue] | None = None
+    offset: int | None = None
+    limit: int | None = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.entity.list_aggregate.ColumnResults",
+    unconverted_values={"column_values"},
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class ColumnResults:
+    column_values: list[base_t.JsonValue]
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.entity.list_aggregate.ColumnAccess",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class ColumnAccess:
+    name: str
+    table_label: str | None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@serial_class(
+    named_type_path="sdk.api.entity.list_aggregate.Data",
+)
+@dataclasses.dataclass(slots=base_t.ENABLE_SLOTS, kw_only=True)  # type: ignore[literal-required]
+class Data:
+    columns: list[ColumnAccess]
+    results: list[ColumnResults]
+# DO NOT MODIFY -- This file is generated by type_spec