openmetadata-ingestion 1.4.6.0__py3-none-any.whl → 1.5.0.0rc1__py3-none-any.whl

metadata/data_quality/processor/test_case_runner.py

@@ -14,7 +14,7 @@ This Processor is in charge of executing the test cases
 """
 import traceback
 from copy import deepcopy
-from typing import List, Optional, cast
+from typing import List, Optional
 
 from metadata.data_quality.api.models import (
     TableAndTests,
@@ -36,7 +36,11 @@ from metadata.generated.schema.metadataIngestion.workflow import (
     OpenMetadataWorkflowConfig,
 )
 from metadata.generated.schema.tests.testCase import TestCase
-from metadata.generated.schema.tests.testDefinition import TestDefinition, TestPlatform
+from metadata.generated.schema.tests.testDefinition import (
+    EntityType,
+    TestDefinition,
+    TestPlatform,
+)
 from metadata.generated.schema.tests.testSuite import TestSuite
 from metadata.generated.schema.type.basic import EntityLink, FullyQualifiedEntityName
 from metadata.ingestion.api.models import Either
@@ -60,8 +64,8 @@ class TestCaseRunner(Processor):
         self.metadata = metadata
 
         self.processor_config: TestSuiteProcessorConfig = (
-            TestSuiteProcessorConfig.parse_obj(
-                self.config.processor.dict().get("config")
+            TestSuiteProcessorConfig.model_validate(
+                self.config.processor.model_dump().get("config")
             )
         )
 
@@ -82,20 +86,14 @@ class TestCaseRunner(Processor):
             test_suite_fqn=fqn.build(
                 None,
                 TestSuite,
-                table_fqn=record.table.fullyQualifiedName.__root__,
+                table_fqn=record.table.fullyQualifiedName.root,
             ),
-            table_fqn=record.table.fullyQualifiedName.__root__,
+            table_fqn=record.table.fullyQualifiedName.root,
         )
-
-        if not test_cases:
-            return Either(
-                left=StackTraceError(
-                    name="No test Cases",
-                    error=f"No tests cases found for table {record.table.fullyQualifiedName.__root__}",
-                )
-            )
-
         openmetadata_test_cases = self.filter_for_om_test_cases(test_cases)
+        openmetadata_test_cases = self.filter_incompatible_test_cases(
+            record.table, openmetadata_test_cases
+        )
 
         test_suite_runner = test_suite_source_factory.create(
             record.service_type.lower(),
@@ -104,6 +102,12 @@ class TestCaseRunner(Processor):
             record.table,
         ).get_data_quality_runner()
 
+        logger.debug(
+            f"Found {len(openmetadata_test_cases)} test cases for table {record.table.fullyQualifiedName.root}"
+        )
+        if len(openmetadata_test_cases) == 0:
+            logger.warning("No test cases found for the table")
+
         test_results = [
             test_case_result
             for test_case in openmetadata_test_cases
@@ -113,17 +117,14 @@ class TestCaseRunner(Processor):
         return Either(right=TestCaseResults(test_results=test_results))
 
     def get_test_cases(
-        self, test_cases: Optional[List[TestCase]], test_suite_fqn: str, table_fqn: str
+        self, test_cases: List[TestCase], test_suite_fqn: str, table_fqn: str
     ) -> List[TestCase]:
         """
         Based on the test suite test cases that we already know, pick up
         the rest from the YAML config, compare and create the new ones
         """
         if self.processor_config.testCases is not None:
-            cli_test_cases = self.get_test_case_from_cli_config()  # type: ignore
-            cli_test_cases = cast(
-                List[TestCaseDefinition], cli_test_cases
-            )  # satisfy type checker
+            cli_test_cases = self.get_test_case_from_cli_config()
             return self.compare_and_create_test_cases(
                 cli_test_cases_definitions=cli_test_cases,
                 test_cases=test_cases,
@@ -135,15 +136,13 @@ class TestCaseRunner(Processor):
 
     def get_test_case_from_cli_config(
         self,
-    ) -> Optional[List[TestCaseDefinition]]:
+    ) -> List[TestCaseDefinition]:
         """Get all the test cases names defined in the CLI config file"""
-        if self.processor_config.testCases is not None:
-            return list(self.processor_config.testCases)
-        return None
+        return list(self.processor_config.testCases or [])
 
     def compare_and_create_test_cases(
         self,
-        cli_test_cases_definitions: Optional[List[TestCaseDefinition]],
+        cli_test_cases_definitions: List[TestCaseDefinition],
         test_cases: List[TestCase],
         table_fqn: str,
         test_suite_fqn: str,
@@ -162,9 +161,7 @@ class TestCaseRunner(Processor):
             return test_cases
         test_cases = deepcopy(test_cases) or []
         test_case_names = (
-            {test_case.name.__root__ for test_case in test_cases}
-            if test_cases
-            else set()
+            {test_case.name.root for test_case in test_cases} if test_cases else set()
         )
 
         # we'll check the test cases defined in the CLI config file and not present in the platform
@@ -196,20 +193,22 @@ class TestCaseRunner(Processor):
                         description=test_case_to_create.description,
                         displayName=test_case_to_create.displayName,
                         testDefinition=FullyQualifiedEntityName(
-                            __root__=test_case_to_create.testDefinitionName
+                            test_case_to_create.testDefinitionName
                         ),
                         entityLink=EntityLink(
-                            __root__=entity_link.get_entity_link(
+                            entity_link.get_entity_link(
                                 Table,
                                 fqn=table_fqn,
                                 column_name=test_case_to_create.columnName,
                             )
                         ),
                         testSuite=test_suite_fqn,
-                        parameterValues=list(test_case_to_create.parameterValues)
-                        if test_case_to_create.parameterValues
-                        else None,
-                        owner=None,
+                        parameterValues=(
+                            list(test_case_to_create.parameterValues)
+                            if test_case_to_create.parameterValues
+                            else None
+                        ),
+                        owners=None,
                         computePassedFailedRowCount=test_case_to_create.computePassedFailedRowCount,
                     )
                 )
@@ -245,11 +244,11 @@ class TestCaseRunner(Processor):
             test_case_to_update.name for test_case_to_update in test_cases_to_update
         }
         for indx, test_case in enumerate(deepcopy(test_cases)):
-            if test_case.name.__root__ in test_cases_to_update_names:
+            if test_case.name.root in test_cases_to_update_names:
                 test_case_definition = next(
                     test_case_to_update
                     for test_case_to_update in test_cases_to_update
-                    if test_case_to_update.name == test_case.name.__root__
+                    if test_case_to_update.name == test_case.name.root
                 )
                 updated_test_case = self.metadata.patch_test_case_definition(
                     test_case=test_case,
@@ -281,7 +280,7 @@ class TestCaseRunner(Processor):
             )
             if TestPlatform.OpenMetadata not in test_definition.testPlatforms:
                 logger.debug(
-                    f"Test case {test_case.name.__root__} is not an OpenMetadata test case."
+                    f"Test case {test_case.name.root} is not an OpenMetadata test case."
                 )
                 continue
             om_test_cases.append(test_case)
@@ -294,15 +293,15 @@ class TestCaseRunner(Processor):
         """Execute the test case and return the result, if any"""
         try:
             test_result = test_suite_runner.run_and_handle(test_case)
-            self.status.scanned(test_case.fullyQualifiedName.__root__)
+            self.status.scanned(test_case.fullyQualifiedName.root)
             return test_result
         except Exception as exc:
-            error = f"Could not run test case {test_case.name.__root__}: {exc}"
+            error = f"Could not run test case {test_case.name.root}: {exc}"
             logger.debug(traceback.format_exc())
             logger.error(error)
             self.status.failed(
                 StackTraceError(
-                    name=test_case.name.__root__,
+                    name=test_case.name.root,
                     error=error,
                     stackTrace=traceback.format_exc(),
                 )
@@ -321,3 +320,40 @@ class TestCaseRunner(Processor):
 
     def close(self) -> None:
         """Nothing to close"""
+
+    def filter_incompatible_test_cases(
+        self, table: Table, test_cases: List[TestCase]
+    ) -> List[TestCase]:
+        """Filter out test cases that are defined for incompatible columns. An example of this is a
+        test case that checks for a column value to be between two values, but the column is of type
+        VARCHAR and not a numeric type. Incompatible test cases will be logged as failures.
+
+        Args:
+            table: Table entity the test cases are run against
+            test_cases: List of test cases
+
+        Returns:
+            List of test cases that are compatible with the table columns
+        """
+        result: List[TestCase] = []
+        for tc in test_cases:
+            test_definition: TestDefinition = self.metadata.get_by_id(
+                TestDefinition, tc.testDefinition.id, nullable=False
+            )
+            if test_definition.entityType != EntityType.COLUMN:
+                result.append(tc)
+                continue
+            column_name = entity_link.get_decoded_column(tc.entityLink.root)
+            column = next(c for c in table.columns if c.name.root == column_name)
+
+            if column.dataType not in test_definition.supportedDataTypes:
+                self.status.failed(
+                    StackTraceError(
+                        name="Incompatible Column for Test Case",
+                        error=f"Test case {tc.name.root} of type {test_definition.name.root}"
+                        f" is not compatible with column {column.name.root} of type {column.dataType.value}",
+                    )
+                )
+            else:
+                result.append(tc)
+        return result

metadata/data_quality/runner/base_test_suite_source.py

@@ -71,7 +71,7 @@ class BaseTestSuiteRunner:
             DatabaseService.__config__
         """
         config_copy = deepcopy(
-            config.source.serviceConnection.__root__.config  # type: ignore
+            config.source.serviceConnection.root.config  # type: ignore
         )
         if hasattr(
             config_copy,  # type: ignore

metadata/data_quality/runner/core.py

@@ -31,8 +31,8 @@ class DataTestsRunner:
     def run_and_handle(self, test_case: TestCase):
         """run and handle test case validation"""
         logger.info(
-            f"Executing test case {test_case.name.__root__} "
-            f"for entity {self.test_runner_interface.table_entity.fullyQualifiedName.__root__}"
+            f"Executing test case {test_case.name.root} "
+            f"for entity {self.test_runner_interface.table_entity.fullyQualifiedName.root}"
         )
         test_result = self.test_runner_interface.run_test_case(
             test_case,

metadata/data_quality/source/test_suite.py

@@ -72,7 +72,7 @@ class TestSuiteSource(Source):
         """
         table: Table = self.metadata.get_by_name(
             entity=Table,
-            fqn=self.source_config.entityFullyQualifiedName.__root__,
+            fqn=self.source_config.entityFullyQualifiedName.root,
             fields=["tableProfilerConfig", "testSuite"],
         )
 
@@ -80,19 +80,21 @@ class TestSuiteSource(Source):
 
     def _get_test_cases_from_test_suite(
         self, test_suite: Optional[TestSuite]
-    ) -> Optional[List[TestCase]]:
+    ) -> List[TestCase]:
         """Return test cases if the test suite exists and has them"""
         if test_suite:
             test_cases = self.metadata.list_all_entities(
                 entity=TestCase,
                 fields=["testSuite", "entityLink", "testDefinition"],
-                params={"testSuiteId": test_suite.id.__root__},
+                params={"testSuiteId": test_suite.id.root},
             )
             test_cases = cast(List[TestCase], test_cases)  # satisfy type checker
-
+            if self.source_config.testCases is not None:
+                test_cases = [
+                    t for t in test_cases if t.name in self.source_config.testCases
+                ]
             return test_cases
-
-        return None
+        return []
 
     def prepare(self):
         """Nothing to prepare"""
@@ -110,7 +112,7 @@ class TestSuiteSource(Source):
             yield Either(
                 left=StackTraceError(
                     name="Missing Table",
-                    error=f"Could not retrieve table entity for {self.source_config.entityFullyQualifiedName.__root__}."
+                    error=f"Could not retrieve table entity for {self.source_config.entityFullyQualifiedName.root}."
                     " Make sure the table exists in OpenMetadata and/or the JWT Token provided is valid.",
                 )
             )
@@ -125,31 +127,31 @@ class TestSuiteSource(Source):
                 name=fqn.build(
                     None,
                     TestSuite,
-                    table_fqn=self.source_config.entityFullyQualifiedName.__root__,
+                    table_fqn=self.source_config.entityFullyQualifiedName.root,
                 ),
-                displayName=f"{self.source_config.entityFullyQualifiedName.__root__} Test Suite",
+                displayName=f"{self.source_config.entityFullyQualifiedName.root} Test Suite",
                 description="Test Suite created from YAML processor config file",
-                owner=None,
-                executableEntityReference=self.source_config.entityFullyQualifiedName.__root__,
+                owners=None,
+                executableEntityReference=self.source_config.entityFullyQualifiedName.root,
             )
             yield Either(
                 right=TableAndTests(
                     executable_test_suite=executable_test_suite,
-                    service_type=self.config.source.serviceConnection.__root__.config.type.value,
+                    service_type=self.config.source.serviceConnection.root.config.type.value,
                 )
             )
 
         test_suite: Optional[TestSuite] = None
         if table.testSuite:
             test_suite = self.metadata.get_by_id(
-                entity=TestSuite, entity_id=table.testSuite.id.__root__
+                entity=TestSuite, entity_id=table.testSuite.id.root
             )
 
         if test_suite and not test_suite.executable:
             yield Either(
                 left=StackTraceError(
                     name="Non-executable Test Suite",
-                    error=f"The table {self.source_config.entityFullyQualifiedName.__root__} "
+                    error=f"The table {self.source_config.entityFullyQualifiedName.root} "
                     "has a test suite that is not executable.",
                 )
             )
@@ -161,7 +163,7 @@ class TestSuiteSource(Source):
                 right=TableAndTests(
                     table=table,
                     test_cases=test_suite_cases,
-                    service_type=self.config.source.serviceConnection.__root__.config.type.value,
+                    service_type=self.config.source.serviceConnection.root.config.type.value,
                 )
             )
 

metadata/data_quality/validations/base_test_handler.py

@@ -18,8 +18,11 @@ from __future__ import annotations
 import reprlib
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Callable, List, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Callable, List, Optional, Type, TypeVar, Union
 
+from metadata.data_quality.validations.runtime_param_setter.param_setter import (
+    RuntimeParameterSetter,
+)
 from metadata.generated.schema.tests.basic import (
     TestCaseResult,
     TestCaseStatus,
@@ -28,16 +31,24 @@ from metadata.generated.schema.tests.basic import (
 from metadata.generated.schema.tests.testCase import TestCase, TestCaseParameterValue
 from metadata.profiler.processor.runner import QueryRunner
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 T = TypeVar("T", bound=Callable)
 R = TypeVar("R")
 
 
 class BaseTestValidator(ABC):
-    """Abstract class for test case handlers"""
+    """Abstract class for test case handlers
+    The runtime_parameter_setter is run after the test case is created to set the runtime parameters.
+    This can be useful to resolve complex test parameters based on the parameters gibven by the user.
+    """
+
+    runtime_parameter_setter: Optional[Type[RuntimeParameterSetter]] = None
 
     def __init__(
         self,
-        runner: QueryRunner,
+        runner: Union[QueryRunner, List["DataFrame"]],
         test_case: TestCase,
         execution_date: Union[datetime, float],
     ) -> None:
@@ -94,6 +105,8 @@ class BaseTestValidator(ABC):
         row_count: Optional[int] = None,
         failed_rows: Optional[int] = None,
         passed_rows: Optional[int] = None,
+        min_bound: Optional[float] = None,
+        max_bound: Optional[float] = None,
     ) -> TestCaseResult:
         """Returns a TestCaseResult object with the given args
 
@@ -111,6 +124,9 @@ class BaseTestValidator(ABC):
             result=result,
             testResultValue=test_result_value,
             sampleData=None,
+            # if users don't set the min/max bound, we'll change the inf/-inf (used for computation) to None
+            minBound=None if min_bound == float("-inf") else min_bound,
+            maxBound=None if max_bound == float("inf") else max_bound,
         )
 
         if (row_count is not None and row_count != 0) and (
@@ -149,7 +165,7 @@ class BaseTestValidator(ABC):
         """
         return TestCaseStatus.Success if condition else TestCaseStatus.Failed
 
-    def get_min_bound(self, param_name: str):
+    def get_min_bound(self, param_name: str) -> Optional[float]:
         """get min value for max value in column test case"""
         return self.get_test_case_param_value(
             self.test_case.parameterValues,  # type: ignore
@@ -158,7 +174,7 @@ class BaseTestValidator(ABC):
             default=float("-inf"),
         )
 
-    def get_max_bound(self, param_name: str):
+    def get_max_bound(self, param_name: str) -> Optional[float]:
         """get max value for max value in column test case"""
         return self.get_test_case_param_value(
             self.test_case.parameterValues,  # type: ignore
@@ -166,3 +182,7 @@ class BaseTestValidator(ABC):
             float,
             default=float("inf"),
         )
+
+    def get_predicted_value(self) -> Optional[str]:
+        """Get predicted value"""
+        return None

metadata/data_quality/validations/column/base/columnValueLengthsToBeBetween.py

@@ -83,6 +83,8 @@ class BaseColumnValueLengthsToBeBetweenValidator(BaseTestValidator):
             ],
             row_count=row_count,
             failed_rows=failed_rows,
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMaxToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMaxToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found max={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MAX, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMeanToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMeanToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found mean={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MEAN, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMedianToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMedianToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found median={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MEDIAN, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueMinToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueMinToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found min={res} vs.  the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=MIN, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValueStdDevToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValueStdDevToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found stddev={res} vs. the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=STDDEV, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValuesSumToBeBetween.py

@@ -65,6 +65,8 @@ class BaseColumnValuesSumToBeBetweenValidator(BaseTestValidator):
             self.get_test_case_status(min_bound <= res <= max_bound),
             f"Found sum={res} vs. the expected min={min_bound}, max={max_bound}.",
             [TestResultValue(name=SUM, value=str(res))],
+            min_bound=min_bound,
+            max_bound=max_bound,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValuesToBeBetween.py

@@ -84,21 +84,25 @@ class BaseColumnValuesToBeBetweenValidator(BaseTestValidator):
         if type(max_res) is date:  # pylint: disable=unidiomatic-typecheck
             max_res = self._convert_date_to_datetime(max_res, time.max)
 
-        min_bound = self.get_test_case_param_value(
-            self.test_case.parameterValues,  # type: ignore
-            "minValue",
-            type_=datetime.fromtimestamp if is_date_time(column.type) else float,
-            default=datetime.min if is_date_time(column.type) else float("-inf"),
-            pre_processor=convert_timestamp if is_date_time(column.type) else None,
-        )
+        if is_date_time(column.type):
+            min_bound = self.get_test_case_param_value(
+                self.test_case.parameterValues,  # type: ignore
+                "minValue",
+                type_=datetime.fromtimestamp,
+                default=datetime.min,
+                pre_processor=convert_timestamp,
+            )
 
-        max_bound = self.get_test_case_param_value(
-            self.test_case.parameterValues,  # type: ignore
-            "maxValue",
-            type_=datetime.fromtimestamp if is_date_time(column.type) else float,
-            default=datetime.max if is_date_time(column.type) else float("inf"),
-            pre_processor=convert_timestamp if is_date_time(column.type) else None,
-        )
+            max_bound = self.get_test_case_param_value(
+                self.test_case.parameterValues,  # type: ignore
+                "maxValue",
+                type_=datetime.fromtimestamp,
+                default=datetime.max,
+                pre_processor=convert_timestamp,
+            )
+        else:
+            min_bound = self.get_min_bound("minValue")
+            max_bound = self.get_max_bound("maxValue")
 
         if self.test_case.computePassedFailedRowCount:
             row_count, failed_rows = self.get_row_count(min_bound, max_bound)
@@ -115,6 +119,12 @@ class BaseColumnValuesToBeBetweenValidator(BaseTestValidator):
             ],
             row_count=row_count,
             failed_rows=failed_rows,
+            min_bound=min_bound
+            if not isinstance(min_bound, (datetime, date))
+            else None,
+            max_bound=max_bound
+            if not isinstance(min_bound, (datetime, date))
+            else None,
         )
 
     @abstractmethod

metadata/data_quality/validations/column/base/columnValuesToBeInSet.py

@@ -50,9 +50,21 @@ class BaseColumnValuesToBeInSetValidator(BaseTestValidator):
             literal_eval,
         )
 
+        match_enum = self.get_test_case_param_value(
+            self.test_case.parameterValues,  # type: ignore
+            "matchEnum",
+            bool,
+            default=False,
+        )
+
         try:
             column: Union[SQALikeColumn, Column] = self._get_column_name()
             res = self._run_results(Metrics.COUNT_IN_SET, column, values=allowed_values)
+            if match_enum:
+                count = self._run_results(
+                    Metrics.ROW_COUNT, column, values=allowed_values
+                )
+                res = count - res
         except (ValueError, RuntimeError) as exc:
             msg = f"Error computing {self.test_case.fullyQualifiedName}: {exc}"  # type: ignore
             logger.debug(traceback.format_exc())
@@ -71,7 +83,7 @@ class BaseColumnValuesToBeInSetValidator(BaseTestValidator):
 
         return self.get_test_case_result_object(
             self.execution_date,
-            self.get_test_case_status(res >= 1),
+            self.get_test_case_status(res == 0 if match_enum else res >= 1),
             f"Found countInSet={res}.",
             [TestResultValue(name=ALLOWED_VALUE_COUNT, value=str(res))],
             row_count=row_count,

metadata/data_quality/validations/column/base/columnValuesToBeNotInSet.py

@@ -59,7 +59,7 @@ class BaseColumnValuesToBeNotInSetValidator(BaseTestValidator):
         except (ValueError, RuntimeError) as exc:
             msg = (
                 f"Error computing {self.test_case.name} for "
-                f"{get_table_fqn(self.test_case.entityLink.__root__)}: {exc}"
+                f"{get_table_fqn(self.test_case.entityLink.root)}: {exc}"
             )
             logger.debug(traceback.format_exc())
             logger.warning(msg)

metadata/data_quality/validations/column/pandas/columnValueLengthsToBeBetween.py

@@ -38,7 +38,7 @@ class ColumnValueLengthsToBeBetweenValidator(
             SQALikeColumn:
         """
         return self.get_column_name(
-            self.test_case.entityLink.__root__,
+            self.test_case.entityLink.root,
             self.runner,
         )
 

metadata/data_quality/validations/column/pandas/columnValueMaxToBeBetween.py

@@ -37,7 +37,7 @@ class ColumnValueMaxToBeBetweenValidator(
             SQALikeColumn: column
         """
         return self.get_column_name(
-            self.test_case.entityLink.__root__,
+            self.test_case.entityLink.root,
             self.runner,
         )
 

metadata/data_quality/validations/column/pandas/columnValueMeanToBeBetween.py

@@ -38,7 +38,7 @@ class ColumnValueMeanToBeBetweenValidator(
             SQALikeColumn: column
         """
         return self.get_column_name(
-            self.test_case.entityLink.__root__,
+            self.test_case.entityLink.root,
             self.runner,
         )
 

metadata/data_quality/validations/column/pandas/columnValueMedianToBeBetween.py

@@ -37,7 +37,7 @@ class ColumnValueMedianToBeBetweenValidator(
             SQALikeColumn: column
         """
         return self.get_column_name(
-            self.test_case.entityLink.__root__,
+            self.test_case.entityLink.root,
             self.runner,
         )
 

metadata/data_quality/validations/column/pandas/columnValueMinToBeBetween.py

@@ -37,7 +37,7 @@ class ColumnValueMinToBeBetweenValidator(
             SQALikeColumn: column
         """
         return self.get_column_name(
-            self.test_case.entityLink.__root__,
+            self.test_case.entityLink.root,
             self.runner,
         )
 

metadata/data_quality/validations/column/pandas/columnValueStdDevToBeBetween.py

@@ -37,7 +37,7 @@ class ColumnValueStdDevToBeBetweenValidator(
             SQALikeColumn: column
         """
         return self.get_column_name(
-            self.test_case.entityLink.__root__,
+            self.test_case.entityLink.root,
             self.runner,
         )