great-expectations-cloud 20250915.1.dev1__py3-none-any.whl → 20260120.0.dev0__py3-none-any.whl

great_expectations_cloud/agent/actions/agent_action.py

@@ -4,7 +4,6 @@ import datetime
 from abc import abstractmethod
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Generic, Optional, TypeVar, Union
-from uuid import UUID
 
 from pydantic.v1 import BaseModel
 
@@ -12,6 +11,7 @@ from great_expectations_cloud.agent.models import (
     AgentBaseExtraForbid,
     AgentBaseExtraIgnore,
     CreatedResource,
+    DomainContext,
 )
 
 if TYPE_CHECKING:
@@ -32,11 +32,11 @@ _EventT = TypeVar("_EventT", bound=Union[AgentBaseExtraForbid, AgentBaseExtraIgn
 
 class AgentAction(Generic[_EventT]):
     def __init__(
-        self, context: CloudDataContext, base_url: str, organization_id: UUID, auth_key: str
+        self, context: CloudDataContext, base_url: str, domain_context: DomainContext, auth_key: str
     ):
         self._context = context
         self._base_url = base_url
-        self._organization_id = organization_id
+        self._domain_context = domain_context
         self._auth_key = auth_key
 
     @abstractmethod

great_expectations_cloud/agent/actions/draft_datasource_config_action.py

@@ -40,9 +40,7 @@ class DraftDatasourceConfigAction(AgentAction[DraftDatasourceConfigEvent]):
     def check_draft_datasource_config(
         self, event: DraftDatasourceConfigEvent, id: str
     ) -> ActionResult:
-        draft_config = self.get_draft_config(
-            config_id=event.config_id, workspace_id=event.workspace_id
-        )
+        draft_config = self.get_draft_config(config_id=event.config_id)
         datasource_type = draft_config.get("type", None)
         if datasource_type is None:
             raise TypeError(  # noqa: TRY003 # one off error
@@ -60,9 +58,7 @@ class DraftDatasourceConfigAction(AgentAction[DraftDatasourceConfigEvent]):
 
         if isinstance(datasource, SQLDatasource):
             asset_names = get_asset_names(datasource)
-            self._update_asset_names_list(
-                config_id=event.config_id, workspace_id=event.workspace_id, asset_names=asset_names
-            )
+            self._update_asset_names_list(config_id=event.config_id, asset_names=asset_names)
 
         return ActionResult(
             id=id,
@@ -70,13 +66,11 @@ class DraftDatasourceConfigAction(AgentAction[DraftDatasourceConfigEvent]):
             created_resources=[],
         )
 
-    def _update_asset_names_list(
-        self, config_id: UUID, workspace_id: UUID, asset_names: list[str]
-    ) -> None:
+    def _update_asset_names_list(self, config_id: UUID, asset_names: list[str]) -> None:
         with create_session(access_token=self._auth_key) as session:
             url = urljoin(
                 base=self._base_url,
-                url=f"/api/v1/organizations/{self._organization_id}/workspaces/{workspace_id}/draft-table-names/{config_id}",
+                url=f"/api/v1/organizations/{self._domain_context.organization_id}/workspaces/{self._domain_context.workspace_id}/draft-table-names/{config_id}",
             )
             response = session.put(
                 url=url,
@@ -90,10 +84,10 @@ class DraftDatasourceConfigAction(AgentAction[DraftDatasourceConfigEvent]):
                 f"={config_id}.",
             )
 
-    def get_draft_config(self, config_id: UUID, workspace_id: UUID) -> dict[str, Any]:
+    def get_draft_config(self, config_id: UUID) -> dict[str, Any]:
         resource_url = urljoin(
             base=self._base_url,
-            url=f"/api/v1/organizations/{self._organization_id}/workspaces/{workspace_id}/draft-datasources/{config_id}",
+            url=f"/api/v1/organizations/{self._domain_context.organization_id}/workspaces/{self._domain_context.workspace_id}/draft-datasources/{config_id}",
         )
         with create_session(access_token=self._auth_key) as session:
             response = session.get(resource_url)

great_expectations_cloud/agent/actions/generate_data_quality_check_expectations_action.py

@@ -43,6 +43,7 @@ from great_expectations_cloud.agent.event_handler import register_event_action
 from great_expectations_cloud.agent.exceptions import GXAgentError
 from great_expectations_cloud.agent.models import (
     CreatedResource,
+    DomainContext,
     GenerateDataQualityCheckExpectationsEvent,
 )
 from great_expectations_cloud.agent.utils import (
@@ -83,13 +84,13 @@ class GenerateDataQualityCheckExpectationsAction(
         self,
         context: CloudDataContext,
         base_url: str,
-        organization_id: UUID,
+        domain_context: DomainContext,
         auth_key: str,
         metric_repository: MetricRepository | None = None,
         batch_inspector: BatchInspector | None = None,
     ):
         super().__init__(
-            context=context, base_url=base_url, organization_id=organization_id, auth_key=auth_key
+            context=context, base_url=base_url, domain_context=domain_context, auth_key=auth_key
         )
         self._metric_repository = metric_repository or MetricRepository(
             data_store=CloudDataStore(self._context)
@@ -100,8 +101,6 @@ class GenerateDataQualityCheckExpectationsAction(
 
     @override
     def run(self, event: GenerateDataQualityCheckExpectationsEvent, id: str) -> ActionResult:
-        self._workspace_id = event.workspace_id
-
         created_resources: list[CreatedResource] = []
         assets_with_errors: list[str] = []
         selected_dqis: Sequence[DataQualityIssues] = event.selected_data_quality_issues or []
@@ -206,7 +205,7 @@ class GenerateDataQualityCheckExpectationsAction(
             metric_list=[
                 MetricTypes.TABLE_COLUMNS,
                 MetricTypes.TABLE_COLUMN_TYPES,
-                MetricTypes.COLUMN_NULL_COUNT,
+                MetricTypes.COLUMN_NON_NULL_COUNT,
                 MetricTypes.TABLE_ROW_COUNT,
             ],
         )
@@ -225,7 +224,7 @@ class GenerateDataQualityCheckExpectationsAction(
         """
         url = urljoin(
             base=self._base_url,
-            url=f"/api/v1/organizations/{self._organization_id}/workspaces/{self._workspace_id}/expectations/",
+            url=f"/api/v1/organizations/{self._domain_context.organization_id}/workspaces/{self._domain_context.workspace_id}/expectations/",
         )
         with create_session(access_token=self._auth_key) as session:
             response = session.get(
@@ -375,11 +374,11 @@ class GenerateDataQualityCheckExpectationsAction(
             metric
             for metric in metric_run.metrics
             if isinstance(metric, ColumnMetric)
-            and metric.metric_name == MetricTypes.COLUMN_NULL_COUNT
+            and metric.metric_name == MetricTypes.COLUMN_NON_NULL_COUNT
         ]
 
         if not column_null_values_metric or len(column_null_values_metric) == 0:
-            raise RuntimeError("missing COLUMN_NULL_COUNT metrics")  # noqa: TRY003
+            raise RuntimeError("missing COLUMN_NON_NULL_COUNT metrics")  # noqa: TRY003
 
         expectation_ids = []
         # Single-expectation approach using ExpectColumnProportionOfNonNullValuesToBeBetween
@@ -390,7 +389,7 @@ class GenerateDataQualityCheckExpectationsAction(
         )
         for column in columns_missing_completeness_coverage:
             column_name = column.column
-            null_count = column.value
+            non_null_count = column.value
             row_count = table_row_count.value
             expectation: gx_expectations.Expectation
 
@@ -400,7 +399,6 @@ class GenerateDataQualityCheckExpectationsAction(
             max_param_name = f"{unique_id}_proportion_max"
 
             # Calculate non-null proportion
-            non_null_count = row_count - null_count if row_count > 0 else 0
             non_null_proportion = non_null_count / row_count if row_count > 0 else 0
 
             if use_forecast:
@@ -527,7 +525,7 @@ class GenerateDataQualityCheckExpectationsAction(
     ) -> UUID:
         url = urljoin(
             base=self._base_url,
-            url=f"/api/v1/organizations/{self._organization_id}/workspaces/{self._workspace_id}/expectations/{asset_id}",
+            url=f"/api/v1/organizations/{self._domain_context.organization_id}/workspaces/{self._domain_context.workspace_id}/expectations/{asset_id}",
         )
 
         expectation_payload = expectation.configuration.to_json_dict()

great_expectations_cloud/agent/actions/list_asset_names.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from urllib.parse import urljoin
-from uuid import UUID
 
 from great_expectations.core.http import create_session
 from great_expectations.datasource.fluent import SQLDatasource
@@ -34,7 +33,6 @@ class ListAssetNamesAction(AgentAction[ListAssetNamesEvent]):
 
         self._add_or_update_asset_names_list(
             datasource_id=str(datasource.id),
-            workspace_id=event.workspace_id,
             asset_names=asset_names,
         )
 
@@ -44,13 +42,11 @@ class ListAssetNamesAction(AgentAction[ListAssetNamesEvent]):
             created_resources=[],
         )
 
-    def _add_or_update_asset_names_list(
-        self, datasource_id: str, workspace_id: UUID, asset_names: list[str]
-    ) -> None:
+    def _add_or_update_asset_names_list(self, datasource_id: str, asset_names: list[str]) -> None:
         with create_session(access_token=self._auth_key) as session:
             url = urljoin(
                 base=self._base_url,
-                url=f"/api/v1/organizations/{self._organization_id}/workspaces/{workspace_id}/table-names/{datasource_id}",
+                url=f"/api/v1/organizations/{self._domain_context.organization_id}/workspaces/{self._domain_context.workspace_id}/table-names/{datasource_id}",
             )
             response = session.put(
                 url=url,

great_expectations_cloud/agent/actions/run_checkpoint.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import logging
+import socket
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Final
 
 from typing_extensions import override
 
@@ -21,6 +23,8 @@ if TYPE_CHECKING:
     from great_expectations.data_context import CloudDataContext
     from great_expectations.datasource.fluent.interfaces import DataAsset, Datasource
 
+LOGGER: Final[logging.Logger] = logging.getLogger(__name__)
+
 
 class RunCheckpointAction(AgentAction[RunCheckpointEvent]):
     @override
@@ -45,12 +49,28 @@ def run_checkpoint(
     id: str,
     expectation_parameters: dict[str, Any] | None = None,
 ) -> ActionResult:
+    """Run a checkpoint and return the result."""
+    hostname = socket.gethostname()
+    log_extra = {
+        "correlation_id": id,
+        "checkpoint_name": event.checkpoint_name,
+        "hostname": hostname,
+    }
+
     # the checkpoint_name property on possible events is optional for backwards compatibility,
     # but this action requires it in order to run:
     if not event.checkpoint_name:
         raise MissingCheckpointNameError
 
+    LOGGER.debug("Fetching checkpoint from context", extra=log_extra)
     checkpoint = context.checkpoints.get(name=event.checkpoint_name)
+    LOGGER.debug(
+        "Checkpoint fetched successfully",
+        extra={
+            **log_extra,
+            "validation_definitions_count": len(checkpoint.validation_definitions),
+        },
+    )
 
     # only GX-managed Checkpoints are currently validated here and they contain only one validation definition, but
     # the Checkpoint does allow for multiple validation definitions so we'll be defensive and ensure we only test each
@@ -66,15 +86,48 @@ def run_checkpoint(
             )
         data_sources_assets_by_data_source_name[ds_name].assets_by_name[vd.asset.name] = vd.asset
 
-    for data_sources_assets in data_sources_assets_by_data_source_name.values():
+    # Test connections to all datasources and assets
+    for ds_name, data_sources_assets in data_sources_assets_by_data_source_name.items():
         data_source = data_sources_assets.data_source
+        LOGGER.debug(
+            "Testing datasource connection",
+            extra={**log_extra, "datasource_name": ds_name},
+        )
         data_source.test_connection(test_assets=False)  # raises `TestConnectionError` on failure
-        for data_asset in data_sources_assets.assets_by_name.values():
+        LOGGER.debug(
+            "Datasource connection successful",
+            extra={**log_extra, "datasource_name": ds_name},
+        )
+
+        for asset_name, data_asset in data_sources_assets.assets_by_name.items():
+            LOGGER.debug(
+                "Testing data asset connection",
+                extra={**log_extra, "datasource_name": ds_name, "asset_name": asset_name},
+            )
             data_asset.test_connection()  # raises `TestConnectionError` on failure
+            LOGGER.debug(
+                "Data asset connection successful",
+                extra={**log_extra, "datasource_name": ds_name, "asset_name": asset_name},
+            )
 
+    LOGGER.debug(
+        "Running checkpoint",
+        extra={
+            **log_extra,
+            "datasources_count": len(data_sources_assets_by_data_source_name),
+            "has_expectation_parameters": expectation_parameters is not None,
+        },
+    )
     checkpoint_run_result = checkpoint.run(
         batch_parameters=event.splitter_options, expectation_parameters=expectation_parameters
     )
+    LOGGER.debug(
+        "Checkpoint run completed",
+        extra={
+            **log_extra,
+            "run_results_count": len(checkpoint_run_result.run_results),
+        },
+    )
 
     validation_results = checkpoint_run_result.run_results
     created_resources = []
@@ -88,6 +141,14 @@ def run_checkpoint(
         )
         created_resources.append(created_resource)
 
+    LOGGER.debug(
+        "Checkpoint action completed successfully",
+        extra={
+            **log_extra,
+            "created_resources_count": len(created_resources),
+        },
+    )
+
     return ActionResult(
         id=id,
         type=event.type,

great_expectations_cloud/agent/actions/run_metric_list_action.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
-from uuid import UUID
 
 from great_expectations.experimental.metric_repository.batch_inspector import (
     BatchInspector,
@@ -21,6 +20,7 @@ from great_expectations_cloud.agent.actions import ActionResult, AgentAction
 from great_expectations_cloud.agent.event_handler import register_event_action
 from great_expectations_cloud.agent.models import (
     CreatedResource,
+    DomainContext,
     RunMetricsListEvent,
 )
 
@@ -34,13 +34,13 @@ class MetricListAction(AgentAction[RunMetricsListEvent]):
         self,
         context: CloudDataContext,
         base_url: str,
-        organization_id: UUID,
+        domain_context: DomainContext,
         auth_key: str,
         metric_repository: MetricRepository | None = None,
         batch_inspector: BatchInspector | None = None,
     ):
         super().__init__(
-            context=context, base_url=base_url, organization_id=organization_id, auth_key=auth_key
+            context=context, base_url=base_url, domain_context=domain_context, auth_key=auth_key
         )
         self._metric_repository = metric_repository or MetricRepository(
             data_store=CloudDataStore(self._context)

great_expectations_cloud/agent/actions/run_scheduled_checkpoint.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import logging
+import socket
+from typing import TYPE_CHECKING, Final
 from urllib.parse import urljoin
 
 from great_expectations.core.http import create_session
@@ -18,13 +20,15 @@ from great_expectations_cloud.agent.models import RunScheduledCheckpointEvent
 if TYPE_CHECKING:
     from great_expectations.data_context import CloudDataContext
 
+LOGGER: Final[logging.Logger] = logging.getLogger(__name__)
+
 
 class RunScheduledCheckpointAction(AgentAction[RunScheduledCheckpointEvent]):
     @override
     def run(self, event: RunScheduledCheckpointEvent, id: str) -> ActionResult:
         expectation_parameters_url = urljoin(
             base=self._base_url,
-            url=f"/api/v1/organizations/{self._organization_id}/workspaces/{event.workspace_id}/checkpoints/{event.checkpoint_id}/expectation-parameters",
+            url=f"/api/v1/organizations/{self._domain_context.organization_id}/workspaces/{self._domain_context.workspace_id}/checkpoints/{event.checkpoint_id}/expectation-parameters",
         )
         return run_scheduled_checkpoint(
             context=self._context,
@@ -38,16 +42,31 @@ class RunScheduledCheckpointAction(AgentAction[RunScheduledCheckpointEvent]):
 def run_scheduled_checkpoint(
     context: CloudDataContext, event: RunScheduledCheckpointEvent, id: str, auth_key: str, url: str
 ) -> ActionResult:
+    """Run a scheduled checkpoint, fetching expectation parameters from GX Cloud first."""
+    hostname = socket.gethostname()
+    log_extra = {
+        "correlation_id": id,
+        "checkpoint_id": str(event.checkpoint_id),
+        "schedule_id": str(event.schedule_id),
+        "hostname": hostname,
+    }
+
+    LOGGER.debug("Fetching expectation parameters from GX Cloud", extra=log_extra)
     with create_session(access_token=auth_key) as session:
         response = session.get(url=url)
 
     if not response.ok:
+        LOGGER.error(
+            "Failed to fetch expectation parameters",
+            extra={**log_extra, "response_status": response.status_code},
+        )
         raise GXCloudError(
             message=f"RunScheduledCheckpointAction encountered an error while connecting to GX Cloud. "
             f"Unable to retrieve expectation_parameters for Checkpoint with ID={event.checkpoint_id}.",
             response=response,
         )
     data = response.json()
+    LOGGER.debug("Expectation parameters fetched successfully", extra=log_extra)
 
     try:
         expectation_parameters = (
@@ -56,11 +75,16 @@ def run_scheduled_checkpoint(
             else None
         )
     except KeyError as e:
+        LOGGER.exception("Malformed response from GX Cloud", extra=log_extra)
         raise GXCloudError(
             message="Malformed response received from GX Cloud",
             response=response,
         ) from e
 
+    LOGGER.debug(
+        "Proceeding to run checkpoint",
+        extra={**log_extra, "has_expectation_parameters": expectation_parameters is not None},
+    )
     return run_checkpoint(context, event, id, expectation_parameters=expectation_parameters)
 
 

great_expectations_cloud/agent/actions/run_window_checkpoint.py

@@ -24,7 +24,7 @@ class RunWindowCheckpointAction(AgentAction[RunWindowCheckpointEvent]):
     def run(self, event: RunWindowCheckpointEvent, id: str) -> ActionResult:
         expectation_parameters_url = urljoin(
             base=self._base_url,
-            url=f"/api/v1/organizations/{self._organization_id}/workspaces/{event.workspace_id}/checkpoints/{event.checkpoint_id}/expectation-parameters",
+            url=f"/api/v1/organizations/{self._domain_context.organization_id}/workspaces/{self._domain_context.workspace_id}/checkpoints/{event.checkpoint_id}/expectation-parameters",
         )
         return run_window_checkpoint(
             self._context,

great_expectations_cloud/agent/agent.py

@@ -3,13 +3,19 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import resource
 import signal
+import socket
+import sys
+import threading
+import time
 import traceback
 import warnings
 from collections import defaultdict
 from concurrent.futures import Future
 from concurrent.futures.thread import ThreadPoolExecutor
 from functools import partial
+from http import HTTPStatus
 from importlib.metadata import version as metadata_version
 from typing import TYPE_CHECKING, Any, Callable, Final, Literal
 from urllib.parse import urljoin, urlparse
@@ -65,6 +71,7 @@ from great_expectations_cloud.agent.models import (
     AgentBaseExtraForbid,
     CreateScheduledJobAndSetJobStarted,
     CreateScheduledJobAndSetJobStartedRequest,
+    DomainContext,
     JobCompleted,
     JobStarted,
     JobStatus,
@@ -136,6 +143,9 @@ class GXAgent:
     _PYPI_GX_AGENT_PACKAGE_NAME = "great_expectations_cloud"
     _PYPI_GREAT_EXPECTATIONS_PACKAGE_NAME = "great_expectations"
 
+    # Heartbeat interval in seconds (log progress every 60 seconds during job processing)
+    _HEARTBEAT_INTERVAL_SECONDS = 60
+
     def __init__(self: Self):
         self._config = self._create_config()
 
@@ -159,6 +169,15 @@ class GXAgent:
         self._correlation_ids: defaultdict[str, int] = defaultdict(lambda: 0)
         self._listen_tries = 0
 
+        # Heartbeat tracking
+        self._heartbeat_stop_event: threading.Event | None = None
+        self._heartbeat_thread: threading.Thread | None = None
+        self._current_job_correlation_id: str | None = None
+        self._current_job_start_time: float | None = None
+
+        # Install signal handlers for graceful shutdown logging
+        self._install_signal_handlers()
+
     def run(self) -> None:
         """Open a connection to GX Cloud."""
 
@@ -218,6 +237,98 @@ class GXAgent:
             if subscriber is not None:
                 subscriber.close()
 
+    def _install_signal_handlers(self) -> None:
+        """Install signal handlers to log when the process receives shutdown signals."""
+        original_sigterm = signal.getsignal(signal.SIGTERM)
+        original_sigint = signal.getsignal(signal.SIGINT)
+
+        def sigterm_handler(signum: int, frame: Any) -> None:
+            self._log_signal_received("SIGTERM", signum)
+            if callable(original_sigterm):
+                original_sigterm(signum, frame)
+            elif original_sigterm == signal.SIG_DFL:
+                raise SystemExit(128 + signum)
+
+        def sigint_handler(signum: int, frame: Any) -> None:
+            self._log_signal_received("SIGINT", signum)
+            if callable(original_sigint):
+                original_sigint(signum, frame)
+            elif original_sigint == signal.SIG_DFL:
+                raise KeyboardInterrupt
+
+        signal.signal(signal.SIGTERM, sigterm_handler)
+        signal.signal(signal.SIGINT, sigint_handler)
+
+    def _log_signal_received(self, signal_name: str, signum: int) -> None:
+        """Log when a shutdown signal is received, including current job info."""
+        memory_mb = self._get_memory_usage_mb()
+        LOGGER.warning(
+            f"Received {signal_name} signal - shutting down",
+            extra={
+                "signal": signal_name,
+                "signal_number": signum,
+                "hostname": socket.gethostname(),
+                "current_job_correlation_id": self._current_job_correlation_id,
+                "job_elapsed_seconds": (
+                    time.time() - self._current_job_start_time
+                    if self._current_job_start_time
+                    else None
+                ),
+                "memory_usage_mb": memory_mb,
+                "has_active_task": self._current_task is not None and not self._current_task.done(),
+            },
+        )
+
+    def _get_memory_usage_mb(self) -> float:
+        """Get current memory usage in MB using resource module."""
+        # ru_maxrss is in KB on Linux, bytes on macOS
+        usage = resource.getrusage(resource.RUSAGE_SELF)
+        # On macOS, ru_maxrss is in bytes; on Linux, it's in KB
+        if sys.platform == "darwin":
+            return usage.ru_maxrss / (1024 * 1024)
+        return usage.ru_maxrss / 1024
+
+    def _start_heartbeat(self, correlation_id: str, org_id: UUID, workspace_id: UUID) -> None:
+        """Start a background thread that logs periodic heartbeats during job processing."""
+        self._current_job_correlation_id = correlation_id
+        self._current_job_start_time = time.time()
+        self._heartbeat_stop_event = threading.Event()
+
+        def heartbeat_loop() -> None:
+            stop_event = self._heartbeat_stop_event
+            if stop_event is None:
+                return
+            while not stop_event.wait(timeout=self._HEARTBEAT_INTERVAL_SECONDS):
+                if stop_event.is_set():
+                    break
+                elapsed = time.time() - (self._current_job_start_time or time.time())
+                memory_mb = self._get_memory_usage_mb()
+                LOGGER.debug(
+                    "job.heartbeat",
+                    extra={
+                        "correlation_id": correlation_id,
+                        "organization_id": str(org_id),
+                        "workspace_id": str(workspace_id),
+                        "hostname": socket.gethostname(),
+                        "elapsed_seconds": round(elapsed, 1),
+                        "memory_usage_mb": round(memory_mb, 1),
+                    },
+                )
+
+        self._heartbeat_thread = threading.Thread(target=heartbeat_loop, daemon=True)
+        self._heartbeat_thread.start()
+
+    def _stop_heartbeat(self) -> None:
+        """Stop the heartbeat thread."""
+        if self._heartbeat_stop_event:
+            self._heartbeat_stop_event.set()
+        if self._heartbeat_thread and self._heartbeat_thread.is_alive():
+            self._heartbeat_thread.join(timeout=2)
+        self._heartbeat_thread = None
+        self._heartbeat_stop_event = None
+        self._current_job_correlation_id = None
+        self._current_job_start_time = None
+
     @classmethod
     def get_current_gx_agent_version(cls) -> str:
         version: str = metadata_version(cls._PYPI_GX_AGENT_PACKAGE_NAME)
@@ -237,8 +348,26 @@ class GXAgent:
         Args:
             event_context: An Event with related properties and actions.
         """
+        # Track how many times this correlation_id has been seen BY THIS POD (for local diagnostics)
+        # Note: event_context.redelivered is set by RabbitMQ and indicates cross-pod redelivery
+        local_delivery_count = self._correlation_ids.get(event_context.correlation_id, 0)
+
         if self._reject_correlation_id(event_context.correlation_id) is True:
-            # this event has been redelivered too many times - remove it from circulation
+            # this event has been redelivered too many times to THIS pod - remove it from circulation
+            LOGGER.error(
+                "Message redelivered too many times to this pod, removing from queue",
+                extra={
+                    "event_type": event_context.event.type,
+                    "correlation_id": event_context.correlation_id,
+                    "organization_id": self.get_organization_id(event_context),
+                    "workspace_id": str(self.get_workspace_id(event_context)),
+                    "schedule_id": event_context.event.schedule_id
+                    if isinstance(event_context.event, ScheduledEventBase)
+                    else None,
+                    "local_delivery_count": local_delivery_count,
+                    "redelivered": event_context.redelivered,
+                },
+            )
             event_context.processed_with_failures()
             return
         elif self._can_accept_new_task() is not True:
@@ -252,6 +381,7 @@ class GXAgent:
                     "schedule_id": event_context.event.schedule_id
                     if isinstance(event_context.event, ScheduledEventBase)
                     else None,
+                    "redelivered": event_context.redelivered,
                 },
             )
             # request that this message is redelivered later
@@ -260,6 +390,20 @@ class GXAgent:
             self._redeliver_msg_task = loop.create_task(event_context.redeliver_message())
             return
 
+        if event_context.redelivered:
+            LOGGER.warning(
+                "rabbitmq.message.redelivered",
+                extra={
+                    "event_type": event_context.event.type,
+                    "correlation_id": event_context.correlation_id,
+                    "organization_id": self.get_organization_id(event_context),
+                    "workspace_id": str(self.get_workspace_id(event_context)),
+                    "schedule_id": event_context.event.schedule_id
+                    if isinstance(event_context.event, ScheduledEventBase)
+                    else None,
+                },
+            )
+
         self._current_task = self._executor.submit(
             self._handle_event,
             event_context=event_context,
@@ -341,8 +485,9 @@ class GXAgent:
                 org_id=org_id,
                 workspace_id=workspace_id,
             )
+        memory_mb = self._get_memory_usage_mb()
         LOGGER.info(
-            "Starting job",
+            "job.started",
             extra={
                 "event_type": event_context.event.type,
                 "correlation_id": event_context.correlation_id,
@@ -351,9 +496,14 @@ class GXAgent:
                 "schedule_id": event_context.event.schedule_id
                 if isinstance(event_context.event, ScheduledEventBase)
                 else None,
+                "hostname": socket.gethostname(),
+                "redelivered": event_context.redelivered,
+                "memory_usage_mb": round(memory_mb, 1),
             },
         )
 
+        self._start_heartbeat(event_context.correlation_id, org_id, workspace_id)
+
         self._set_sentry_tags(event_context)
 
         handler = EventHandler(context=data_context)
@@ -363,7 +513,7 @@ class GXAgent:
             id=event_context.correlation_id,
             base_url=base_url,
             auth_key=auth_key,
-            organization_id=org_id,
+            domain_context=DomainContext(organization_id=org_id, workspace_id=workspace_id),
         )
         return result
 
@@ -378,11 +528,30 @@ class GXAgent:
         """
         # warning:  this method will not be executed in the main thread
 
+        # Calculate job duration before stopping heartbeat (which clears start time)
+        job_elapsed_time = (
+            time.time() - self._current_job_start_time if self._current_job_start_time else None
+        )
+        self._stop_heartbeat()
+
         org_id = self.get_organization_id(event_context)
         workspace_id = self.get_workspace_id(event_context)
 
+        memory_mb = self._get_memory_usage_mb()
+        LOGGER.debug(
+            "job.thread_exiting",
+            extra={
+                "correlation_id": event_context.correlation_id,
+                "hostname": socket.gethostname(),
+                "has_exception": future.exception() is not None,
+                "cancelled": future.cancelled(),
+                "memory_usage_mb": round(memory_mb, 1),
+            },
+        )
+
         # get results or errors from the thread
         error = future.exception()
+
         if error is None:
             result: ActionResult = future.result()
 
@@ -393,16 +562,21 @@ class GXAgent:
                     error_stack_trace="The version of the GX Agent you are using does not support this functionality. Please upgrade to the most recent image tagged with `stable`.",
                     processed_by=self._get_processed_by(),
                 )
-                LOGGER.error(
-                    "Job completed with error. Ensure agent is up-to-date.",
+                LOGGER.warning(
+                    "job.completed",
                     extra={
                         "event_type": event_context.event.type,
-                        "id": event_context.correlation_id,
+                        "correlation_id": event_context.correlation_id,
+                        "job_duration": job_elapsed_time,
+                        "success": False,
                         "organization_id": str(org_id),
                         "workspace_id": str(workspace_id),
                         "schedule_id": event_context.event.schedule_id
                         if isinstance(event_context.event, ScheduledEventBase)
                         else None,
+                        "hostname": socket.gethostname(),
+                        "error_type": "UnknownEvent",
+                        "error_message": "Agent does not support this event type. Upgrade required.",
                     },
                 )
             else:
@@ -412,30 +586,40 @@ class GXAgent:
                     processed_by=self._get_processed_by(),
                 )
                 LOGGER.info(
-                    "Completed job",
+                    "job.completed",
                     extra={
                         "event_type": event_context.event.type,
                         "correlation_id": event_context.correlation_id,
                         "job_duration": (
                             result.job_duration.total_seconds() if result.job_duration else None
                         ),
+                        "success": True,
                         "organization_id": str(org_id),
                         "workspace_id": str(workspace_id),
                         "schedule_id": event_context.event.schedule_id
                         if isinstance(event_context.event, ScheduledEventBase)
                         else None,
+                        "hostname": socket.gethostname(),
                     },
                 )
         else:
-            status = build_failed_job_completed_status(error)
+            status = build_failed_job_completed_status(error, processed_by=self._get_processed_by())
             LOGGER.info(traceback.format_exc())
-            LOGGER.info(
-                "Job completed with error",
+            LOGGER.warning(
+                "job.completed",
                 extra={
                     "event_type": event_context.event.type,
                     "correlation_id": event_context.correlation_id,
+                    "job_duration": job_elapsed_time,
+                    "success": False,
                     "organization_id": str(org_id),
                     "workspace_id": str(workspace_id),
+                    "schedule_id": event_context.event.schedule_id
+                    if isinstance(event_context.event, ScheduledEventBase)
+                    else None,
+                    "hostname": socket.gethostname(),
+                    "error_type": type(error).__name__,
+                    "error_message": str(error)[:500],  # Truncate to avoid huge logs
                 },
             )
 
@@ -655,6 +839,31 @@ class GXAgent:
         with create_session(access_token=self.get_auth_key()) as session:
             payload = CreateScheduledJobAndSetJobStartedRequest(data=data).json()
             response = session.post(agent_sessions_url, data=payload)
+
+            if response.status_code == HTTPStatus.BAD_REQUEST:
+                try:
+                    response_body = response.json()
+                except Exception:
+                    response_body = response.text
+                LOGGER.warning(
+                    "Job already exists - this message was likely redelivered by RabbitMQ "
+                    "after another runner already claimed it. Continuing to process anyway "
+                    "as a safety measure in case the original runner failed.",
+                    extra={
+                        "correlation_id": str(event_context.correlation_id),
+                        "event_type": str(event_context.event.type),
+                        "organization_id": str(org_id),
+                        "schedule_id": str(event_context.event.schedule_id),
+                        "workspace_id": str(workspace_id),
+                        "response_status": response.status_code,
+                        "response_body": response_body,
+                    },
+                )
+                # Note: We intentionally continue processing instead of NACKing.
+                # This ensures job completion even if the first runner fails.
+                # TODO: Once we add inProgress timeout in Mercury, we can
+                # safely NACK here to prevent duplicate processing.
+
             LOGGER.info(
                 "Created scheduled job and set started",
                 extra={
@@ -663,6 +872,7 @@ class GXAgent:
                     "organization_id": str(org_id),
                     "schedule_id": str(event_context.event.schedule_id),
                     "workspace_id": str(workspace_id),
+                    "response_status": response.status_code,
                 },
             )
             GXAgent._log_http_error(

great_expectations_cloud/agent/event_handler.py

@@ -15,6 +15,7 @@ from pydantic import v1 as pydantic_v1
 from great_expectations_cloud.agent.actions.unknown import UnknownEventAction
 from great_expectations_cloud.agent.exceptions import GXAgentError
 from great_expectations_cloud.agent.models import (
+    DomainContext,
     Event,
     EventType,
     UnknownEvent,
@@ -67,11 +68,11 @@ class EventHandler:
         self._context = context
 
     def get_event_action(
-        self, event: Event, base_url: str, auth_key: str, organization_id: UUID
+        self, event: Event, base_url: str, auth_key: str, domain_context: DomainContext
     ) -> AgentAction[Any]:
         """Get the action that should be run for the given event."""
 
-        if not self._check_event_organization_id(event, organization_id):
+        if not self._check_event_organization_id(event, domain_context.organization_id):
             # Making message more generic
             raise GXAgentError("Unable to process job. Invalid input.")  # noqa: TRY003
 
@@ -84,17 +85,17 @@ class EventHandler:
         return action_class(
             context=self._context,
             base_url=base_url,
-            organization_id=organization_id,
+            domain_context=domain_context,
             auth_key=auth_key,
         )
 
-    def handle_event(  # Refactor opportunity
-        self, event: Event, id: str, base_url: str, auth_key: str, organization_id: UUID
+    def handle_event(
+        self, event: Event, id: str, base_url: str, auth_key: str, domain_context: DomainContext
     ) -> ActionResult:
-        start_time = datetime.now(tz=timezone.utc)
         """Transform an Event into an ActionResult."""
+        start_time = datetime.now(tz=timezone.utc)
         action = self.get_event_action(
-            event=event, base_url=base_url, auth_key=auth_key, organization_id=organization_id
+            event=event, base_url=base_url, auth_key=auth_key, domain_context=domain_context
         )
         LOGGER.info(f"Handling event: {event.type} -> {action.__class__.__name__}")
         action_result = action.run(event=event, id=id)

great_expectations_cloud/agent/message_service/asyncio_rabbit_mq_client.py

@@ -27,6 +27,7 @@ class OnMessagePayload:
     correlation_id: str
     delivery_tag: int
     body: bytes
+    redelivered: bool = False  # Set by RabbitMQ when message is redelivered
 
 
 class OnMessageFn(Protocol):
@@ -174,8 +175,12 @@ class AsyncRabbitMQClient:
         # param on_message is provided by the caller as an argument to AsyncRabbitMQClient.run
         correlation_id = header_frame.correlation_id
         delivery_tag = method_frame.delivery_tag
+        redelivered = method_frame.redelivered  # RabbitMQ sets this flag on redelivery
         payload = OnMessagePayload(
-            correlation_id=correlation_id, delivery_tag=delivery_tag, body=body
+            correlation_id=correlation_id,
+            delivery_tag=delivery_tag,
+            body=body,
+            redelivered=redelivered,
         )
         return on_message(payload)
 
@@ -190,10 +195,13 @@ class AsyncRabbitMQClient:
     def _on_consumer_canceled(self, method_frame: Basic.Cancel) -> None:
         """Callback invoked when the broker cancels the client's connection."""
         if self._channel is not None:
-            LOGGER.info(
-                "Consumer was cancelled remotely, shutting down",
+            LOGGER.warning(
+                "rabbitmq.consumer.cancelled",
                 extra={
-                    "method_frame": method_frame,
+                    "consumer_tag": method_frame.consumer_tag
+                    if hasattr(method_frame, "consumer_tag")
+                    else None,
+                    "was_consuming": self.was_consuming,
                 },
             )
             self._channel.close()
@@ -232,11 +240,31 @@ class AsyncRabbitMQClient:
         self._reconnect()
         self._log_pika_exception("Connection open failed", reason)
 
-    def _on_connection_closed(
-        self, connection: AsyncioConnection, _unused_reason: pika.Exception
-    ) -> None:
+    def _on_connection_closed(self, connection: AsyncioConnection, reason: pika.Exception) -> None:
         """Callback invoked after the broker closes the connection"""
-        LOGGER.debug("Connection to RabbitMQ has been closed")
+        # Use DEBUG for expected closes, WARNING for unexpected
+        log_level = LOGGER.debug if self._closing else LOGGER.warning
+        if isinstance(reason, (ConnectionClosed, ChannelClosed)):
+            log_level(
+                "rabbitmq.connection.closed",
+                extra={
+                    "reply_code": reason.reply_code,
+                    "reply_text": reason.reply_text,
+                    "was_consuming": self.was_consuming,
+                    "is_closing": self._closing,
+                },
+            )
+        else:
+            log_level(
+                "rabbitmq.connection.closed",
+                extra={
+                    "reply_code": 0,  # Unknown/non-AMQP error
+                    "reply_text": str(reason),
+                    "reason_type": type(reason).__name__,
+                    "was_consuming": self.was_consuming,
+                    "is_closing": self._closing,
+                },
+            )
         self._channel = None
         self._is_unrecoverable = True
         if self._closing:

great_expectations_cloud/agent/message_service/subscriber.py

@@ -37,6 +37,8 @@ class EventContext:
             can be removed from the queue.
         redeliver_message: async callable to signal that the broker should
             try to deliver this message again.
+        redelivered: True if RabbitMQ is redelivering this message (another
+            consumer failed to acknowledge it).
     """
 
     event: Event
@@ -44,6 +46,7 @@ class EventContext:
     processed_successfully: Callable[[], None]
     processed_with_failures: Callable[[], None]
     redeliver_message: Callable[[], Coroutine[OnMessageCallback, None, None]]
+    redelivered: bool = False
 
 
 class OnMessageCallback(Protocol):
@@ -142,6 +145,7 @@ class Subscriber:
             processed_successfully=ack_callback,
             processed_with_failures=nack_callback,
             redeliver_message=redeliver_message,
+            redelivered=payload.redelivered,
         )
 
         return on_message(event_context)

great_expectations_cloud/agent/models.py

@@ -24,6 +24,18 @@ def all_subclasses(cls: type) -> list[type]:
     return all_sub_cls
 
 
+class DomainContext(BaseModel):
+    """
+    Encapsulates domain-related context information.
+
+    This dataclass consolidates organization_id and workspace_id to reduce
+    parameter proliferation and improve code maintainability.
+    """
+
+    organization_id: UUID
+    workspace_id: UUID
+
+
 class AgentBaseExtraForbid(BaseModel):
     class Config:
         # 2024-03-04: ZEL-501 Strictly enforce models for handling outdated APIs
@@ -277,15 +289,23 @@ class CreateScheduledJobAndSetJobStartedRequest(AgentBaseExtraForbid):
     data: CreateScheduledJobAndSetJobStarted
 
 
-def build_failed_job_completed_status(error: BaseException) -> JobCompleted:
+def build_failed_job_completed_status(
+    error: BaseException,
+    processed_by: Literal["agent", "runner"] | None = None,
+) -> JobCompleted:
     if isinstance(error, GXCoreError):
         status = JobCompleted(
             success=False,
             error_stack_trace=str(error),
             error_code=error.error_code,
             error_params=error.get_error_params(),
+            processed_by=processed_by,
         )
     else:
-        status = JobCompleted(success=False, error_stack_trace=str(error))
+        status = JobCompleted(
+            success=False,
+            error_stack_trace=str(error),
+            processed_by=processed_by,
+        )
 
     return status

{great_expectations_cloud-20250915.1.dev1.dist-info → great_expectations_cloud-20260120.0.dev0.dist-info}/METADATA

@@ -1,22 +1,22 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: great_expectations_cloud
-Version: 20250915.1.dev1
+Version: 20260120.0.dev0
 Summary: Great Expectations Cloud
 License: Proprietary
+License-File: LICENSE
 Author: The Great Expectations Team
 Author-email: team@greatexpectations.io
-Requires-Python: >=3.11,<3.12
+Requires-Python: >=3.11.4,<3.12
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
-Requires-Dist: great-expectations[databricks,gx-redshift,mssql,postgresql,snowflake,trino] (==1.6.0)
+Requires-Dist: great-expectations[databricks,gx-redshift,mssql,postgresql,snowflake,trino] (==1.11.1)
 Requires-Dist: orjson (>=3.9.7,<4.0.0,!=3.9.10)
 Requires-Dist: packaging (>=21.3,<26.0)
 Requires-Dist: pika (>=1.3.1,<2.0.0)

{great_expectations_cloud-20250915.1.dev1.dist-info → great_expectations_cloud-20260120.0.dev0.dist-info}/RECORD

@@ -1,34 +1,34 @@
 great_expectations_cloud/__init__.py,sha256=1mr5RDyA2N38eynvEfVbuYIbjFadeJfqZ-X9CrqYiVo,150
 great_expectations_cloud/agent/__init__.py,sha256=FqDFYbGefmNhwlvJwJbNovkwzny6mwaYH5LtTi6VlSU,464
 great_expectations_cloud/agent/actions/__init__.py,sha256=TYPe2j8EgaziXXgSLEdgjnbHKL56O6cQL1kjPnGbRFI,949
-great_expectations_cloud/agent/actions/agent_action.py,sha256=mGAovvT4CDaQlZaeNcz5tqfMIt6cul2anzxPwFrSxeA,1186
-great_expectations_cloud/agent/actions/draft_datasource_config_action.py,sha256=eFiv3Mm7IavSvag8ctD6yooIT8b4n1LQFsKrRzX-lMM,5341
-great_expectations_cloud/agent/actions/generate_data_quality_check_expectations_action.py,sha256=WBAgt0AvJ7T0AqdLZqYsaj-afj4J8K4jSa6u_9TXka0,23635
-great_expectations_cloud/agent/actions/list_asset_names.py,sha256=KNuYgV7fPmL5yTq3lKgEenHBZHoi4h6QMAmbkmHulNQ,2641
-great_expectations_cloud/agent/actions/run_checkpoint.py,sha256=N2d07JDCG06kMve7yjPZQFlaGKoJw5dCbpKuBWw6Ssg,3751
-great_expectations_cloud/agent/actions/run_metric_list_action.py,sha256=tW64pNYJElkUmcd9baKllTSyR-NYyU-40QvMwSwwLqQ,3234
-great_expectations_cloud/agent/actions/run_scheduled_checkpoint.py,sha256=_7IYfMhIBlXzanvl627e83c79ecDlk_bMQAQaQHhdx8,2427
-great_expectations_cloud/agent/actions/run_window_checkpoint.py,sha256=_pseC6tytSiAXsqJVf0Jjirpga8I1IAPEWazPWZ8iJg,2287
+great_expectations_cloud/agent/actions/agent_action.py,sha256=F9zOgVmNJ_V2RhRbDXNMjd46-QVNFN8Lp_bmPvh5cwU,1189
+great_expectations_cloud/agent/actions/draft_datasource_config_action.py,sha256=NVN2GBSty-XvCW7pHDkLImHd3V0iJzpUNIh8rNGDuzs,5241
+great_expectations_cloud/agent/actions/generate_data_quality_check_expectations_action.py,sha256=dhiy_lkcePDy45fEX0uhk-m89_aYKtV6P5jfd-Dcax8,23611
+great_expectations_cloud/agent/actions/list_asset_names.py,sha256=pOL5ip8ZZJbZhDNSp44rjYkx93rKdf3U6f4fY-JLhvg,2576
+great_expectations_cloud/agent/actions/run_checkpoint.py,sha256=xlDYX6BHvHr3loz74hu4ARq5VStJ7-QYf80GPi-PuTY,5697
+great_expectations_cloud/agent/actions/run_metric_list_action.py,sha256=69nyR0vXjz_lKAHYczuEMQtbNIv0lf-DMiOBXmkwpuQ,3237
+great_expectations_cloud/agent/actions/run_scheduled_checkpoint.py,sha256=33lp6F_J1asgBmaHoqLLDL8wRnBw9MEZlQ3bosGQkwk,3425
+great_expectations_cloud/agent/actions/run_window_checkpoint.py,sha256=MCMbgY3dNUx546sNpXg5p3rCWNzDa6EQOUt20Nr5udo,2317
 great_expectations_cloud/agent/actions/unknown.py,sha256=mtWw9tDZqGZSiUWj7PtIlLFJ1dM-7AHBX3SO16-u2EM,739
 great_expectations_cloud/agent/actions/utils.py,sha256=0lzeASN1TYWJ35-H-sCRkcPMHzWU05SzKIyTv0CzvA8,1665
-great_expectations_cloud/agent/agent.py,sha256=JXZTtExQ-gMM6KPiqSH0xa95ugQC4F-fxclzO4bS4Jc,30961
+great_expectations_cloud/agent/agent.py,sha256=JdyWvLdkzMq_kJgLsuhCDZz7NIOjBQZxaUv_UiwiEwg,40826
 great_expectations_cloud/agent/agent_warnings.py,sha256=9-xl_AI2V9Py4o7KzFOQjG3lYx-vZ36fq4w2iiPNiUw,362
 great_expectations_cloud/agent/cli.py,sha256=a_HmPxBMlVD59BEmkZnlbOOAFlezVMx9djZ2XIW-3W0,2885
 great_expectations_cloud/agent/config.py,sha256=c1BOr-TrxZnciWNRuu4atGtfRh-XSmwIS0osDCzQa04,1348
 great_expectations_cloud/agent/constants.py,sha256=SAEtcOwI-SxZiZSVoCFfEC5oCtYdgmyUmK7for_zg_Q,246
-great_expectations_cloud/agent/event_handler.py,sha256=kePpZ4EMIY0YWKeYH4W7lKY8C8OeER_Dkhwwadf3nTc,6069
+great_expectations_cloud/agent/event_handler.py,sha256=wcvAM0i6pnIsWlYstnZ2ThpByJYCyKrRmh0solC02bk,6091
 great_expectations_cloud/agent/exceptions.py,sha256=XIDBVSmBfFpVQA5i9rZqEtORIdi5E4_lwup0jP90TUk,1506
 great_expectations_cloud/agent/message_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-great_expectations_cloud/agent/message_service/asyncio_rabbit_mq_client.py,sha256=B2EwgG_Qdm1s_xkxbGPQxdRBkDSuhkKyT6rGFpXuqQ0,12391
-great_expectations_cloud/agent/message_service/subscriber.py,sha256=K8szy9uM1MUBkMaMZt9o5ExnjqEn1hw6zYaH7pQkjoM,5975
-great_expectations_cloud/agent/models.py,sha256=ea3d6eul8ECvsIubVSEJzeJbX6X9M40oEhaWhj4yuVI,10007
+great_expectations_cloud/agent/message_service/asyncio_rabbit_mq_client.py,sha256=z1iYArWz5qhtsEYSK6Qd2LbiwZsEJOzOvunvtHVRuBo,13630
+great_expectations_cloud/agent/message_service/subscriber.py,sha256=ZEwwLaQe-yypYJWMkpTvRqEgzH7FbYH0-ean8LK1Qt8,6174
+great_expectations_cloud/agent/models.py,sha256=PKPxOXApET47s5Q-c9OqolgZoYghoULuvMFcCsl1soI,10478
 great_expectations_cloud/agent/run.py,sha256=V33RLoB1PFmJ0h0RfHG4SB5lN_Za8tW2Dua6GUpN9yY,639
 great_expectations_cloud/agent/utils.py,sha256=3OvdcXeK1gk2oJgqG4jPvBRwlMCn8LioULW3YgRtj98,2950
 great_expectations_cloud/logging/README.md,sha256=vbwU689x8SkGjzoBYQzZOzAvh28fR0RCa1XY5WD-Dgs,1762
 great_expectations_cloud/logging/logging_cfg.py,sha256=W6mlm4_Z2bjzM5TuKmFg_WZor2XoJm4DAoLGaf2O__I,6579
 great_expectations_cloud/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-great_expectations_cloud-20250915.1.dev1.dist-info/LICENSE,sha256=_JJnoX6N_OkrAwlCRizCwil0tIjDAy2TG3GiJ50sM6k,2084
-great_expectations_cloud-20250915.1.dev1.dist-info/METADATA,sha256=QSzFeoscVVOO7Hssw3wo7WEfwFZwU2c8L0CnGakvaQg,12357
-great_expectations_cloud-20250915.1.dev1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-great_expectations_cloud-20250915.1.dev1.dist-info/entry_points.txt,sha256=ofJgdeS2gSzxXLyCAjfNhIaN1wmSyR7EAMs5qhVaXE4,68
-great_expectations_cloud-20250915.1.dev1.dist-info/RECORD,,
+great_expectations_cloud-20260120.0.dev0.dist-info/METADATA,sha256=UzLgYArcgE5nmCdO27EcqNQVSf7hClmv5Ol0xanWx1c,12331
+great_expectations_cloud-20260120.0.dev0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+great_expectations_cloud-20260120.0.dev0.dist-info/entry_points.txt,sha256=ofJgdeS2gSzxXLyCAjfNhIaN1wmSyR7EAMs5qhVaXE4,68
+great_expectations_cloud-20260120.0.dev0.dist-info/licenses/LICENSE,sha256=_JJnoX6N_OkrAwlCRizCwil0tIjDAy2TG3GiJ50sM6k,2084
+great_expectations_cloud-20260120.0.dev0.dist-info/RECORD,,

{great_expectations_cloud-20250915.1.dev1.dist-info → great_expectations_cloud-20260120.0.dev0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any