spark-data-quality 1.0.0__tar.gz

spark_data_quality-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

spark_data_quality-1.0.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: spark-data-quality
+Version: 1.0.0
+Summary: SparkDQAgent — Data Quality validation package for K8s Spark pods
+Author-email: khailas <khailas.rangath@saal.ai>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: great-expectations==0.18.12
+Requires-Dist: trino>=0.320.0
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: spark
+Requires-Dist: pyspark>=3.1.1; extra == "spark"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# spark-dq
+
+Data Quality validation library for K8s Spark pods. Runs Great Expectations + Trino hybrid checks and persists results to the DQ Engine API.
+
+## Installation
+
+```bash
+pip install .            # core (GE + Trino)
+pip install ".[spark]"   # includes PySpark
+pip install -e ".[dev]"  # editable + dev tools
+```
+
+## Package structure
+
+```
+src/spark_dq/
+├── quality.py              # SparkDQAgent — main orchestrator
+├── utils.py                # JSON serialisation helpers
+├── helpers/
+│   ├── api_client.py       # DQ Engine HTTP client (GET /config, POST /save-results)
+│   ├── expectations.py     # Expectation splitting (fast/slow) and result builders
+│   ├── trino_executor.py   # Trino fast-path — batched SQL for 5 assertion types
+│   ├── ge_executor.py      # GE slow-path — parallel in-memory validators
+│   ├── sql_utils.py        # SQL injection prevention utilities
+│   └── exceptions.py       # DQEngineAPIError
+└── data_quality_helper/
+    ├── const.py             # GE datasource config templates
+    ├── datacontext.py       # In-memory GE DataContext builder
+    ├── batch_request.py     # RuntimeBatchRequest factory
+    ├── expectation_suite.py # Suite builder from assertion dicts
+    ├── ge_utils.py          # Mapping ID resolution
+    └── checkpoint_conf.py   # Checkpoint runner (legacy)
+```
+
+## Usage
+
+### Single table
+
+```python
+from spark_dq.quality import SparkDQAgent
+
+agent = SparkDQAgent(
+    catalog="my_catalog",
+    schema="public",
+    table="sales_data",
+    data_quality_url="http://dq-engine:8000/api/v1/spark",
+    catalog_type="unmanaged",
+    table_id=13,
+    test_suite_id=37,
+    trino_host="trino-host:443",
+    trino_user="user",
+    trino_pwd="pwd",
+)
+
+cfg = agent.get_config()        # single GET /config call
+results = agent.validate(df)    # hybrid Trino + GE execution
+```
+
+### Suite run (auto-discover tables)
+
+```python
+agent = SparkDQAgent(
+    catalog="", schema="", table="",
+    data_quality_url="http://dq-engine:8000/api/v1/spark",
+    catalog_type="unmanaged",
+    test_suite_id=37,
+)
+table_configs = agent.get_all_table_configs()  # returns list of per-table configs
+```
+
+## Demo
+
+```bash
+# Single table
+python demo.py \
+  --catalog khtestpostgresss --schema public --table sales_data_new \
+  --dq_url http://localhost:8000/api/v1/spark \
+  --trino_host trino-dev.digixt.ae:443 --trino_user datalake --trino_pwd <pwd> \
+  --table_id 13 --test_suite_id 37
+
+# Suite run (auto-discovers tables)
+python demo.py \
+  --test_suite_id 37 \
+  --dq_url http://localhost:8000/api/v1/spark \
+  --trino_host trino-dev.digixt.ae:443 --trino_user datalake --trino_pwd <pwd>
+```
+
+## Hybrid execution
+
+When Trino credentials are provided, the agent splits expectations into two paths:
+
+| Path | Assertion types | How |
+|------|----------------|-----|
+| **Trino fast-path** | `not_be_null`, `be_unique`, `be_between`, `match_regex`, `row_count_to_be_between` | Single batched SQL query |
+| **GE slow-path** | All others | Parallel in-memory GE validators |
+
+Both paths run **concurrently**. Results are merged and saved via `POST /save-results`.
+
+## License
+
+MIT

spark_data_quality-1.0.0/README.md

@@ -0,0 +1,101 @@
+# spark-dq
+
+Data Quality validation library for K8s Spark pods. Runs Great Expectations + Trino hybrid checks and persists results to the DQ Engine API.
+
+## Installation
+
+```bash
+pip install .            # core (GE + Trino)
+pip install ".[spark]"   # includes PySpark
+pip install -e ".[dev]"  # editable + dev tools
+```
+
+## Package structure
+
+```
+src/spark_dq/
+├── quality.py              # SparkDQAgent — main orchestrator
+├── utils.py                # JSON serialisation helpers
+├── helpers/
+│   ├── api_client.py       # DQ Engine HTTP client (GET /config, POST /save-results)
+│   ├── expectations.py     # Expectation splitting (fast/slow) and result builders
+│   ├── trino_executor.py   # Trino fast-path — batched SQL for 5 assertion types
+│   ├── ge_executor.py      # GE slow-path — parallel in-memory validators
+│   ├── sql_utils.py        # SQL injection prevention utilities
+│   └── exceptions.py       # DQEngineAPIError
+└── data_quality_helper/
+    ├── const.py             # GE datasource config templates
+    ├── datacontext.py       # In-memory GE DataContext builder
+    ├── batch_request.py     # RuntimeBatchRequest factory
+    ├── expectation_suite.py # Suite builder from assertion dicts
+    ├── ge_utils.py          # Mapping ID resolution
+    └── checkpoint_conf.py   # Checkpoint runner (legacy)
+```
+
+## Usage
+
+### Single table
+
+```python
+from spark_dq.quality import SparkDQAgent
+
+agent = SparkDQAgent(
+    catalog="my_catalog",
+    schema="public",
+    table="sales_data",
+    data_quality_url="http://dq-engine:8000/api/v1/spark",
+    catalog_type="unmanaged",
+    table_id=13,
+    test_suite_id=37,
+    trino_host="trino-host:443",
+    trino_user="user",
+    trino_pwd="pwd",
+)
+
+cfg = agent.get_config()        # single GET /config call
+results = agent.validate(df)    # hybrid Trino + GE execution
+```
+
+### Suite run (auto-discover tables)
+
+```python
+agent = SparkDQAgent(
+    catalog="", schema="", table="",
+    data_quality_url="http://dq-engine:8000/api/v1/spark",
+    catalog_type="unmanaged",
+    test_suite_id=37,
+)
+table_configs = agent.get_all_table_configs()  # returns list of per-table configs
+```
+
+## Demo
+
+```bash
+# Single table
+python demo.py \
+  --catalog khtestpostgresss --schema public --table sales_data_new \
+  --dq_url http://localhost:8000/api/v1/spark \
+  --trino_host trino-dev.digixt.ae:443 --trino_user datalake --trino_pwd <pwd> \
+  --table_id 13 --test_suite_id 37
+
+# Suite run (auto-discovers tables)
+python demo.py \
+  --test_suite_id 37 \
+  --dq_url http://localhost:8000/api/v1/spark \
+  --trino_host trino-dev.digixt.ae:443 --trino_user datalake --trino_pwd <pwd>
+```
+
+## Hybrid execution
+
+When Trino credentials are provided, the agent splits expectations into two paths:
+
+| Path | Assertion types | How |
+|------|----------------|-----|
+| **Trino fast-path** | `not_be_null`, `be_unique`, `be_between`, `match_regex`, `row_count_to_be_between` | Single batched SQL query |
+| **GE slow-path** | All others | Parallel in-memory GE validators |
+
+Both paths run **concurrently**. Results are merged and saved via `POST /save-results`.
+
+## License
+
+MIT

spark_data_quality-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "spark-data-quality"
+version = "1.0.0"
+description = "SparkDQAgent — Data Quality validation package for K8s Spark pods"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    { name = "khailas", email = "khailas.rangath@saal.ai" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests>=2.28.0",
+    "great-expectations==0.18.12",
+    "trino>=0.320.0",
+    "PyYAML>=6.0",
+]
+
+[project.optional-dependencies]
+spark = ["pyspark>=3.1.1"]
+dev = ["pytest", "ruff"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py38"

spark_data_quality-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spark_data_quality-1.0.0/src/spark_data_quality.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: spark-data-quality
+Version: 1.0.0
+Summary: SparkDQAgent — Data Quality validation package for K8s Spark pods
+Author-email: khailas <khailas.rangath@saal.ai>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: great-expectations==0.18.12
+Requires-Dist: trino>=0.320.0
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: spark
+Requires-Dist: pyspark>=3.1.1; extra == "spark"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# spark-dq
+
+Data Quality validation library for K8s Spark pods. Runs Great Expectations + Trino hybrid checks and persists results to the DQ Engine API.
+
+## Installation
+
+```bash
+pip install .            # core (GE + Trino)
+pip install ".[spark]"   # includes PySpark
+pip install -e ".[dev]"  # editable + dev tools
+```
+
+## Package structure
+
+```
+src/spark_dq/
+├── quality.py              # SparkDQAgent — main orchestrator
+├── utils.py                # JSON serialisation helpers
+├── helpers/
+│   ├── api_client.py       # DQ Engine HTTP client (GET /config, POST /save-results)
+│   ├── expectations.py     # Expectation splitting (fast/slow) and result builders
+│   ├── trino_executor.py   # Trino fast-path — batched SQL for 5 assertion types
+│   ├── ge_executor.py      # GE slow-path — parallel in-memory validators
+│   ├── sql_utils.py        # SQL injection prevention utilities
+│   └── exceptions.py       # DQEngineAPIError
+└── data_quality_helper/
+    ├── const.py             # GE datasource config templates
+    ├── datacontext.py       # In-memory GE DataContext builder
+    ├── batch_request.py     # RuntimeBatchRequest factory
+    ├── expectation_suite.py # Suite builder from assertion dicts
+    ├── ge_utils.py          # Mapping ID resolution
+    └── checkpoint_conf.py   # Checkpoint runner (legacy)
+```
+
+## Usage
+
+### Single table
+
+```python
+from spark_dq.quality import SparkDQAgent
+
+agent = SparkDQAgent(
+    catalog="my_catalog",
+    schema="public",
+    table="sales_data",
+    data_quality_url="http://dq-engine:8000/api/v1/spark",
+    catalog_type="unmanaged",
+    table_id=13,
+    test_suite_id=37,
+    trino_host="trino-host:443",
+    trino_user="user",
+    trino_pwd="pwd",
+)
+
+cfg = agent.get_config()        # single GET /config call
+results = agent.validate(df)    # hybrid Trino + GE execution
+```
+
+### Suite run (auto-discover tables)
+
+```python
+agent = SparkDQAgent(
+    catalog="", schema="", table="",
+    data_quality_url="http://dq-engine:8000/api/v1/spark",
+    catalog_type="unmanaged",
+    test_suite_id=37,
+)
+table_configs = agent.get_all_table_configs()  # returns list of per-table configs
+```
+
+## Demo
+
+```bash
+# Single table
+python demo.py \
+  --catalog khtestpostgresss --schema public --table sales_data_new \
+  --dq_url http://localhost:8000/api/v1/spark \
+  --trino_host trino-dev.digixt.ae:443 --trino_user datalake --trino_pwd <pwd> \
+  --table_id 13 --test_suite_id 37
+
+# Suite run (auto-discovers tables)
+python demo.py \
+  --test_suite_id 37 \
+  --dq_url http://localhost:8000/api/v1/spark \
+  --trino_host trino-dev.digixt.ae:443 --trino_user datalake --trino_pwd <pwd>
+```
+
+## Hybrid execution
+
+When Trino credentials are provided, the agent splits expectations into two paths:
+
+| Path | Assertion types | How |
+|------|----------------|-----|
+| **Trino fast-path** | `not_be_null`, `be_unique`, `be_between`, `match_regex`, `row_count_to_be_between` | Single batched SQL query |
+| **GE slow-path** | All others | Parallel in-memory GE validators |
+
+Both paths run **concurrently**. Results are merged and saved via `POST /save-results`.
+
+## License
+
+MIT

spark_data_quality-1.0.0/src/spark_data_quality.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+LICENSE
+README.md
+pyproject.toml
+src/spark_data_quality.egg-info/PKG-INFO
+src/spark_data_quality.egg-info/SOURCES.txt
+src/spark_data_quality.egg-info/dependency_links.txt
+src/spark_data_quality.egg-info/requires.txt
+src/spark_data_quality.egg-info/top_level.txt
+src/spark_dq/__init__.py
+src/spark_dq/quality.py
+src/spark_dq/utils.py
+src/spark_dq/data_quality_helper/__init__.py
+src/spark_dq/data_quality_helper/batch_request.py
+src/spark_dq/data_quality_helper/checkpoint_conf.py
+src/spark_dq/data_quality_helper/const.py
+src/spark_dq/data_quality_helper/datacontext.py
+src/spark_dq/data_quality_helper/expectation_suite.py
+src/spark_dq/data_quality_helper/ge_utils.py
+src/spark_dq/data_quality_helper/utils.py
+src/spark_dq/helpers/__init__.py
+src/spark_dq/helpers/api_client.py
+src/spark_dq/helpers/exceptions.py
+src/spark_dq/helpers/expectations.py
+src/spark_dq/helpers/ge_executor.py
+src/spark_dq/helpers/sql_utils.py
+src/spark_dq/helpers/trino_executor.py
+tests/test_imports.py

spark_data_quality-1.0.0/src/spark_data_quality.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

spark_data_quality-1.0.0/src/spark_data_quality.egg-info/requires.txt

@@ -0,0 +1,11 @@
+requests>=2.28.0
+great-expectations==0.18.12
+trino>=0.320.0
+PyYAML>=6.0
+
+[dev]
+pytest
+ruff
+
+[spark]
+pyspark>=3.1.1

spark_data_quality-1.0.0/src/spark_data_quality.egg-info/top_level.txt

@@ -0,0 +1 @@
+spark_dq

spark_data_quality-1.0.0/src/spark_dq/__init__.py

@@ -0,0 +1,3 @@
+"""SparkDQAgent — Data Quality validation package for K8s Spark pods."""
+
+__version__ = "1.0.0"

spark_data_quality-1.0.0/src/spark_dq/data_quality_helper/batch_request.py

@@ -0,0 +1,23 @@
+import logging
+from great_expectations.core.batch import RuntimeBatchRequest
+
+logger = logging.getLogger(__name__)
+
+
+def create_batchrequest(df, datasource_name: str, data_asset_name: str):
+    """
+    Wrap a pre-loaded Spark DataFrame in a GE RuntimeBatchRequest.
+
+    The DataFrame is already loaded by ``quality_spark.py`` (either via
+    ``spark.sql`` for Iceberg or Trino JDBC for external catalogs).
+    No data fetching happens here.
+    """
+    batch = RuntimeBatchRequest(
+        datasource_name=datasource_name,
+        data_connector_name="default_runtime_data_connector_name",
+        data_asset_name=data_asset_name,
+        runtime_parameters={"batch_data": df},
+        batch_identifiers={"default_identifier_name": "default_identifier"},
+    )
+    logger.info("Batch request created from Spark DataFrame")
+    return batch

spark_data_quality-1.0.0/src/spark_dq/data_quality_helper/checkpoint_conf.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+
+from spark_dq.data_quality_helper.const import ACTION_LIST, DATETIME_FORMAT
+
+# BOOLEAN_ONLY: GE only computes pass/fail per expectation — no unexpected
+# value collection, no data movement back to the driver. This eliminates the
+# hidden per-expectation Spark action that makes validation slow at scale.
+RESULT_FORMAT = {
+    "result_format": "BOOLEAN_ONLY",
+    "include_unexpected_rows": False,
+    "partial_unexpected_count": 0,
+}
+
+
+def run_checkpoint(context, data_asset_name, expectation_suite_name, batch_request):
+    checkpoint = context.add_or_update_checkpoint(
+        name=f"{data_asset_name}.{expectation_suite_name}.chk",
+        module_name="great_expectations.checkpoint",
+        class_name="Checkpoint",
+        run_name_template=f'{datetime.now().strftime(DATETIME_FORMAT)}-my-run-name-template',
+    )
+
+    checkpoint_run_result = checkpoint.run(
+        run_name=f'{datetime.now().strftime(DATETIME_FORMAT)}-my-run-name-template',
+        batch_request=batch_request,
+        expectation_suite_name=expectation_suite_name,
+        action_list=ACTION_LIST,
+        runtime_configuration={"result_format": RESULT_FORMAT},
+    )
+    return checkpoint_run_result

spark_data_quality-1.0.0/src/spark_dq/data_quality_helper/const.py

@@ -0,0 +1,27 @@
+DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+DATASOURCE_CONFIG = """
+    name: {datasource_name}
+    class_name: Datasource
+    module_name: great_expectations.datasource
+    execution_engine:
+        class_name: SparkDFExecutionEngine
+        module_name: great_expectations.execution_engine
+        
+    data_connectors:
+        default_runtime_data_connector_name:
+            class_name: RuntimeDataConnector
+            batch_identifiers:
+            - default_identifier_name
+    """
+
+ACTION_LIST = [
+    {
+        "name": "store_validation_result",
+        "action": {"class_name": "StoreValidationResultAction"},
+    },
+    {
+        "name": "store_evaluation_params",
+        "action": {"class_name": "StoreEvaluationParametersAction"},
+    },
+]

spark_data_quality-1.0.0/src/spark_dq/data_quality_helper/datacontext.py

@@ -0,0 +1,39 @@
+from great_expectations.data_context.types.base import DataContextConfig
+
+
+def create_datacontext():
+    """Build a GE DataContextConfig backed entirely by in-memory stores."""
+    return DataContextConfig(
+        **{
+            "config_version": 1.0,
+            "stores": {
+                "expectations_store": {
+                    "class_name": "ExpectationsStore",
+                    "store_backend": {
+                        "class_name": "InMemoryStoreBackend",
+                    },
+                },
+                "validations_store": {
+                    "class_name": "ValidationsStore",
+                    "store_backend": {
+                        "class_name": "InMemoryStoreBackend",
+                    },
+                },
+                "evaluation_parameter_store": {
+                    "class_name": "EvaluationParameterStore",
+                },
+                "checkpoint_store": {
+                    "class_name": "CheckpointStore",
+                    "store_backend": {
+                        "class_name": "InMemoryStoreBackend",
+                    },
+                },
+            },
+            "expectations_store_name": "expectations_store",
+            "validations_store_name": "validations_store",
+            "evaluation_parameter_store_name": "evaluation_parameter_store",
+            "checkpoint_store_name": "checkpoint_store",
+            "data_docs_sites": {},
+            "anonymous_usage_statistics": {"enabled": False},
+        }
+    )

spark_data_quality-1.0.0/src/spark_dq/data_quality_helper/expectation_suite.py

@@ -0,0 +1,17 @@
+from great_expectations.core.expectation_configuration import ExpectationConfiguration
+
+
+def create_expectation_function(expectation_list, suite):
+    # print(f"###inside create_expectation_function,  expectation_list:{expectation_list}")
+    for expectation in expectation_list:
+        expectation = expectation["assertion_info"]
+
+        expectation = ExpectationConfiguration(
+            expectation_type=list(expectation.keys())[0],
+            kwargs=list(expectation.values())[0],
+        )
+        # while adding, GE will overwrite the assertion arguments, if the assertion already exists .
+
+        suite.add_expectation(expectation_configuration=expectation)
+
+    return suite

spark_data_quality-1.0.0/src/spark_dq/data_quality_helper/ge_utils.py

@@ -0,0 +1,20 @@
+def get_mapping_id(actions_result: dict, expectations_list: list):
+    """Match a GE validation result back to its assertion_mapping_id."""
+    expectation_type_action = actions_result["expectation_config"]["expectation_type"]
+    expectation_type_kwargs = dict(actions_result["expectation_config"]["kwargs"])
+    expectation_type_kwargs.pop("batch_id", None)
+    expectation_type_kwargs.pop("catch_exceptions", None)
+
+    for expectation in expectations_list:
+        expectation_info = expectation["assertion_info"]
+        expectation_type_key = list(expectation_info.keys())[0]
+        expectations_type_value = dict(list(expectation_info.values())[0])
+        expectations_type_value.pop("catch_exceptions", None)
+
+        if (
+            expectation_type_key == expectation_type_action
+            and expectations_type_value == expectation_type_kwargs
+        ):
+            return expectation["assertion_mapping_id"]
+
+    return None

spark_data_quality-1.0.0/src/spark_dq/data_quality_helper/utils.py

@@ -0,0 +1,50 @@
+import base64
+import os
+import shutil
+import urllib.parse
+
+
+def convert_quality_report_to_binary(quality_report_lctn):
+    quality_report_lctn = quality_report_lctn.split("file:")[1]
+
+    with open(rf"{urllib.parse.unquote(quality_report_lctn)}", "rb") as f:
+        file_content = f.read()
+
+    # Encode the file content as base64
+    html_binary = base64.b64encode(file_content)
+
+    return html_binary
+
+
+def delete_quality_files(table_id: int, suite_id: int, quality_path: str):
+    # to delete the folder and its contents
+    folder_paths = [
+        os.path.join(
+            quality_path,
+            "expectations",
+            f"{table_id}_{suite_id}",
+        ),
+        os.path.join(
+            quality_path,
+            "uncommitted",
+            "validations",
+            f"{table_id}_{suite_id}",
+        ),
+        os.path.join(
+            quality_path,
+            "checkpoints",
+            f"{table_id}_{suite_id}",
+        ),
+        os.path.join(
+            quality_path,
+            "uncommitted",
+            "data_docs",
+            "local_site",
+            f"{table_id}_{suite_id}",
+        ),
+    ]
+
+    for folder_path in folder_paths:
+        if os.path.exists(folder_path):
+            shutil.rmtree(folder_path)
+            print(f"Folder '{folder_path}' and its contents have been deleted.")