zenml-nightly 0.55.0.dev20240124__py3-none-any.whl → 0.72.0.dev20250116__py3-none-any.whl

zenml/integrations/deepchecks/data_validators/deepchecks_data_validator.py

@@ -17,6 +17,7 @@ from typing import (
     Any,
     ClassVar,
     Dict,
+    List,
     Optional,
     Sequence,
     Tuple,
@@ -28,9 +29,8 @@ import pandas as pd
 from deepchecks.core.checks import BaseCheck
 from deepchecks.core.suite import SuiteResult
 from deepchecks.tabular import Dataset as TabularData
+from deepchecks.tabular import ModelComparisonSuite
 from deepchecks.tabular import Suite as TabularSuite
-
-# not part of deepchecks.tabular.checks
 from deepchecks.tabular.suites import full_suite as full_tabular_suite
 from deepchecks.vision import Suite as VisionSuite
 from deepchecks.vision import VisionData
@@ -61,9 +61,9 @@ class DeepchecksDataValidator(BaseDataValidator):
     """Deepchecks data validator stack component."""
 
     NAME: ClassVar[str] = "Deepchecks"
-    FLAVOR: ClassVar[
-        Type[BaseDataValidatorFlavor]
-    ] = DeepchecksDataValidatorFlavor
+    FLAVOR: ClassVar[Type[BaseDataValidatorFlavor]] = (
+        DeepchecksDataValidatorFlavor
+    )
 
     @staticmethod
     def _split_checks(
@@ -102,7 +102,7 @@ class DeepchecksDataValidator(BaseDataValidator):
         comparison_dataset: Optional[
             Union[pd.DataFrame, DataLoader[Any]]
         ] = None,
-        model: Optional[Union[ClassifierMixin, Module]] = None,
+        models: Optional[List[Union[ClassifierMixin, Module]]] = None,
         check_list: Optional[Sequence[str]] = None,
         dataset_kwargs: Dict[str, Any] = {},
         check_kwargs: Dict[str, Dict[str, Any]] = {},
@@ -123,7 +123,7 @@ class DeepchecksDataValidator(BaseDataValidator):
                 validation.
             comparison_dataset: Optional secondary (comparison) dataset argument
                 used during comparison checks.
-            model: Optional model argument used during validation.
+            models: Optional model argument used during validation.
             check_list: Optional list of ZenML Deepchecks check identifiers
                 specifying the list of Deepchecks checks to be performed.
             dataset_kwargs: Additional keyword arguments to be passed to the
@@ -149,6 +149,7 @@ class DeepchecksDataValidator(BaseDataValidator):
         # arguments and the check list.
         is_tabular = False
         is_vision = False
+        is_multi_model = False
         for dataset in [reference_dataset, comparison_dataset]:
             if dataset is None:
                 continue
@@ -163,7 +164,18 @@ class DeepchecksDataValidator(BaseDataValidator):
                     f"data and {str(DataLoader)} for computer vision data."
                 )
 
-        if model:
+        if models:
+            # if there's more than one models, we should set the
+            # is_multi_model to True
+            if len(models) > 1:
+                is_multi_model = True
+            # if the models are of different types, raise an error
+            # only the same type of models can be used for comparison
+            if len(set(type(model) for model in models)) > 1:
+                raise TypeError(
+                    "Models used for comparison checks must be of the same type."
+                )
+            model = models[0]
             if isinstance(model, ClassifierMixin):
                 is_tabular = True
             elif isinstance(model, Module):
@@ -190,8 +202,18 @@ class DeepchecksDataValidator(BaseDataValidator):
         if not check_list:
             # default to executing all the checks listed in the supplied
             # checks enum type if a custom check list is not supplied
+            # don't include the TABULAR_PERFORMANCE_BIAS check enum value
+            # as it requires a protected feature name to be set
+            checks_to_exclude = [
+                DeepchecksModelValidationCheck.TABULAR_PERFORMANCE_BIAS
+            ]
+            check_enum_values = [
+                check.value
+                for check in check_enum
+                if check not in checks_to_exclude
+            ]
             tabular_checks, vision_checks = cls._split_checks(
-                check_enum.values()
+                check_enum_values
             )
             if is_tabular:
                 check_list = tabular_checks
@@ -254,6 +276,10 @@ class DeepchecksDataValidator(BaseDataValidator):
             suite_class = VisionSuite
             full_suite = full_vision_suite()
 
+        # if is_multi_model is True, we need to use the ModelComparisonSuite
+        if is_multi_model:
+            suite_class = ModelComparisonSuite
+
         train_dataset = dataset_class(reference_dataset, **dataset_kwargs)
         test_dataset = None
         if comparison_dataset is not None:
@@ -294,13 +320,28 @@ class DeepchecksDataValidator(BaseDataValidator):
                     continue
                 condition_method(**condition_kwargs)
 
-            suite.add(check)
-        return suite.run(
-            train_dataset=train_dataset,
-            test_dataset=test_dataset,
-            model=model,
-            **run_kwargs,
-        )
+            # if the check is supported by the suite, add it
+            if isinstance(check, suite.supported_checks()):
+                suite.add(check)
+            else:
+                logger.warning(
+                    f"Check {check_name} is not supported by the {suite_class} "
+                    "suite. Ignoring the check."
+                )
+
+        if isinstance(suite, ModelComparisonSuite):
+            return suite.run(
+                models=models,
+                train_datasets=train_dataset,
+                test_datasets=test_dataset,
+            )
+        else:
+            return suite.run(
+                train_dataset=train_dataset,
+                test_dataset=test_dataset,
+                model=models[0] if models else None,
+                **run_kwargs,
+            )
 
     def data_validation(
         self,
@@ -389,7 +430,7 @@ class DeepchecksDataValidator(BaseDataValidator):
         """Run one or more Deepchecks model validation checks.
 
         Call this method to perform model validation checks (e.g. confusion
-        matrix validation, performance reports, model error analyses, etc).
+        matrix validation, performance reports, model error analyzes, etc).
         A second dataset is required for model performance comparison tests
         (i.e. tests that identify changes in a model behavior by comparing how
         it performs on two different datasets).
@@ -444,7 +485,7 @@ class DeepchecksDataValidator(BaseDataValidator):
             check_enum=check_enum,
             reference_dataset=dataset,
             comparison_dataset=comparison_dataset,
-            model=model,
+            models=[model],
             check_list=check_list,
             dataset_kwargs=dataset_kwargs,
             check_kwargs=check_kwargs,

zenml/integrations/deepchecks/materializers/deepchecks_dataset_materializer.py

@@ -18,7 +18,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, Tuple, Type
 from deepchecks.tabular import Dataset
 
 from zenml.enums import ArtifactType, VisualizationType
-from zenml.materializers.pandas_materializer import PandasMaterializer
+from zenml.integrations.pandas.materializers.pandas_materializer import (
+    PandasMaterializer,
+)
 
 if TYPE_CHECKING:
     from zenml.metadata.metadata_types import MetadataType

zenml/integrations/deepchecks/materializers/deepchecks_results_materializer.py

@@ -39,9 +39,9 @@ class DeepchecksResultMaterializer(BaseMaterializer):
         CheckResult,
         SuiteResult,
     )
-    ASSOCIATED_ARTIFACT_TYPE: ClassVar[
-        ArtifactType
-    ] = ArtifactType.DATA_ANALYSIS
+    ASSOCIATED_ARTIFACT_TYPE: ClassVar[ArtifactType] = (
+        ArtifactType.DATA_ANALYSIS
+    )
 
     def load(self, data_type: Type[Any]) -> Union[CheckResult, SuiteResult]:
         """Reads a Deepchecks check or suite result from a serialized JSON file.

zenml/integrations/deepchecks/validation_checks.py

@@ -118,10 +118,10 @@ class DeepchecksValidationCheck(StrEnum):
         cls.validate_check_name(check_name)
 
         try:
-            check_class: Type[
-                BaseCheck
-            ] = source_utils.load_and_validate_class(
-                check_name, expected_class=BaseCheck
+            check_class: Type[BaseCheck] = (
+                source_utils.load_and_validate_class(
+                    check_name, expected_class=BaseCheck
+                )
             )
         except AttributeError:
             raise ValueError(
@@ -153,8 +153,8 @@ class DeepchecksDataIntegrityCheck(DeepchecksValidationCheck):
 
     This list reflects the set of data integrity checks provided by Deepchecks:
 
-      * [for tabular data](https://docs.deepchecks.com/en/stable/checks_gallery/tabular.html#data-integrity)
-      * [for computer vision](https://docs.deepchecks.com/en/stable/checks_gallery/vision.html#data-integrity)
+      * [for tabular data](https://docs.deepchecks.com/stable/tabular/auto_checks/data_integrity/index.html)
+      * [for computer vision](https://docs.deepchecks.com/stable/vision/auto_checks/data_integrity/index.html)
 
     All these checks inherit from `deepchecks.tabular.SingleDatasetCheck` or
     `deepchecks.vision.SingleDatasetCheck` and require a single dataset as input.
@@ -176,8 +176,8 @@ class DeepchecksDataIntegrityCheck(DeepchecksValidationCheck):
     TABULAR_FEATURE_LABEL_CORRELATION = source_utils.resolve(
         tabular_checks.FeatureLabelCorrelation
     ).import_path
-    TABULAR_IDENTIFIER_LEAKAGE = source_utils.resolve(
-        tabular_checks.IdentifierLeakage
+    TABULAR_IDENTIFIER_LABEL_CORRELATION = source_utils.resolve(
+        tabular_checks.IdentifierLabelCorrelation
     ).import_path
     TABULAR_IS_SINGLE_VALUE = source_utils.resolve(
         tabular_checks.IsSingleValue
@@ -200,6 +200,12 @@ class DeepchecksDataIntegrityCheck(DeepchecksValidationCheck):
     TABULAR_STRING_MISMATCH = source_utils.resolve(
         tabular_checks.StringMismatch
     ).import_path
+    TABULAR_CLASS_IMBALANCE = source_utils.resolve(
+        tabular_checks.ClassImbalance
+    ).import_path
+    TABULAR_PERCENT_OF_NULLS = source_utils.resolve(
+        tabular_checks.PercentOfNulls
+    ).import_path
 
     VISION_IMAGE_PROPERTY_OUTLIERS = source_utils.resolve(
         vision_checks.ImagePropertyOutliers
@@ -207,6 +213,9 @@ class DeepchecksDataIntegrityCheck(DeepchecksValidationCheck):
     VISION_LABEL_PROPERTY_OUTLIERS = source_utils.resolve(
         vision_checks.LabelPropertyOutliers
     ).import_path
+    VISION_PROPERTY_LABEL_CORRELATION = source_utils.resolve(
+        vision_checks.PropertyLabelCorrelation
+    ).import_path
 
 
 class DeepchecksDataDriftCheck(DeepchecksValidationCheck):
@@ -234,9 +243,6 @@ class DeepchecksDataDriftCheck(DeepchecksValidationCheck):
     TABULAR_DATE_TRAIN_TEST_LEAKAGE_OVERLAP = source_utils.resolve(
         tabular_checks.DateTrainTestLeakageOverlap
     ).import_path
-    TABULAR_DOMINANT_FREQUENCY_CHANGE = source_utils.resolve(
-        tabular_checks.DominantFrequencyChange
-    ).import_path
     TABULAR_FEATURE_LABEL_CORRELATION_CHANGE = source_utils.resolve(
         tabular_checks.FeatureLabelCorrelationChange
     ).import_path
@@ -252,22 +258,37 @@ class DeepchecksDataDriftCheck(DeepchecksValidationCheck):
     TABULAR_TRAIN_TEST_FEATURE_DRIFT = source_utils.resolve(
         tabular_checks.TrainTestFeatureDrift
     ).import_path
+    TABULAR_FEATURE_DRIFT = source_utils.resolve(
+        tabular_checks.FeatureDrift
+    ).import_path
     TABULAR_TRAIN_TEST_LABEL_DRIFT = source_utils.resolve(
         tabular_checks.TrainTestLabelDrift
     ).import_path
+    TABULAR_LABEL_DRIFT = source_utils.resolve(
+        tabular_checks.LabelDrift
+    ).import_path
     TABULAR_TRAIN_TEST_SAMPLES_MIX = source_utils.resolve(
         tabular_checks.TrainTestSamplesMix
     ).import_path
     TABULAR_WHOLE_DATASET_DRIFT = source_utils.resolve(
         tabular_checks.WholeDatasetDrift
     ).import_path
+    TABULAR_NEW_CATEGORY_TRAIN_TEST = source_utils.resolve(
+        tabular_checks.NewCategoryTrainTest
+    ).import_path
+    TABULAR_MULTIVARIATE_DRIFT = source_utils.resolve(
+        tabular_checks.MultivariateDrift
+    ).import_path
 
-    VISION_FEATURE_LABEL_CORRELATION_CHANGE = source_utils.resolve(
-        vision_checks.FeatureLabelCorrelationChange
+    VISION_PROPERTY_LABEL_CORRELATION_CHANGE = source_utils.resolve(
+        vision_checks.PropertyLabelCorrelationChange
     ).import_path
     VISION_HEATMAP_COMPARISON = source_utils.resolve(
         vision_checks.HeatmapComparison
     ).import_path
+    VISION_LABEL_DRIFT = source_utils.resolve(
+        vision_checks.LabelDrift
+    ).import_path
     VISION_IMAGE_DATASET_DRIFT = source_utils.resolve(
         vision_checks.ImageDatasetDrift
     ).import_path
@@ -277,12 +298,6 @@ class DeepchecksDataDriftCheck(DeepchecksValidationCheck):
     VISION_NEW_LABELS = source_utils.resolve(
         vision_checks.NewLabels
     ).import_path
-    VISION_SIMILAR_IMAGE_LEAKAGE = source_utils.resolve(
-        vision_checks.SimilarImageLeakage
-    ).import_path
-    VISION_TRAIN_TEST_LABEL_DRIFT = source_utils.resolve(
-        vision_checks.TrainTestLabelDrift
-    ).import_path
 
 
 class DeepchecksModelValidationCheck(DeepchecksValidationCheck):
@@ -308,6 +323,12 @@ class DeepchecksModelValidationCheck(DeepchecksValidationCheck):
     TABULAR_MODEL_INFERENCE_TIME = source_utils.resolve(
         tabular_checks.ModelInferenceTime
     ).import_path
+    TABULAR_MODEL_INFO = source_utils.resolve(
+        tabular_checks.ModelInfo
+    ).import_path
+    TABULAR_PERFORMANCE_BIAS = source_utils.resolve(
+        tabular_checks.model_evaluation.PerformanceBias
+    ).import_path
     TABULAR_REGRESSION_ERROR_DISTRIBUTION = source_utils.resolve(
         tabular_checks.RegressionErrorDistribution
     ).import_path
@@ -320,24 +341,33 @@ class DeepchecksModelValidationCheck(DeepchecksValidationCheck):
     TABULAR_SEGMENT_PERFORMANCE = source_utils.resolve(
         tabular_checks.SegmentPerformance
     ).import_path
+    TABULAR_WEAK_SEGMENT_PERFORMANCE = source_utils.resolve(
+        tabular_checks.WeakSegmentsPerformance
+    ).import_path
+    TABULAR_SINGLE_DATASET_PERFORMANCE = source_utils.resolve(
+        tabular_checks.SingleDatasetPerformance
+    ).import_path
+    TABULAR_TRAIN_TEST_PERFORMANCE = source_utils.resolve(
+        tabular_checks.TrainTestPerformance
+    ).import_path
+    TABULAR_MULTI_MODEL_PERFORMANCE_REPORT = source_utils.resolve(
+        tabular_checks.MultiModelPerformanceReport
+    ).import_path
 
     VISION_CONFUSION_MATRIX_REPORT = source_utils.resolve(
         vision_checks.ConfusionMatrixReport
     ).import_path
-    VISION_IMAGE_SEGMENT_PERFORMANCE = source_utils.resolve(
-        vision_checks.ImageSegmentPerformance
-    ).import_path
     VISION_MEAN_AVERAGE_PRECISION_REPORT = source_utils.resolve(
         vision_checks.MeanAveragePrecisionReport
     ).import_path
     VISION_MEAN_AVERAGE_RECALL_REPORT = source_utils.resolve(
         vision_checks.MeanAverageRecallReport
     ).import_path
-    VISION_ROBUSTNESS_REPORT = source_utils.resolve(
-        vision_checks.RobustnessReport
+    VISION_SINGLE_DATASET_PERFORMANCE = source_utils.resolve(
+        vision_checks.SingleDatasetPerformance
     ).import_path
-    VISION_SINGLE_DATASET_SCALAR_PERFORMANCE = source_utils.resolve(
-        vision_checks.SingleDatasetScalarPerformance
+    VISION_WEAK_SEGMENT_PERFORMANCE = source_utils.resolve(
+        vision_checks.WeakSegmentsPerformance
     ).import_path
 
 
@@ -358,18 +388,15 @@ class DeepchecksModelDriftCheck(DeepchecksValidationCheck):
     TABULAR_BOOSTING_OVERFIT = source_utils.resolve(
         tabular_checks.BoostingOverfit
     ).import_path
-    TABULAR_MODEL_ERROR_ANALYSIS = source_utils.resolve(
-        tabular_checks.ModelErrorAnalysis
-    ).import_path
-    TABULAR_PERFORMANCE_REPORT = source_utils.resolve(
-        tabular_checks.PerformanceReport
-    ).import_path
     TABULAR_SIMPLE_MODEL_COMPARISON = source_utils.resolve(
         tabular_checks.SimpleModelComparison
     ).import_path
     TABULAR_TRAIN_TEST_PREDICTION_DRIFT = source_utils.resolve(
         tabular_checks.TrainTestPredictionDrift
     ).import_path
+    TABULAR_PREDICTION_DRIFT = source_utils.resolve(
+        tabular_checks.PredictionDrift
+    ).import_path
     TABULAR_UNUSED_FEATURES = source_utils.resolve(
         tabular_checks.UnusedFeatures
     ).import_path
@@ -377,12 +404,12 @@ class DeepchecksModelDriftCheck(DeepchecksValidationCheck):
     VISION_CLASS_PERFORMANCE = source_utils.resolve(
         vision_checks.ClassPerformance
     ).import_path
-    VISION_MODEL_ERROR_ANALYSIS = source_utils.resolve(
-        vision_checks.ModelErrorAnalysis
-    ).import_path
     VISION_SIMPLE_MODEL_COMPARISON = source_utils.resolve(
         vision_checks.SimpleModelComparison
     ).import_path
     VISION_TRAIN_TEST_PREDICTION_DRIFT = source_utils.resolve(
         vision_checks.TrainTestPredictionDrift
     ).import_path
+    VISION_PREDICTION_DRIFT = source_utils.resolve(
+        vision_checks.PredictionDrift
+    ).import_path

zenml/integrations/discord/__init__.py

@@ -31,6 +31,7 @@ class DiscordIntegration(Integration):
 
     NAME = DISCORD
     REQUIREMENTS = ["discord.py>=2.3.2", "aiohttp>=3.8.1", "asyncio"]
+    REQUIREMENTS_IGNORED_ON_UNINSTALL = ["aiohttp","asyncio"]
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/discord/steps/discord_alerter_ask_step.py

@@ -12,6 +12,7 @@
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
 """Step that allows you to send messages to Discord and wait for a response."""
+
 from typing import Optional
 
 from zenml import get_step_context, step

zenml/integrations/discord/steps/discord_alerter_post_step.py

@@ -12,6 +12,7 @@
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
 """Step that allows you to post messages to Discord."""
+
 from typing import Optional
 
 from zenml import get_step_context, step

zenml/integrations/evidently/__init__.py

@@ -25,16 +25,15 @@ file.
 import logging
 import os
 import warnings
-from typing import List, Type
+from typing import List, Type, Optional
 
 from zenml.integrations.constants import EVIDENTLY
 from zenml.integrations.integration import Integration
 from zenml.stack import Flavor
 
-
 # Fix numba errors in Docker and suppress logs and deprecation warning spam
 try:
-    from numba.core.errors import (  # type: ignore[import-untyped]
+    from numba.core.errors import (
         NumbaDeprecationWarning,
         NumbaPendingDeprecationWarning,
     )
@@ -54,7 +53,26 @@ class EvidentlyIntegration(Integration):
     """[Evidently](https://github.com/evidentlyai/evidently) integration for ZenML."""
 
     NAME = EVIDENTLY
-    REQUIREMENTS = ["evidently>0.2.6,<0.4.5"]  # supports pyyaml 6
+    REQUIREMENTS = [
+        "evidently>=0.4.16,<=0.4.22",
+        "tenacity!=8.4.0",  # https://github.com/jd/tenacity/issues/471
+    ]
+    REQUIREMENTS_IGNORED_ON_UNINSTALL = ["tenacity", "pandas"]
+
+    @classmethod
+    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+        """Method to get the requirements for the integration.
+
+        Args:
+            target_os: The target operating system to get the requirements for.
+
+        Returns:
+            A list of requirements.
+        """
+        from zenml.integrations.pandas import PandasIntegration
+
+        return cls.REQUIREMENTS + \
+            PandasIntegration.get_requirements(target_os=target_os)
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/evidently/column_mapping.py

@@ -16,7 +16,7 @@
 from typing import List, Optional, Sequence, Union
 
 from evidently import ColumnMapping  # type: ignore[import-untyped]
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class EvidentlyColumnMapping(BaseModel):
@@ -41,7 +41,9 @@ class EvidentlyColumnMapping(BaseModel):
     """
 
     target: Optional[str] = None
-    prediction: Optional[Union[str, Sequence[str]]] = "prediction"
+    prediction: Optional[Union[str, Sequence[str]]] = Field(
+        default="prediction", union_mode="left_to_right"
+    )
     datetime: Optional[str] = None
     id: Optional[str] = None
     numerical_features: Optional[List[str]] = None
@@ -49,9 +51,15 @@ class EvidentlyColumnMapping(BaseModel):
     datetime_features: Optional[List[str]] = None
     target_names: Optional[List[str]] = None
     task: Optional[str] = None
-    pos_label: Optional[Union[str, int]] = 1
+    pos_label: Optional[Union[str, int]] = Field(
+        default=1, union_mode="left_to_right"
+    )
     text_features: Optional[List[str]] = None
 
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
     def to_evidently_column_mapping(self) -> ColumnMapping:
         """Convert this Pydantic object to an Evidently ColumnMapping object.
 

zenml/integrations/evidently/data_validators/evidently_data_validator.py

@@ -45,9 +45,9 @@ class EvidentlyDataValidator(BaseDataValidator):
     """Evidently data validator stack component."""
 
     NAME: ClassVar[str] = "Evidently"
-    FLAVOR: ClassVar[
-        Type[BaseDataValidatorFlavor]
-    ] = EvidentlyDataValidatorFlavor
+    FLAVOR: ClassVar[Type[BaseDataValidatorFlavor]] = (
+        EvidentlyDataValidatorFlavor
+    )
 
     @classmethod
     def _unpack_options(
@@ -118,14 +118,16 @@ class EvidentlyDataValidator(BaseDataValidator):
         return options
 
     @staticmethod
-    def _download_nltk_data() -> None:
-        """Download NLTK data for text metrics and tests.
+    def _set_nltk_data_path() -> None:
+        """Set the NLTK data path to the current working directory.
+
+        This is necessary because the default download directory is not writable
+        in some Docker containers.
 
         Raises:
             ImportError: if NLTK is not installed.
         """
         try:
-            import nltk  # type: ignore[import-untyped]
             from nltk.data import (  # type: ignore[import-untyped]
                 path as nltk_path,
             )
@@ -138,8 +140,23 @@ class EvidentlyDataValidator(BaseDataValidator):
         # Configure NLTK to use the current working directory to download and
         # lookup data. This is necessary because the default download directory
         # is not writable in some Docker containers.
+        os.environ["NLTK_DATA"] = os.getcwd()
         nltk_path.append(os.getcwd())
 
+    @staticmethod
+    def _download_nltk_data() -> None:
+        """Download NLTK data for text metrics and tests.
+
+        Raises:
+            ImportError: if NLTK is not installed.
+        """
+        try:
+            import nltk  # type: ignore[import-untyped]
+        except ImportError:
+            raise ImportError(
+                "NLTK is not installed. Please install NLTK to use "
+                "Evidently text metrics and tests."
+            )
         # Download NLTK data. We need this later on for the Evidently text report.
         nltk.download("words", download_dir=os.getcwd())
         nltk.download("wordnet", download_dir=os.getcwd())
@@ -196,6 +213,7 @@ class EvidentlyDataValidator(BaseDataValidator):
         Returns:
             The Evidently Report as JSON object and as HTML.
         """
+        self._set_nltk_data_path()
         if download_nltk_data:
             self._download_nltk_data()
 

zenml/integrations/evidently/metrics.py

@@ -33,7 +33,7 @@ from evidently.metrics.base_metric import (  # type: ignore[import-untyped]
 from evidently.utils.generators import (  # type: ignore[import-untyped]
     BaseGenerator,
 )
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from zenml.logger import get_logger
 from zenml.utils import source_utils
@@ -75,7 +75,9 @@ class EvidentlyMetricConfig(BaseModel):
     class_path: str
     parameters: Dict[str, Any] = Field(default_factory=dict)
     is_generator: bool = False
-    columns: Optional[Union[str, List[str]]] = None
+    columns: Optional[Union[str, List[str]]] = Field(
+        default=None, union_mode="left_to_right"
+    )
     skip_id_column: bool = False
 
     @staticmethod
@@ -209,7 +211,7 @@ class EvidentlyMetricConfig(BaseModel):
         else:
             raise ValueError(f"Invalid Evidently Metric class: {metric}")
 
-        class_path = f"{metric_class.__module__}." f"{metric_class.__name__}"
+        class_path = f"{metric_class.__module__}.{metric_class.__name__}"
 
         config = cls(
             class_path=class_path,
@@ -289,7 +291,7 @@ class EvidentlyMetricConfig(BaseModel):
                 f"Invalid Evidently Metric or MetricPreset class: {metric}"
             )
 
-        class_path = f"{metric_class.__module__}." f"{metric_class.__name__}"
+        class_path = f"{metric_class.__module__}.{metric_class.__name__}"
 
         config = cls(class_path=class_path, parameters=parameters)
 
@@ -359,7 +361,4 @@ class EvidentlyMetricConfig(BaseModel):
                 f"`{self.class_path}`: {str(e)}"
             )
 
-    class Config:
-        """Pydantic config class."""
-
-        extra = "forbid"
+    model_config = ConfigDict(extra="forbid")

zenml/integrations/evidently/tests.py

@@ -33,7 +33,7 @@ from evidently.tests.base_test import (  # type: ignore[import-untyped]
 from evidently.utils.generators import (  # type: ignore[import-untyped]
     BaseGenerator,
 )
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from zenml.logger import get_logger
 from zenml.utils import source_utils
@@ -73,7 +73,9 @@ class EvidentlyTestConfig(BaseModel):
     class_path: str
     parameters: Dict[str, Any] = Field(default_factory=dict)
     is_generator: bool = False
-    columns: Optional[Union[str, List[str]]] = None
+    columns: Optional[Union[str, List[str]]] = Field(
+        default=None, union_mode="left_to_right"
+    )
 
     @staticmethod
     def get_test_class(test_name: str) -> Union[Test, TestPreset]:
@@ -203,7 +205,7 @@ class EvidentlyTestConfig(BaseModel):
         else:
             raise ValueError(f"Invalid Evidently Test class: {test}")
 
-        class_path = f"{test_class.__module__}." f"{test_class.__name__}"
+        class_path = f"{test_class.__module__}.{test_class.__name__}"
 
         config = cls(
             class_path=class_path,
@@ -282,7 +284,7 @@ class EvidentlyTestConfig(BaseModel):
                 f"Invalid Evidently Test or TestPreset class: {test}"
             )
 
-        class_path = f"{test_class.__module__}." f"{test_class.__name__}"
+        class_path = f"{test_class.__module__}.{test_class.__name__}"
         config = cls(class_path=class_path, parameters=parameters)
 
         # Try to instantiate the configuration to check if the parameters are
@@ -343,7 +345,4 @@ class EvidentlyTestConfig(BaseModel):
                 f"`{self.class_path}`: {str(e)}"
             )
 
-    class Config:
-        """Pydantic config class."""
-
-        extra = "forbid"
+    model_config = ConfigDict(extra="forbid")