[FEATURE] ValidationConfigStore

great_expectations/core/factory/validation_factory.py

@@ -1,15 +1,21 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from great_expectations._docs_decorators import public_api
 from great_expectations.compatibility.typing_extensions import override
 from great_expectations.core.factory.factory import Factory
 from great_expectations.core.validation_config import ValidationConfig
 
+if TYPE_CHECKING:
+    from great_expectations.data_context.store.validation_config_store import (
+        ValidationConfigStore,
+    )
+
 
 # TODO: Add analytics as needed
 class ValidationFactory(Factory[ValidationConfig]):
-    def __init__(self, store) -> None:
-        # TODO: Update type hints when new ValidationConfigStore is implemented
+    def __init__(self, store: ValidationConfigStore) -> None:
         self._store = store
 
     @public_api

great_expectations/core/validation_config.py

@@ -1,15 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from great_expectations._docs_decorators import public_api
-from great_expectations.compatibility.pydantic import BaseModel
-
-if TYPE_CHECKING:
-    from great_expectations.core.batch_config import BatchConfig
-    from great_expectations.core.expectation_suite import ExpectationSuite
-
-    # from great_expectations.datasource.fluent.interfaces import DataAsset
+from great_expectations.compatibility.pydantic import BaseModel, validator
+from great_expectations.core.batch_config import BatchConfig  # noqa: TCH001
+from great_expectations.core.expectation_suite import (
+    ExpectationSuite,
+    expectationSuiteSchema,
+)
 
 
 class ValidationConfig(BaseModel):
@@ -23,10 +20,25 @@ class ValidationConfig(BaseModel):
 
     """
 
+    class Config:
+        arbitrary_types_allowed = True
+        json_encoders = {
+            ExpectationSuite: lambda v: expectationSuiteSchema.dump(v),
+        }
+
     name: str
     data: BatchConfig  # TODO: Should support a union of Asset | BatchConfig
     suite: ExpectationSuite
 
+    @validator("suite", pre=True)
+    def _validate_suite(cls, v):
+        if isinstance(v, dict):
+            return ExpectationSuite(**expectationSuiteSchema.load(v))
+        return v
+
     @public_api
     def run(self):
         raise NotImplementedError
+
+
+ValidationConfig.update_forward_refs()

great_expectations/data_context/cloud_constants.py

@@ -31,3 +31,4 @@ class GXCloudRESTResource(str, Enum):
     PROFILER = "profiler"
     RENDERED_DATA_DOC = "rendered_data_doc"
     VALIDATION_RESULT = "validation_result"
+    VALIDATION_CONFIG = "validation_config"

great_expectations/data_context/data_context/abstract_data_context.py

@@ -148,6 +148,9 @@
         DataDocsSiteConfigTypedDict,
         StoreConfigTypedDict,
     )
+    from great_expectations.data_context.store.validation_config_store import (
+        ValidationConfigStore,
+    )
     from great_expectations.data_context.store.validations_store import ValidationsStore
     from great_expectations.data_context.types.resource_identifiers import (
         GXCloudIdentifier,
@@ -331,8 +334,13 @@ def _init_factories(self) -> None:
                 context=self,
             )
 
-        # TODO: Update to follow existing pattern once new ValidationConfigStore is implemented
         self._validations: ValidationFactory | None = None
+        if validation_config_store := self.stores.get(
+            self.validation_config_store_name
+        ):
+            self._validations = ValidationFactory(
+                store=validation_config_store,
+            )
 
     def _init_analytics(self) -> None:
         init_analytics(
@@ -617,6 +625,13 @@ def validations_store_name(self, value: str) -> None:
     def validations_store(self) -> ValidationsStore:
         return self.stores[self.validations_store_name]
 
+    @property
+    def validation_config_store_name(self) -> str:
+        return DataContextConfigDefaults.DEFAULT_VALIDATION_CONFIG_STORE_NAME.value
+
+    def validaiton_config_store(self) -> ValidationConfigStore:
+        return self.stores[self.validation_config_store_name]
+
     @property
     def checkpoint_store_name(self) -> Optional[str]:
         from great_expectations.data_context.store.checkpoint_store import (

great_expectations/data_context/data_context/serializable_data_context.py

@@ -48,6 +48,7 @@ class SerializableDataContext(AbstractDataContext):
         DataContextConfigDefaults.EXPECTATIONS_BASE_DIRECTORY.value,
         DataContextConfigDefaults.PLUGINS_BASE_DIRECTORY.value,
         DataContextConfigDefaults.PROFILERS_BASE_DIRECTORY.value,
+        DataContextConfigDefaults.VALIDATION_CONFIGS_BASE_DIRECTORY.value,
         GX_UNCOMMITTED_DIR,
     ]
     GX_DIR: ClassVar[str] = "gx"

great_expectations/data_context/store/__init__.py

@@ -30,3 +30,4 @@
 from .profiler_store import ProfilerStore  # isort:skip
 from .data_context_store import DataContextStore  # isort:skip
 from .data_asset_store import DataAssetStore  # isort:skip
+from .validation_config_store import ValidationConfigStore  # isort:skip

great_expectations/data_context/store/gx_cloud_store_backend.py

@@ -133,6 +133,7 @@ class GXCloudStoreBackend(StoreBackend, metaclass=ABCMeta):
         GXCloudRESTResource.PROFILER: "profiler",
         GXCloudRESTResource.RENDERED_DATA_DOC: "rendered_data_doc",
         GXCloudRESTResource.VALIDATION_RESULT: "result",
+        GXCloudRESTResource.VALIDATION_CONFIG: "validation_config",
     }
 
     ALLOWED_SET_KWARGS_BY_RESOURCE_TYPE: Dict[GXCloudRESTResource, Set[str]] = {
@@ -157,6 +158,7 @@ class GXCloudStoreBackend(StoreBackend, metaclass=ABCMeta):
             GXCloudRESTResource.PROFILER: "profilers",
             GXCloudRESTResource.RENDERED_DATA_DOC: "rendered_data_docs",
             GXCloudRESTResource.VALIDATION_RESULT: "validation_results",
+            GXCloudRESTResource.VALIDATION_CONFIG: "validation_configs",
         }
     )
 
@@ -295,6 +297,8 @@ def _put(self, id: str, value: Any) -> GXCloudResourceRef | bool:
         # resource for others. Since we route all update calls through this single
         # method, we need to handle both cases.
 
+        print("CHETAN", value, type(value.get("suite")))
+
         resource_type = self.ge_cloud_resource_type
         organization_id = self.ge_cloud_credentials["organization_id"]
         attributes_key = self.PAYLOAD_ATTRIBUTES_KEYS[resource_type]

great_expectations/data_context/store/validation_config_store.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from great_expectations.compatibility.typing_extensions import override
+from great_expectations.core.data_context_key import StringKey
+from great_expectations.core.validation_config import ValidationConfig
+from great_expectations.data_context.cloud_constants import GXCloudRESTResource
+from great_expectations.data_context.store.store import Store
+from great_expectations.data_context.types.resource_identifiers import (
+    GXCloudIdentifier,
+)
+
+
+class ValidationConfigStore(Store):
+    _key_class = StringKey
+
+    def __init__(
+        self,
+        store_name: str,
+        store_backend: dict | None = None,
+        runtime_environment: dict | None = None,
+    ) -> None:
+        super().__init__(
+            store_name=store_name,
+            store_backend=store_backend,
+            runtime_environment=runtime_environment,
+        )
+
+    def get_key(
+        self, name: str, id: str | None = None
+    ) -> GXCloudIdentifier | StringKey:
+        """Given a name and optional ID, build the correct key for use in the ValidationConfigStore."""
+        if self.cloud_mode:
+            return GXCloudIdentifier(
+                resource_type=GXCloudRESTResource.VALIDATION_CONFIG,
+                id=id,
+                resource_name=name,
+            )
+        return StringKey(key=name)
+
+    @override
+    def serialize(self, value):
+        if self.cloud_mode:
+            data = value.dict()
+            data["suite"] = data["suite"].to_json_dict()
+            return data
+
+        return value.json()
+
+    @override
+    def deserialize(self, value):
+        return ValidationConfig.parse_raw(value)

great_expectations/data_context/types/base.py

@@ -1624,6 +1624,12 @@ class DataContextConfigDefaults(enum.Enum):
     DEFAULT_VALIDATIONS_STORE_BASE_DIRECTORY_RELATIVE_NAME = (
         f"{UNCOMMITTED}/{VALIDATIONS_BASE_DIRECTORY}/"
     )
+    DEFAULT_VALIDATION_CONFIG_STORE_NAME = "validation_config_store"
+    VALIDATION_CONFIGS_BASE_DIRECTORY = "validation_configs"
+    DEFAULT_VALIDATION_CONFIG_STORE_BASE_DIRECTORY_RELATIVE_NAME = (
+        f"{VALIDATION_CONFIGS_BASE_DIRECTORY}/"
+    )
+
     DEFAULT_EVALUATION_PARAMETER_STORE_NAME = "evaluation_parameter_store"
     DEFAULT_EVALUATION_PARAMETER_STORE_BASE_DIRECTORY_RELATIVE_NAME = (
         "evaluation_parameters/"
@@ -1690,6 +1696,13 @@ class DataContextConfigDefaults(enum.Enum):
                 "base_directory": DEFAULT_VALIDATIONS_STORE_BASE_DIRECTORY_RELATIVE_NAME,
             },
         },
+        DEFAULT_VALIDATION_CONFIG_STORE_NAME: {
+            "class_name": "ValidationConfigStore",
+            "store_backend": {
+                "class_name": "TupleFilesystemStoreBackend",
+                "base_directory": DEFAULT_VALIDATION_CONFIG_STORE_BASE_DIRECTORY_RELATIVE_NAME,
+            },
+        },
         DEFAULT_EVALUATION_PARAMETER_STORE_NAME: {
             "class_name": "EvaluationParameterStore"
         },

tests/data_context/migrator/test_file_migrator.py

@@ -64,6 +64,7 @@ def test_migrate_scaffolds_filesystem(
         DataContextConfigDefaults.PLUGINS_BASE_DIRECTORY.value,
         DataContextConfigDefaults.PROFILERS_BASE_DIRECTORY.value,
         DataContextConfigDefaults.UNCOMMITTED.value,
+        DataContextConfigDefaults.VALIDATION_CONFIGS_BASE_DIRECTORY.value,
     ]
 
 

tests/data_context/store/test_validation_config_store.py

@@ -0,0 +1,128 @@
+from unittest import mock
+
+import pytest
+
+from great_expectations.core.batch_config import BatchConfig
+from great_expectations.core.data_context_key import StringKey
+from great_expectations.core.expectation_suite import ExpectationSuite
+from great_expectations.core.validation_config import ValidationConfig
+from great_expectations.data_context.cloud_constants import GXCloudRESTResource
+from great_expectations.data_context.store import ValidationConfigStore
+from great_expectations.data_context.types.resource_identifiers import GXCloudIdentifier
+from tests.datasource.fluent._fake_cloud_api import CloudDetails
+
+
+@pytest.fixture
+def ephemeral_store():
+    return ValidationConfigStore(store_name="ephemeral_validation_config_store")
+
+
+@pytest.fixture
+def file_backed_store(tmp_path):
+    base_directory = tmp_path / "base_dir"
+    return ValidationConfigStore(
+        store_name="file_backed_validation_config_store",
+        store_backend={
+            "class_name": "TupleFilesystemStoreBackend",
+            "base_directory": base_directory,
+        },
+    )
+
+
+@pytest.fixture
+def cloud_backed_store(cloud_details: CloudDetails):
+    return ValidationConfigStore(
+        store_name="cloud_backed_validation_config_store",
+        store_backend={
+            "class_name": "GXCloudStoreBackend",
+            "ge_cloud_resource_type": GXCloudRESTResource.VALIDATION_CONFIG,
+            "ge_cloud_credentials": {
+                "access_token": cloud_details.access_token,
+                "organization_id": cloud_details.org_id,
+            },
+        },
+    )
+
+
+@pytest.fixture
+def validation_config() -> ValidationConfig:
+    return ValidationConfig(
+        name="my_validation",
+        data=BatchConfig(name="my_batch_config"),
+        suite=ExpectationSuite(name="my_suite"),
+    )
+
+
+@pytest.mark.parametrize("store_fixture", ["ephemeral_store", "file_backed_store"])
+@pytest.mark.unit
+def test_add(request, store_fixture: str, validation_config: ValidationConfig):
+    store: ValidationConfigStore = request.getfixturevalue(store_fixture)
+
+    key = StringKey(key="my_validation")
+    store.add(key=key, value=validation_config)
+
+    assert store.get(key) == validation_config
+
+
+@pytest.mark.cloud
+def test_add_cloud(
+    cloud_backed_store: ValidationConfigStore, validation_config: ValidationConfig
+):
+    store = cloud_backed_store
+
+    id = "5a8ada9f-5b71-461b-b1af-f1d93602a156"
+    name = "my_validation"
+    key = GXCloudIdentifier(
+        resource_type=GXCloudRESTResource.VALIDATION_CONFIG,
+        id=id,
+        resource_name=name,
+    )
+
+    with mock.patch("requests.Session.put", autospec=True) as mock_put:
+        store.add(key=key, value=validation_config)
+
+    mock_put.assert_called_once_with(
+        mock.ANY,
+        f"https://api.greatexpectations.io/organizations/12345678-1234-5678-1234-567812345678/validation-configs/{id}",
+        json={
+            "data": {
+                "type": "validation_config",
+                "id": id,
+                "attributes": {
+                    "organization_id": "12345678-1234-5678-1234-567812345678",
+                    "validation_config": {
+                        "name": name,
+                        "data": {
+                            "id": None,
+                            "name": "my_batch_config",
+                            "partitioner": None,
+                        },
+                        "suite": {
+                            "expectation_suite_name": "my_suite",
+                            "id": None,
+                            "expectations": [],
+                            "data_asset_type": None,
+                            "meta": mock.ANY,
+                            "notes": None,
+                        },
+                    },
+                },
+            }
+        },
+    )
+
+
+@pytest.mark.parametrize("store_fixture", ["ephemeral_store", "file_backed_store"])
+@pytest.mark.unit
+def test_get_key(request, store_fixture: str):
+    store: ValidationConfigStore = request.getfixturevalue(store_fixture)
+
+    name = "my_validation"
+    assert store.get_key(name=name) == StringKey(key=name)
+
+
+@pytest.mark.cloud
+def test_get_key_cloud(cloud_backed_store: ValidationConfigStore):
+    key = cloud_backed_store.get_key(name="my_validation")
+    assert key.resource_type == GXCloudRESTResource.VALIDATION_CONFIG
+    assert key.resource_name == "my_validation"

tests/data_context/test_data_context.py

@@ -782,6 +782,7 @@ def test_data_context_create_makes_uncommitted_dirs_when_all_are_missing(
         data_docs/
         validations/
             .ge_store_backend_id
+    validation_configs/
 """
     )
 
@@ -809,6 +810,7 @@ def test_data_context_create_does_nothing_if_all_uncommitted_dirs_exist(
         data_docs/
         validations/
             .ge_store_backend_id
+    validation_configs/
 """
     project_path = str(tmp_path_factory.mktemp("stuff"))
     ge_dir = os.path.join(project_path, FileDataContext.GX_DIR)  # noqa: PTH118
@@ -910,6 +912,7 @@ def test_scaffold_directories(tmp_path_factory):
         "expectations",
         ".gitignore",
         "uncommitted",
+        "validation_configs",
     }
     assert set(
         os.listdir(os.path.join(empty_directory, "uncommitted"))  # noqa: PTH118