[FEATURE] V1 Checkpoint

great_expectations/checkpoint/v1_checkpoint.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Union
+
+import great_expectations.exceptions as gx_exceptions
+from great_expectations import project_manager
+from great_expectations._docs_decorators import public_api
+from great_expectations.checkpoint.actions import ValidationAction  # noqa: TCH001
+from great_expectations.compatibility.pydantic import BaseModel, validator
+from great_expectations.core.serdes import _IdentifierBundle
+from great_expectations.core.validation_config import ValidationConfig
+from great_expectations.render.renderer.renderer import Renderer
+
+if TYPE_CHECKING:
+    from great_expectations.checkpoint.types.checkpoint_result import CheckpointResult
+    from great_expectations.data_context.store.validation_config_store import (
+        ValidationConfigStore,
+    )
+
+
+class Checkpoint(BaseModel):
+    """
+    A Checkpoint is the primary means for validating data in a production deployment of Great Expectations.
+
+    Checkpoints provide a convenient abstraction for running a number of validations and triggering a set of actions
+    to be taken after the validation step.
+
+    Args:
+        validations: List of validation configs to be run.
+        actions: List of actions to be taken after the validations are run.
+
+    """
+
+    name: str
+    validations: List[ValidationConfig]
+    actions: List[ValidationAction]
+    id: Union[str, None] = None
+
+    class Config:
+        arbitrary_types_allowed = (
+            True  # Necessary for compatibility with ValidationAction's Marshmallow dep
+        )
+        """
+        When serialized, the validations field should be encoded as a set of identifiers.
+        These will be used as foreign keys to retrieve the actual objects from the appropriate stores.
+
+        Example:
+        {
+            "name": "my_checkpoint",
+            "validations": [
+                {
+                    "name": "my_first_validation",
+                    "id": "a758816-64c8-46cb-8f7e-03c12cea1d67"
+                },
+                {
+                    "name": "my_second_validation",
+                    "id": "1339js16-64c8-46cb-8f7e-03c12cea1d67"
+                },
+            ],
+            "actions": [
+                {
+                    "name": "my_slack_action",
+                    "slack_webhook": "https://hooks.slack.com/services/ABC123/DEF456/XYZ789",
+                    "notify_on": "all",
+                    "notify_with": ["my_data_docs_site"],
+                    "renderer": {
+                        "class_name": "SlackRenderer",
+                    }
+                }
+        """
+        json_encoders = {
+            ValidationConfig: lambda v: v.serialize(),
+            Renderer: lambda r: r.serialize(),
+            # ExpectationSuite: lambda e: e.serialize(),
+            # BatchConfig: lambda b: b.serialize(),
+        }
+
+    @validator("validations", pre=True)
+    def _validate_validations(
+        cls, validations: list[ValidationConfig] | list[dict]
+    ) -> list[ValidationConfig]:
+        if len(validations) == 0:
+            raise ValueError("Checkpoint must contain at least one validation")
+
+        if isinstance(validations[0], dict):
+            validation_config_store = project_manager.get_validation_config_store()
+            identifier_bundles = [_IdentifierBundle(**v) for v in validations]
+            return cls._deserialize_identifier_bundles_to_validation_configs(
+                identifier_bundles=identifier_bundles, store=validation_config_store
+            )
+
+        return validations
+
+    @classmethod
+    def _deserialize_identifier_bundles_to_validation_configs(
+        cls, identifier_bundles: list[_IdentifierBundle], store: ValidationConfigStore
+    ) -> list[ValidationConfig]:
+        validations: list[ValidationConfig] = []
+        for id_bundle in identifier_bundles:
+            key = store.get_key(name=id_bundle.name, id=id_bundle.id)
+
+            try:
+                validation_config = store.get(key=key)
+            except (KeyError, gx_exceptions.InvalidKeyError):
+                raise ValueError(
+                    f"Unable to retrieve validation config {id_bundle} from store"
+                )
+
+            validations.append(validation_config)
+
+        return validations
+
+    @public_api
+    def run(
+        self,
+        batch_params: Dict[str, Any] | None = None,
+        suite_params: Dict[str, Any] | None = None,
+    ) -> CheckpointResult:
+        raise NotImplementedError
+
+    @public_api
+    def save(self) -> None:
+        raise NotImplementedError

great_expectations/core/batch_config.py

@@ -7,6 +7,7 @@
 # if we move this import into the TYPE_CHECKING block, we need to provide the
 # Partitioner class when we update forward refs, so we just import here.
 from great_expectations.core.partitioners import Partitioner  # noqa: TCH001
+from great_expectations.core.serdes import _EncodedValidationData, _IdentifierBundle
 
 if TYPE_CHECKING:
     from great_expectations.datasource.fluent.batch_request import (
@@ -47,3 +48,21 @@ def build_batch_request(
 
     def save(self) -> None:
         self.data_asset._save_batch_config(self)
+
+    def serialize(self) -> _EncodedValidationData:
+        asset = self.data_asset
+        ds = asset.datasource
+        return _EncodedValidationData(
+            datasource=_IdentifierBundle(
+                name=ds.name,
+                id=ds.id,
+            ),
+            asset=_IdentifierBundle(
+                name=asset.name,
+                id=str(asset.id) if asset.id else None,
+            ),
+            batch_definition=_IdentifierBundle(
+                name=self.name,
+                id=self.id,
+            ),
+        )

great_expectations/core/expectation_suite.py

@@ -40,6 +40,7 @@
     _deduplicate_evaluation_parameter_dependencies,
 )
 from great_expectations.core.metric_domain_types import MetricDomainTypes
+from great_expectations.core.serdes import _IdentifierBundle
 from great_expectations.core.util import (
     convert_to_json_serializable,
     ensure_json_serializable,
@@ -1110,6 +1111,16 @@ def render(self) -> None:
                 )
             )
 
+    def serialize(self) -> _IdentifierBundle:
+        from great_expectations import project_manager
+
+        if not self.id:
+            expectation_store = project_manager.get_expectations_store()
+            key = expectation_store.get_key(name=self.name, id=None)
+            expectation_store.add(key=key, value=self)
+
+        return _IdentifierBundle(name=self.name, id=self.id)
+
 
 _TExpectationSuite = TypeVar("_TExpectationSuite", ExpectationSuite, dict)
 

great_expectations/core/serdes.py

@@ -0,0 +1,16 @@
+from typing import Union
+
+from great_expectations.compatibility.pydantic import (
+    BaseModel,
+)
+
+
+class _IdentifierBundle(BaseModel):
+    name: str
+    id: Union[str, None]
+
+
+class _EncodedValidationData(BaseModel):
+    datasource: _IdentifierBundle
+    asset: _IdentifierBundle
+    batch_definition: _IdentifierBundle

great_expectations/core/validation_config.py

@@ -19,6 +19,7 @@
     expectationSuiteSchema,
 )
 from great_expectations.core.run_identifier import RunIdentifier
+from great_expectations.core.serdes import _EncodedValidationData, _IdentifierBundle
 from great_expectations.data_context.cloud_constants import GXCloudRESTResource
 from great_expectations.data_context.data_context.context_factory import project_manager
 from great_expectations.data_context.types.resource_identifiers import (
@@ -40,45 +41,6 @@
     from great_expectations.datasource.fluent.interfaces import DataAsset, Datasource
 
 
-class _IdentifierBundle(BaseModel):
-    name: str
-    id: Union[str, None]
-
-
-class _EncodedValidationData(BaseModel):
-    datasource: _IdentifierBundle
-    asset: _IdentifierBundle
-    batch_definition: _IdentifierBundle
-
-
-def _encode_suite(suite: ExpectationSuite) -> _IdentifierBundle:
-    if not suite.id:
-        expectation_store = project_manager.get_expectations_store()
-        key = expectation_store.get_key(name=suite.name, id=None)
-        expectation_store.add(key=key, value=suite)
-
-    return _IdentifierBundle(name=suite.name, id=suite.id)
-
-
-def _encode_data(data: BatchConfig) -> _EncodedValidationData:
-    asset = data.data_asset
-    ds = asset.datasource
-    return _EncodedValidationData(
-        datasource=_IdentifierBundle(
-            name=ds.name,
-            id=ds.id,
-        ),
-        asset=_IdentifierBundle(
-            name=asset.name,
-            id=str(asset.id) if asset.id else None,
-        ),
-        batch_definition=_IdentifierBundle(
-            name=data.name,
-            id=data.id,
-        ),
-    )
-
-
 class ValidationConfig(BaseModel):
     """
     Responsible for running a suite against data and returning a validation result.
@@ -125,8 +87,8 @@ class Config:
         }
         """
         json_encoders = {
-            ExpectationSuite: lambda e: _encode_suite(e),
-            BatchConfig: lambda b: _encode_data(b),
+            ExpectationSuite: lambda e: e.serialize(),
+            BatchConfig: lambda b: b.serialize(),
         }
 
     name: str = Field(..., allow_mutation=False)
@@ -302,3 +264,14 @@ def _get_expectation_suite_and_validation_result_ids(
                 run_id=run_id,
             )
             return expectation_suite_identifier, validation_result_id
+
+    def serialize(self) -> dict:
+        if not self.id:
+            validation_config_store = project_manager.get_validation_config_store()
+            key = validation_config_store.get_key(name=self.name, id=None)
+            validation_config_store.add(key=key, value=self)
+
+        self.data.serialize()
+        self.suite.serialize()
+
+        return _IdentifierBundle(name=self.name, id=self.id)