snowpark-checkpoints-validators 0.2.0rc1__py3-none-any.whl → 0.2.1__py3-none-any.whl

snowflake/snowpark_checkpoints/job_context.py

@@ -0,0 +1,128 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from datetime import datetime
+from typing import Optional
+
+import pandas as pd
+
+from pyspark.sql import SparkSession
+
+from snowflake.snowpark import Session
+from snowflake.snowpark_checkpoints.utils.constants import SCHEMA_EXECUTION_MODE
+
+
+LOGGER = logging.getLogger(__name__)
+RESULTS_TABLE = "SNOWPARK_CHECKPOINTS_REPORT"
+
+
+class SnowparkJobContext:
+
+    """Class used to record migration results in Snowflake.
+
+    Args:
+        snowpark_session: A Snowpark session instance.
+        spark_session: A Spark session instance.
+        job_name: The name of the job.
+        log_results: Whether to log the migration results in Snowflake.
+
+    """
+
+    def __init__(
+        self,
+        snowpark_session: Session,
+        spark_session: SparkSession = None,
+        job_name: Optional[str] = None,
+        log_results: Optional[bool] = True,
+    ):
+        self.log_results = log_results
+        self.job_name = job_name
+        self.spark_session = spark_session or self._create_pyspark_session()
+        self.snowpark_session = snowpark_session
+
+    def _mark_fail(
+        self, message, checkpoint_name, data, execution_mode=SCHEMA_EXECUTION_MODE
+    ):
+        if not self.log_results:
+            LOGGER.warning(
+                (
+                    "Recording of migration results into Snowflake is disabled. "
+                    "Failure result for checkpoint '%s' will not be recorded."
+                ),
+                checkpoint_name,
+            )
+            return
+
+        LOGGER.debug(
+            "Marking failure for checkpoint '%s' in '%s' mode with message '%s'",
+            checkpoint_name,
+            execution_mode,
+            message,
+        )
+
+        session = self.snowpark_session
+        df = pd.DataFrame(
+            {
+                "DATE": [datetime.now()],
+                "JOB": [self.job_name],
+                "STATUS": ["fail"],
+                "CHECKPOINT": [checkpoint_name],
+                "MESSAGE": [message],
+                "DATA": [f"{data}"],
+                "EXECUTION_MODE": [execution_mode],
+            }
+        )
+        report_df = session.createDataFrame(df)
+        LOGGER.info("Writing failure result to table: '%s'", RESULTS_TABLE)
+        report_df.write.mode("append").save_as_table(RESULTS_TABLE)
+
+    def _mark_pass(self, checkpoint_name, execution_mode=SCHEMA_EXECUTION_MODE):
+        if not self.log_results:
+            LOGGER.warning(
+                (
+                    "Recording of migration results into Snowflake is disabled. "
+                    "Pass result for checkpoint '%s' will not be recorded."
+                ),
+                checkpoint_name,
+            )
+            return
+
+        LOGGER.debug(
+            "Marking pass for checkpoint '%s' in '%s' mode",
+            checkpoint_name,
+            execution_mode,
+        )
+
+        session = self.snowpark_session
+        df = pd.DataFrame(
+            {
+                "DATE": [datetime.now()],
+                "JOB": [self.job_name],
+                "STATUS": ["pass"],
+                "CHECKPOINT": [checkpoint_name],
+                "MESSAGE": [""],
+                "DATA": [""],
+                "EXECUTION_MODE": [execution_mode],
+            }
+        )
+        report_df = session.createDataFrame(df)
+        LOGGER.info("Writing pass result to table: '%s'", RESULTS_TABLE)
+        report_df.write.mode("append").save_as_table(RESULTS_TABLE)
+
+    def _create_pyspark_session(self) -> SparkSession:
+        LOGGER.info("Creating a PySpark session")
+        return SparkSession.builder.getOrCreate()

snowflake/snowpark_checkpoints/singleton.py

@@ -0,0 +1,23 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]

snowflake/snowpark_checkpoints/snowpark_sampler.py

@@ -0,0 +1,124 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from typing import Optional
+
+import pandas
+
+from snowflake.snowpark import DataFrame as SnowparkDataFrame
+from snowflake.snowpark_checkpoints.job_context import SnowparkJobContext
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+class SamplingStrategy:
+    RANDOM_SAMPLE = 1
+    LIMIT = 2
+
+
+class SamplingError(Exception):
+    pass
+
+
+class SamplingAdapter:
+    def __init__(
+        self,
+        job_context: Optional[SnowparkJobContext],
+        sample_frac: Optional[float] = None,
+        sample_number: Optional[int] = None,
+        sampling_strategy: SamplingStrategy = SamplingStrategy.RANDOM_SAMPLE,
+    ):
+        self.pandas_sample_args = []
+        self.job_context = job_context
+        if sample_frac and not (0 <= sample_frac <= 1):
+            raise ValueError(
+                f"'sample_size' value {sample_frac} is out of range (0 <= sample_size <= 1)"
+            )
+
+        self.sample_frac = sample_frac
+        self.sample_number = sample_number
+        self.sampling_strategy = sampling_strategy
+
+    def process_args(self, input_args):
+        # create the intermediate pandas
+        # data frame for the test data
+        LOGGER.info("Processing %s input argument(s) for sampling", len(input_args))
+        for arg in input_args:
+            if isinstance(arg, SnowparkDataFrame):
+                df_count = arg.count()
+                if df_count == 0:
+                    raise SamplingError(
+                        "Input DataFrame is empty. Cannot sample from an empty DataFrame."
+                    )
+
+                LOGGER.info("Sampling a Snowpark DataFrame with %s rows", df_count)
+                if self.sampling_strategy == SamplingStrategy.RANDOM_SAMPLE:
+                    if self.sample_frac:
+                        LOGGER.info(
+                            "Applying random sampling with fraction %s",
+                            self.sample_frac,
+                        )
+                        df_sample = arg.sample(frac=self.sample_frac).to_pandas()
+                    else:
+                        LOGGER.info(
+                            "Applying random sampling with size %s", self.sample_number
+                        )
+                        df_sample = arg.sample(n=self.sample_number).to_pandas()
+                else:
+                    LOGGER.info(
+                        "Applying limit sampling with size %s", self.sample_number
+                    )
+                    df_sample = arg.limit(self.sample_number).to_pandas()
+
+                LOGGER.info(
+                    "Successfully sampled the DataFrame. Resulting DataFrame shape: %s",
+                    df_sample.shape,
+                )
+                self.pandas_sample_args.append(df_sample)
+            else:
+                LOGGER.debug(
+                    "Argument is not a Snowpark DataFrame. No sampling is applied."
+                )
+                self.pandas_sample_args.append(arg)
+
+    def get_sampled_pandas_args(self):
+        return self.pandas_sample_args
+
+    def get_sampled_snowpark_args(self):
+        if self.job_context is None:
+            raise SamplingError("Need a job context to compare with Spark")
+        snowpark_sample_args = []
+        for arg in self.pandas_sample_args:
+            if isinstance(arg, pandas.DataFrame):
+                snowpark_df = self.job_context.snowpark_session.create_dataframe(arg)
+                snowpark_sample_args.append(snowpark_df)
+            else:
+                snowpark_sample_args.append(arg)
+        return snowpark_sample_args
+
+    def get_sampled_spark_args(self):
+        if self.job_context is None:
+            raise SamplingError("Need a job context to compare with Spark")
+        pyspark_sample_args = []
+        for arg in self.pandas_sample_args:
+            if isinstance(arg, pandas.DataFrame):
+                pyspark_df = self.job_context.spark_session.createDataFrame(arg)
+                pyspark_sample_args.append(pyspark_df)
+            else:
+                pyspark_sample_args.append(arg)
+        return pyspark_sample_args

snowflake/snowpark_checkpoints/spark_migration.py

@@ -0,0 +1,255 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from typing import Callable, Optional, TypeVar
+
+import pandas as pd
+
+from pyspark.sql import DataFrame as SparkDataFrame
+
+from snowflake.snowpark import DataFrame as SnowparkDataFrame
+from snowflake.snowpark.types import PandasDataFrame
+from snowflake.snowpark_checkpoints.errors import SparkMigrationError
+from snowflake.snowpark_checkpoints.job_context import SnowparkJobContext
+from snowflake.snowpark_checkpoints.snowpark_sampler import (
+    SamplingAdapter,
+    SamplingStrategy,
+)
+from snowflake.snowpark_checkpoints.utils.constants import FAIL_STATUS, PASS_STATUS
+from snowflake.snowpark_checkpoints.utils.logging_utils import log
+from snowflake.snowpark_checkpoints.utils.telemetry import STATUS_KEY, report_telemetry
+from snowflake.snowpark_checkpoints.utils.utils_checks import (
+    _replace_special_characters,
+    _update_validation_result,
+)
+
+
+fn = TypeVar("F", bound=Callable)
+LOGGER = logging.getLogger(__name__)
+
+
+@log
+def check_with_spark(
+    job_context: Optional[SnowparkJobContext],
+    spark_function: fn,
+    checkpoint_name: str,
+    sample_number: Optional[int] = 100,
+    sampling_strategy: Optional[SamplingStrategy] = SamplingStrategy.RANDOM_SAMPLE,
+    output_path: Optional[str] = None,
+) -> Callable[[fn], fn]:
+    """Validate function output with Spark instance.
+
+    Will take the input snowpark dataframe of this function, sample data, convert
+    it to a Spark dataframe and then execute `spark_function`. Subsequently
+    the output of that function will be compared to the output of this function
+    for the same sample of data.
+
+    Args:
+        job_context (SnowparkJobContext): The job context containing configuration and details for the validation.
+        spark_function (fn): The equivalent PySpark function to compare against the Snowpark implementation.
+        checkpoint_name (str): A name for the checkpoint. Defaults to None.
+        sample_number (Optional[int], optional): The number of rows for validation. Defaults to 100.
+        sampling_strategy (Optional[SamplingStrategy], optional): The strategy used for sampling data.
+            Defaults to SamplingStrategy.RANDOM_SAMPLE.
+        output_path (Optional[str], optional): The path to store the validation results. Defaults to None.
+
+    Returns:
+        Callable[[fn], fn]: A decorator that wraps the original Snowpark function with validation logic.
+
+    """
+
+    def check_with_spark_decorator(snowpark_fn):
+        @log(log_args=False)
+        def wrapper(*args, **kwargs):
+            LOGGER.info(
+                "Starting output validation between Snowpark function '%s' and Spark function '%s'",
+                snowpark_fn.__name__,
+                spark_function.__name__,
+            )
+            _checkpoint_name = checkpoint_name
+            if checkpoint_name is None:
+                LOGGER.warning(
+                    "No checkpoint name provided. Using '%s' as the checkpoint name",
+                    snowpark_fn.__name__,
+                )
+                _checkpoint_name = snowpark_fn.__name__
+            _checkpoint_name = _replace_special_characters(_checkpoint_name)
+
+            sampler = SamplingAdapter(
+                job_context,
+                sample_number=sample_number,
+                sampling_strategy=sampling_strategy,
+            )
+            sampler.process_args(args)
+            snowpark_sample_args = sampler.get_sampled_snowpark_args()
+            pyspark_sample_args = sampler.get_sampled_spark_args()
+
+            # Run the sampled data in snowpark
+            LOGGER.info("Running the Snowpark function with sampled args")
+            snowpark_test_results = snowpark_fn(*snowpark_sample_args, **kwargs)
+            LOGGER.info("Running the Spark function with sampled args")
+            spark_test_results = spark_function(*pyspark_sample_args, **kwargs)
+
+            LOGGER.info("Comparing the results of the Snowpark and Spark functions")
+            result, exception = _assert_return(
+                snowpark_test_results,
+                spark_test_results,
+                job_context,
+                _checkpoint_name,
+                output_path,
+            )
+            if not result:
+                LOGGER.error(
+                    "Validation failed. The results of the Snowpark function '%s' and Spark function '%s' do not match",
+                    snowpark_fn.__name__,
+                    spark_function.__name__,
+                )
+                raise exception from None
+            LOGGER.info(
+                "Validation passed. The results of the Snowpark function '%s' and Spark function '%s' match",
+                snowpark_fn.__name__,
+                spark_function.__name__,
+            )
+
+            # Run the original function in snowpark
+            return snowpark_fn(*args, **kwargs)
+
+        return wrapper
+
+    return check_with_spark_decorator
+
+
+@report_telemetry(
+    params_list=["snowpark_results", "spark_results"],
+    return_indexes=[(STATUS_KEY, 0)],
+    multiple_return=True,
+)
+def _assert_return(
+    snowpark_results, spark_results, job_context, checkpoint_name, output_path=None
+) -> tuple[bool, Optional[Exception]]:
+    """Assert and validate the results from Snowpark and Spark transformations.
+
+    Args:
+        snowpark_results (Any): Results from the Snowpark transformation.
+        spark_results (Any): Results from the Spark transformation to compare against.
+        job_context (Any): Additional context about the job. Defaults to None.
+        checkpoint_name (Any): Name of the checkpoint for logging. Defaults to None.
+        output_path (Optional[str], optional): The path to store the validation results. Defaults to None.
+
+    Raises:
+        AssertionError: If the Snowpark and Spark results do not match.
+        TypeError: If the results cannot be compared.
+
+    """
+    if isinstance(snowpark_results, SnowparkDataFrame) and isinstance(
+        spark_results, SparkDataFrame
+    ):
+        LOGGER.debug("Comparing two DataFrame results for equality")
+        cmp = compare_spark_snowpark_dfs(spark_results, snowpark_results)
+
+        if not cmp.empty:
+            exception_result = SparkMigrationError(
+                "DataFrame difference:\n", job_context, checkpoint_name, cmp
+            )
+            return False, exception_result
+        job_context._mark_pass(checkpoint_name)
+        _update_validation_result(checkpoint_name, PASS_STATUS, output_path)
+        return True, None
+    else:
+        LOGGER.debug("Comparing two scalar results for equality")
+        if snowpark_results != spark_results:
+            exception_result = SparkMigrationError(
+                "Return value difference:\n",
+                job_context,
+                checkpoint_name,
+                f"{snowpark_results} != {spark_results}",
+            )
+            _update_validation_result(checkpoint_name, FAIL_STATUS, output_path)
+            return False, exception_result
+        job_context._mark_pass(checkpoint_name)
+        _update_validation_result(checkpoint_name, PASS_STATUS, output_path)
+        return True, None
+
+
+def compare_spark_snowpark_dfs(
+    spark_df: SparkDataFrame, snowpark_df: SnowparkDataFrame
+) -> PandasDataFrame:
+    """Compare two dataframes for equality.
+
+    Args:
+        spark_df (SparkDataFrame): The Spark dataframe to compare.
+        snowpark_df (SnowparkDataFrame): The Snowpark dataframe to compare.
+
+    Returns:Pandas DataFrame containing the differences between the two dataframes.
+
+    """
+    snowpark_df = snowpark_df.to_pandas()
+    snowpark_df.columns = snowpark_df.columns.str.upper()
+    spark_df = spark_df.toPandas()
+    spark_df.columns = spark_df.columns.str.upper()
+    spark_cols = set(spark_df.columns)
+    snowpark_cols = set(snowpark_df.columns)
+    cmp = pd.DataFrame([])
+    left = spark_cols - snowpark_cols
+    right = snowpark_cols - spark_cols
+    if left != set():
+        cmp = _compare_dfs(spark_df, snowpark_df, "spark", "snowpark")
+    if right != set():
+        right_cmp = _compare_dfs(snowpark_df, spark_df, "snowpark", "spark")
+        cmp = right_cmp if cmp.empty else pd.concat([cmp, right_cmp], ignore_index=True)
+    if left == set() and right == set():
+        if spark_df.shape == snowpark_df.shape:
+            cmp = spark_df.compare(snowpark_df, result_names=("spark", "snowpark"))
+        else:
+            cmp = spark_df.merge(snowpark_df, indicator=True, how="outer").loc[
+                lambda x: x["_merge"] != "both"
+            ]
+            cmp = cmp.replace(
+                {"left_only": "spark_only", "right_only": "snowpark_only"}
+            )
+
+    return cmp
+
+
+def _compare_dfs(
+    df_a: pd.DataFrame, df_b: pd.DataFrame, left_label: str, right_label: str
+) -> PandasDataFrame:
+    """Compare two dataframes for equality.
+
+    Args:
+        df_a (PandasDataFrame): The first dataframe to compare.
+        df_b (PandasDataFrame): The second dataframe to compare.
+        left_label (str): The label for the first dataframe.
+        right_label (str): The label for the second dataframe.
+
+    :return: Pandas DataFrame containing the differences between the two dataframes.
+
+    """
+    df_a["side"] = "a"
+    df_b["side"] = "b"
+    a_only = [col for col in df_a.columns if col not in df_b.columns] + ["side"]
+    b_only = [col for col in df_b.columns if col not in df_a.columns] + ["side"]
+    cmp = (
+        df_a[a_only]
+        .merge(df_b[b_only], indicator=True, how="left")
+        .loc[lambda x: x["_merge"] != "both"]
+    )
+    cmp = cmp.replace(
+        {"left_only": f"{left_label}_only", "right_only": f"{right_label}_only"}
+    )
+    cmp = cmp.drop(columns="side")
+    return cmp

snowflake/snowpark_checkpoints/utils/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

snowflake/snowpark_checkpoints/utils/constants.py

@@ -0,0 +1,134 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Skip type
+from enum import IntEnum
+from typing import Final
+
+
+class CheckpointMode(IntEnum):
+
+    """Enum class representing the validation mode."""
+
+    SCHEMA = 1
+    """Validate against a schema file"""
+    DATAFRAME = 2
+    """Validate against a dataframe"""
+
+
+# Execution mode
+SCHEMA_EXECUTION_MODE: Final[str] = "Schema"
+DATAFRAME_EXECUTION_MODE: Final[str] = "Dataframe"
+
+
+# File position on stack
+STACK_POSITION_CHECKPOINT: Final[int] = 6
+
+# Validation status
+PASS_STATUS: Final[str] = "PASS"
+FAIL_STATUS: Final[str] = "FAIL"
+
+# Validation result keys
+DEFAULT_KEY: Final[str] = "default"
+
+
+# Skip type
+SKIP_ALL: Final[str] = "skip_all"
+
+# Supported types
+BOOLEAN_TYPE: Final[str] = "boolean"
+BINARY_TYPE: Final[str] = "binary"
+BYTE_TYPE: Final[str] = "byte"
+CHAR_TYPE: Final[str] = "char"
+DATE_TYPE: Final[str] = "date"
+DAYTIMEINTERVAL_TYPE: Final[str] = "daytimeinterval"
+DECIMAL_TYPE: Final[str] = "decimal"
+DOUBLE_TYPE: Final[str] = "double"
+FLOAT_TYPE: Final[str] = "float"
+INTEGER_TYPE: Final[str] = "integer"
+LONG_TYPE: Final[str] = "long"
+SHORT_TYPE: Final[str] = "short"
+STRING_TYPE: Final[str] = "string"
+TIMESTAMP_TYPE: Final[str] = "timestamp"
+TIMESTAMP_NTZ_TYPE: Final[str] = "timestamp_ntz"
+VARCHAR_TYPE: Final[str] = "varchar"
+
+# Pandas data types
+PANDAS_BOOLEAN_DTYPE: Final[str] = "bool"
+PANDAS_DATETIME_DTYPE: Final[str] = "datetime64[ns]"
+PANDAS_FLOAT_DTYPE: Final[str] = "float64"
+PANDAS_INTEGER_DTYPE: Final[str] = "int64"
+PANDAS_OBJECT_DTYPE: Final[str] = "object"
+PANDAS_TIMEDELTA_DTYPE: Final[str] = "timedelta64[ns]"
+
+# Schemas keys
+COLUMNS_KEY: Final[str] = "columns"
+COUNT_KEY: Final[str] = "rows_count"
+DECIMAL_PRECISION_KEY: Final[str] = "decimal_precision"
+FALSE_COUNT_KEY: Final[str] = "false_count"
+FORMAT_KEY: Final[str] = "format"
+NAME_KEY: Final[str] = "name"
+MARGIN_ERROR_KEY: Final[str] = "margin_error"
+MAX_KEY: Final[str] = "max"
+MEAN_KEY: Final[str] = "mean"
+MIN_KEY: Final[str] = "min"
+NULL_COUNT_KEY: Final[str] = "rows_null_count"
+NULLABLE_KEY: Final[str] = "nullable"
+ROWS_NOT_NULL_COUNT_KEY: Final[str] = "rows_not_null_count"
+TRUE_COUNT_KEY: Final[str] = "true_count"
+TYPE_KEY: Final[str] = "type"
+ROWS_COUNT_KEY: Final[str] = "rows_count"
+FORMAT_KEY: Final[str] = "format"
+
+DATAFRAME_CUSTOM_DATA_KEY: Final[str] = "custom_data"
+DATAFRAME_PANDERA_SCHEMA_KEY: Final[str] = "pandera_schema"
+
+# Default values
+DEFAULT_DATE_FORMAT: Final[str] = "%Y-%m-%d"
+
+# SQL Column names
+TABLE_NAME_COL: Final[str] = "TABLE_NAME"
+CREATED_COL: Final[str] = "CREATED"
+
+# SQL Table names
+INFORMATION_SCHEMA_TABLE_NAME: Final[str] = "INFORMATION_SCHEMA"
+TABLES_TABLE_NAME: Final[str] = "TABLES"
+
+# SQL Query
+EXCEPT_HASH_AGG_QUERY: Final[
+    str
+] = "SELECT HASH_AGG(*) FROM IDENTIFIER(:1) EXCEPT SELECT HASH_AGG(*) FROM IDENTIFIER(:2)"
+
+# Table checkpoints name
+CHECKPOINT_TABLE_NAME_FORMAT: Final[str] = "{}_snowpark"
+
+# Write mode
+OVERWRITE_MODE: Final[str] = "overwrite"
+
+# Validation modes
+VALIDATION_MODE_KEY: Final[str] = "validation_mode"
+PIPELINES_KEY: Final[str] = "pipelines"
+
+# File name
+CHECKPOINT_JSON_OUTPUT_FILE_FORMAT_NAME: Final[str] = "{}.json"
+CHECKPOINTS_JSON_FILE_NAME: Final[str] = "checkpoints.json"
+SNOWPARK_CHECKPOINTS_OUTPUT_DIRECTORY_NAME: Final[str] = "snowpark-checkpoints-output"
+CHECKPOINT_PARQUET_OUTPUT_FILE_FORMAT_NAME: Final[str] = "{}.parquet"
+VALIDATION_RESULTS_JSON_FILE_NAME: Final[str] = "checkpoint_validation_results.json"
+
+# Environment variables
+SNOWFLAKE_CHECKPOINT_CONTRACT_FILE_PATH_ENV_VAR: Final[
+    str
+] = "SNOWFLAKE_CHECKPOINT_CONTRACT_FILE_PATH"