From d48773c8e75872f0c7c152668a4399bc314e1d6b Mon Sep 17 00:00:00 2001 From: mike0sv Date: Mon, 17 Mar 2025 17:16:39 +0000 Subject: [PATCH 1/2] base polymorphic model and imports --- .../fastapi_monitoring/fastapi/app.py | 2 +- src/evidently/_pydantic_compat.py | 89 ----------- src/evidently/base_metric.py | 6 +- src/evidently/collector/app.py | 2 +- src/evidently/collector/config.py | 6 +- src/evidently/collector/storage.py | 2 +- src/evidently/core.py | 18 +-- src/evidently/experimental/report_set.py | 3 +- src/evidently/features/custom_feature.py | 2 +- src/evidently/features/generated_features.py | 4 +- src/evidently/features/llm_judge.py | 4 +- src/evidently/features/sentiment_feature.py | 2 +- .../trigger_words_presence_feature.py | 2 +- src/evidently/features/words_feature.py | 2 +- src/evidently/future/datasets.py | 2 +- .../descriptors/_generate_descriptors.py | 3 +- src/evidently/future/metric_types.py | 2 +- src/evidently/future/tests/reference.py | 2 +- src/evidently/metric_results.py | 4 +- .../confusion_matrix_metric.py | 3 +- .../lift_table_metric.py | 4 +- .../classification_performance/objects.py | 4 +- .../pr_table_metric.py | 4 +- src/evidently/metrics/custom_metric.py | 3 +- src/evidently/options/base.py | 9 +- src/evidently/options/data_drift.py | 3 +- src/evidently/pydantic_utils.py | 149 ++++++++++-------- src/evidently/suite/base_suite.py | 4 +- src/evidently/ui/api/models.py | 5 +- src/evidently/ui/app.py | 2 +- src/evidently/ui/base.py | 8 +- src/evidently/ui/components/base.py | 2 +- src/evidently/ui/components/security.py | 2 +- src/evidently/ui/config.py | 6 +- src/evidently/ui/dashboards/base.py | 6 +- src/evidently/ui/dashboards/test_suites.py | 2 +- src/evidently/ui/dashboards/utils.py | 2 +- src/evidently/ui/managers/auth.py | 3 +- src/evidently/ui/managers/projects.py | 2 +- src/evidently/ui/storage/local/base.py | 6 +- src/evidently/ui/storage/utils.py | 3 +- src/evidently/ui/utils.py | 4 +- src/evidently/ui/workspace/cloud.py | 2 +- src/evidently/ui/workspace/remote.py | 2 +- src/evidently/utils/data_preprocessing.py | 2 +- src/evidently/utils/llm/wrapper.py | 5 +- tests/collector/test_app.py | 2 +- tests/collector/test_config.py | 2 +- tests/conftest.py | 2 +- tests/features/test_multicolumn.py | 2 +- .../test_column_value_list_metric.py | 2 +- tests/metrics/recsys/test_precision_top_k.py | 2 +- tests/multitest/conftest.py | 3 +- tests/test_metric_results.py | 6 +- tests/test_pydantic_aliases.py | 2 +- tests/ui/conftest.py | 2 +- tests/ui/test_app.py | 2 +- tests/ui/test_dashboards.py | 2 +- tests/utils/test_pydantic_utils.py | 4 +- 59 files changed, 186 insertions(+), 251 deletions(-) delete mode 100644 src/evidently/_pydantic_compat.py diff --git a/examples/integrations/fastapi_monitoring/fastapi/app.py b/examples/integrations/fastapi_monitoring/fastapi/app.py index dbe496fd91..b3d23dfc26 100644 --- a/examples/integrations/fastapi_monitoring/fastapi/app.py +++ b/examples/integrations/fastapi_monitoring/fastapi/app.py @@ -9,7 +9,7 @@ Response, FileResponse ) -from evidently._pydantic_compat import BaseModel +from pydantic import BaseModel import pandas as pd from config.config import DATA_COLUMNS diff --git a/src/evidently/_pydantic_compat.py b/src/evidently/_pydantic_compat.py deleted file mode 100644 index 1e3b0c4227..0000000000 --- a/src/evidently/_pydantic_compat.py +++ /dev/null @@ -1,89 +0,0 @@ -from typing import TYPE_CHECKING - -import pydantic - -v = 1 if pydantic.__version__.startswith("1") else 2 - -if v == 2: - from pydantic.v1 import BaseConfig - from pydantic.v1 import BaseModel - from pydantic.v1 import EmailStr - from pydantic.v1 import Extra - from pydantic.v1 import Field - from pydantic.v1 import PrivateAttr - from pydantic.v1 import SecretStr - from pydantic.v1 import ValidationError - from pydantic.v1 import create_model - from pydantic.v1 import parse_obj_as - from pydantic.v1 import root_validator - from pydantic.v1 import validator - from pydantic.v1.fields import SHAPE_DICT - from pydantic.v1.fields import SHAPE_LIST - from pydantic.v1.fields import SHAPE_SET - from pydantic.v1.fields import SHAPE_TUPLE - from pydantic.v1.fields import ModelField - from pydantic.v1.main import ModelMetaclass - from pydantic.v1.utils import import_string - from pydantic.v1.validators import _VALIDATORS - - if TYPE_CHECKING: - from pydantic.v1.main import AbstractSetIntStr - from pydantic.v1.main import MappingIntStrAny - from pydantic.v1.main import Model - from pydantic.v1.typing import DictStrAny - -else: - from pydantic import BaseConfig # type: ignore[assignment] - from pydantic import BaseModel # type: ignore[assignment] - from pydantic import EmailStr # type: ignore[attr-defined,no-redef] - from pydantic import Extra # type: ignore[assignment] - from pydantic import Field # type: ignore[assignment] - from pydantic import PrivateAttr - from pydantic import SecretStr # type: ignore[assignment] - from pydantic import ValidationError # type: ignore[assignment] - from pydantic import create_model # type: ignore[attr-defined,no-redef] - from pydantic import parse_obj_as - from pydantic import root_validator # type: ignore[attr-defined,no-redef] - from pydantic import validator - from pydantic.fields import SHAPE_DICT # type: ignore[attr-defined,no-redef] - from pydantic.fields import SHAPE_LIST # type: ignore[attr-defined,no-redef] - from pydantic.fields import SHAPE_SET # type: ignore[attr-defined,no-redef] - from pydantic.fields import SHAPE_TUPLE # type: ignore[attr-defined,no-redef] - from pydantic.fields import ModelField # type: ignore[attr-defined,no-redef] - from pydantic.main import ModelMetaclass # type: ignore[attr-defined,no-redef] - from pydantic.utils import import_string # type: ignore[attr-defined,no-redef] - from pydantic.validators import _VALIDATORS # type: ignore[attr-defined,no-redef] - - if TYPE_CHECKING: - from pydantic.main import AbstractSetIntStr # type: ignore[attr-defined,no-redef] - from pydantic.main import MappingIntStrAny # type: ignore[attr-defined,no-redef] - from pydantic.main import Model # type: ignore[attr-defined,no-redef] - from pydantic.typing import DictStrAny # type: ignore[attr-defined,no-redef] - - -__all__ = [ - "BaseConfig", - "BaseModel", - "Field", - "ValidationError", - "parse_obj_as", - "validator", - "SecretStr", - "SHAPE_DICT", - "SHAPE_LIST", - "SHAPE_SET", - "SHAPE_TUPLE", - "ModelField", - "ModelMetaclass", - "import_string", - "_VALIDATORS", - "Model", - "MappingIntStrAny", - "AbstractSetIntStr", - "DictStrAny", - "PrivateAttr", - "Extra", - "create_model", - "EmailStr", - "root_validator", -] diff --git a/src/evidently/base_metric.py b/src/evidently/base_metric.py index 77d235f796..c9cd7def95 100644 --- a/src/evidently/base_metric.py +++ b/src/evidently/base_metric.py @@ -17,10 +17,10 @@ import pandas as pd import typing_inspect +from pydantic import Field +from pydantic import PrivateAttr +from pydantic._internal._model_construction import ModelMetaclass -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import ModelMetaclass -from evidently._pydantic_compat import PrivateAttr from evidently.core import BaseResult from evidently.core import ColumnType from evidently.core import IncludeTags diff --git a/src/evidently/collector/app.py b/src/evidently/collector/app.py index 50a0c38f91..f245693cf2 100644 --- a/src/evidently/collector/app.py +++ b/src/evidently/collector/app.py @@ -28,9 +28,9 @@ from litestar.types import Receive from litestar.types import Scope from litestar.types import Send +from pydantic import SecretStr from typing_extensions import Annotated -from evidently._pydantic_compat import SecretStr from evidently.collector.config import CONFIG_PATH from evidently.collector.config import CollectorConfig from evidently.collector.config import CollectorServiceConfig diff --git a/src/evidently/collector/config.py b/src/evidently/collector/config.py index 79de610c97..0348586389 100644 --- a/src/evidently/collector/config.py +++ b/src/evidently/collector/config.py @@ -9,10 +9,10 @@ from typing import Union import pandas as pd +from pydantic import BaseModel +from pydantic import Field +from pydantic import parse_obj_as -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import Metric from evidently.collector.storage import CollectorStorage from evidently.collector.storage import InMemoryStorage diff --git a/src/evidently/collector/storage.py b/src/evidently/collector/storage.py index 1e1b290f0c..9b5bd96237 100644 --- a/src/evidently/collector/storage.py +++ b/src/evidently/collector/storage.py @@ -6,8 +6,8 @@ from typing import Sequence import pandas as pd +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.pydantic_utils import PolymorphicModel from evidently.pydantic_utils import autoregister from evidently.suite.base_suite import ReportBase diff --git a/src/evidently/core.py b/src/evidently/core.py index 5adbff0837..b3f9e5f535 100644 --- a/src/evidently/core.py +++ b/src/evidently/core.py @@ -1,4 +1,5 @@ import uuid +from enum import Enum from typing import TYPE_CHECKING from typing import Any from typing import ClassVar @@ -14,25 +15,14 @@ import numpy as np import pandas as pd import uuid6 +from pydantic import BaseConfig +from pydantic import BaseModel +from pydantic_core.core_schema import ModelField from typing_inspect import is_literal_type -from evidently._pydantic_compat import SHAPE_DICT -from evidently._pydantic_compat import SHAPE_LIST -from evidently._pydantic_compat import SHAPE_SET -from evidently._pydantic_compat import SHAPE_TUPLE -from evidently._pydantic_compat import ModelField from evidently.pydantic_utils import IncludeTags from evidently.pydantic_utils import pydantic_type_validator -if TYPE_CHECKING: - from evidently._pydantic_compat import AbstractSetIntStr - from evidently._pydantic_compat import MappingIntStrAny - -from enum import Enum - -from evidently._pydantic_compat import BaseConfig -from evidently._pydantic_compat import BaseModel - IncludeOptions = Union["AbstractSetIntStr", "MappingIntStrAny"] diff --git a/src/evidently/experimental/report_set.py b/src/evidently/experimental/report_set.py index 262a100676..bc90b705ce 100644 --- a/src/evidently/experimental/report_set.py +++ b/src/evidently/experimental/report_set.py @@ -3,7 +3,8 @@ from typing import Dict from typing import Optional -from evidently._pydantic_compat import ValidationError +from pydantic import ValidationError + from evidently.suite.base_suite import Snapshot from evidently.ui.type_aliases import SnapshotID diff --git a/src/evidently/features/custom_feature.py b/src/evidently/features/custom_feature.py index 1e38d08ff6..91924cb07e 100644 --- a/src/evidently/features/custom_feature.py +++ b/src/evidently/features/custom_feature.py @@ -2,8 +2,8 @@ from typing import Tuple import pandas as pd +from pydantic import Field -from evidently._pydantic_compat import Field from evidently.base_metric import ColumnName from evidently.core import ColumnType from evidently.core import new_id diff --git a/src/evidently/features/generated_features.py b/src/evidently/features/generated_features.py index 1f4dc221bf..5e96487df0 100644 --- a/src/evidently/features/generated_features.py +++ b/src/evidently/features/generated_features.py @@ -9,9 +9,9 @@ import deprecation import pandas as pd import uuid6 +from pydantic import BaseModel +from pydantic import Field -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import Field from evidently.base_metric import ColumnName from evidently.base_metric import DatasetType from evidently.base_metric import TEngineDataType diff --git a/src/evidently/features/llm_judge.py b/src/evidently/features/llm_judge.py index a84d63f76d..b14199e9b6 100644 --- a/src/evidently/features/llm_judge.py +++ b/src/evidently/features/llm_judge.py @@ -9,9 +9,9 @@ from typing import Tuple import pandas as pd +from pydantic import Field +from pydantic import PrivateAttr -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import PrivateAttr from evidently.base_metric import ColumnName from evidently.core import ColumnType from evidently.features.generated_features import GeneratedFeatures diff --git a/src/evidently/features/sentiment_feature.py b/src/evidently/features/sentiment_feature.py index f269abaaf4..41e0744e2d 100644 --- a/src/evidently/features/sentiment_feature.py +++ b/src/evidently/features/sentiment_feature.py @@ -4,8 +4,8 @@ import numpy as np from nltk.sentiment.vader import SentimentIntensityAnalyzer +from pydantic import PrivateAttr -from evidently._pydantic_compat import PrivateAttr from evidently.core import ColumnType from evidently.features.generated_features import ApplyColumnGeneratedFeature diff --git a/src/evidently/features/trigger_words_presence_feature.py b/src/evidently/features/trigger_words_presence_feature.py index 675b7bd23c..027bea560f 100644 --- a/src/evidently/features/trigger_words_presence_feature.py +++ b/src/evidently/features/trigger_words_presence_feature.py @@ -6,8 +6,8 @@ import numpy as np from nltk.stem.wordnet import WordNetLemmatizer +from pydantic import PrivateAttr -from evidently._pydantic_compat import PrivateAttr from evidently.core import ColumnType from evidently.features.generated_features import ApplyColumnGeneratedFeature diff --git a/src/evidently/features/words_feature.py b/src/evidently/features/words_feature.py index 72526abf9a..470ba64260 100644 --- a/src/evidently/features/words_feature.py +++ b/src/evidently/features/words_feature.py @@ -7,8 +7,8 @@ import numpy as np import pandas as pd from nltk.stem.wordnet import WordNetLemmatizer +from pydantic import PrivateAttr -from evidently._pydantic_compat import PrivateAttr from evidently.base_metric import ColumnName from evidently.core import ColumnType from evidently.features.generated_features import ApplyColumnGeneratedFeature diff --git a/src/evidently/future/datasets.py b/src/evidently/future/datasets.py index cc9248929e..0708c71a8f 100644 --- a/src/evidently/future/datasets.py +++ b/src/evidently/future/datasets.py @@ -12,8 +12,8 @@ import numpy as np import pandas as pd +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.base_metric import DisplayName from evidently.core import ColumnType from evidently.features.generated_features import GeneratedFeatures diff --git a/src/evidently/future/descriptors/_generate_descriptors.py b/src/evidently/future/descriptors/_generate_descriptors.py index 06802da41d..1462e3fe71 100644 --- a/src/evidently/future/descriptors/_generate_descriptors.py +++ b/src/evidently/future/descriptors/_generate_descriptors.py @@ -8,7 +8,8 @@ from typing import Tuple from typing import Type -from evidently._pydantic_compat import import_string +from pydantic import import_string + from evidently.core import ColumnType from evidently.descriptors.llm_judges import BaseLLMEval from evidently.features.custom_feature import CustomFeature diff --git a/src/evidently/future/metric_types.py b/src/evidently/future/metric_types.py index db19f3a109..bb9722fb25 100644 --- a/src/evidently/future/metric_types.py +++ b/src/evidently/future/metric_types.py @@ -22,8 +22,8 @@ from typing import Union import typing_inspect +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.future._utils import not_implemented from evidently.future.datasets import Dataset from evidently.metric_results import Label diff --git a/src/evidently/future/tests/reference.py b/src/evidently/future/tests/reference.py index 8bd5732d27..22c19ca424 100644 --- a/src/evidently/future/tests/reference.py +++ b/src/evidently/future/tests/reference.py @@ -1,6 +1,6 @@ from typing import Optional -from evidently._pydantic_compat import BaseModel +from pydantic import BaseModel class Reference(BaseModel): diff --git a/src/evidently/metric_results.py b/src/evidently/metric_results.py index 3c1c18f89c..5a1e1d2cff 100644 --- a/src/evidently/metric_results.py +++ b/src/evidently/metric_results.py @@ -11,10 +11,10 @@ import numpy as np import pandas as pd +from pydantic import parse_obj_as +from pydantic import validator from typing_extensions import Literal -from evidently._pydantic_compat import parse_obj_as -from evidently._pydantic_compat import validator from evidently.base_metric import MetricResult from evidently.core import IncludeTags from evidently.core import pydantic_type_validator diff --git a/src/evidently/metrics/classification_performance/confusion_matrix_metric.py b/src/evidently/metrics/classification_performance/confusion_matrix_metric.py index be67be2eff..e36cd7c7e4 100644 --- a/src/evidently/metrics/classification_performance/confusion_matrix_metric.py +++ b/src/evidently/metrics/classification_performance/confusion_matrix_metric.py @@ -3,7 +3,8 @@ from typing import Optional from typing import Union -from evidently._pydantic_compat import BaseModel +from pydantic import BaseModel + from evidently.base_metric import InputData from evidently.base_metric import MetricResult from evidently.calculations.classification_performance import calculate_matrix diff --git a/src/evidently/metrics/classification_performance/lift_table_metric.py b/src/evidently/metrics/classification_performance/lift_table_metric.py index 8a7edb3f64..3e5a4fe426 100644 --- a/src/evidently/metrics/classification_performance/lift_table_metric.py +++ b/src/evidently/metrics/classification_performance/lift_table_metric.py @@ -7,8 +7,8 @@ from typing import Union import pandas as pd +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.base_metric import InputData from evidently.base_metric import Metric from evidently.base_metric import MetricResult @@ -28,7 +28,7 @@ from evidently.utils.data_operations import process_columns if TYPE_CHECKING: - from evidently._pydantic_compat import Model + from pydantic import Model class LabelModel(BaseModel): diff --git a/src/evidently/metrics/classification_performance/objects.py b/src/evidently/metrics/classification_performance/objects.py index 1125418868..8fcd091872 100644 --- a/src/evidently/metrics/classification_performance/objects.py +++ b/src/evidently/metrics/classification_performance/objects.py @@ -1,10 +1,10 @@ from typing import Dict from typing import Optional +from pydantic import Field +from pydantic import parse_obj_as from sklearn.metrics import classification_report -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import MetricResult from evidently.metric_results import Label diff --git a/src/evidently/metrics/classification_performance/pr_table_metric.py b/src/evidently/metrics/classification_performance/pr_table_metric.py index c9cee3b4ce..0c5f879e8f 100644 --- a/src/evidently/metrics/classification_performance/pr_table_metric.py +++ b/src/evidently/metrics/classification_performance/pr_table_metric.py @@ -7,8 +7,8 @@ from typing import Union import pandas as pd +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.base_metric import InputData from evidently.base_metric import Metric from evidently.base_metric import MetricResult @@ -27,7 +27,7 @@ from evidently.utils.data_operations import process_columns if TYPE_CHECKING: - from evidently._pydantic_compat import Model + from pydantic import Model class LabelModel(BaseModel): diff --git a/src/evidently/metrics/custom_metric.py b/src/evidently/metrics/custom_metric.py index 5dd4ebd2b3..58f6594221 100644 --- a/src/evidently/metrics/custom_metric.py +++ b/src/evidently/metrics/custom_metric.py @@ -3,7 +3,8 @@ from typing import Optional from typing import Union -from evidently._pydantic_compat import PrivateAttr +from pydantic import PrivateAttr + from evidently.base_metric import InputData from evidently.base_metric import Metric from evidently.base_metric import MetricResult diff --git a/src/evidently/options/base.py b/src/evidently/options/base.py index a76b7098f7..0b9a0db3e4 100644 --- a/src/evidently/options/base.py +++ b/src/evidently/options/base.py @@ -6,16 +6,17 @@ from typing import TypeVar from typing import Union -from evidently._pydantic_compat import BaseModel +from pydantic import BaseModel + from evidently.options import ColorOptions from evidently.options.agg_data import DataDefinitionOptions from evidently.options.agg_data import RenderOptions from evidently.options.option import Option if TYPE_CHECKING: - from evidently._pydantic_compat import AbstractSetIntStr - from evidently._pydantic_compat import DictStrAny - from evidently._pydantic_compat import MappingIntStrAny + from pydantic import AbstractSetIntStr + from pydantic import DictStrAny + from pydantic import MappingIntStrAny TypeParam = TypeVar("TypeParam", bound=Option) diff --git a/src/evidently/options/data_drift.py b/src/evidently/options/data_drift.py index 0a0cf48f4c..670d5ea270 100644 --- a/src/evidently/options/data_drift.py +++ b/src/evidently/options/data_drift.py @@ -5,7 +5,8 @@ from typing import Optional from typing import Union -from evidently._pydantic_compat import BaseModel +from pydantic import BaseModel + from evidently.calculations.stattests import PossibleStatTestType from evidently.calculations.stattests import StatTest from evidently.utils.data_drift_utils import resolve_stattest_threshold diff --git a/src/evidently/pydantic_utils.py b/src/evidently/pydantic_utils.py index ec3b2f9528..6bf7fcfa7f 100644 --- a/src/evidently/pydantic_utils.py +++ b/src/evidently/pydantic_utils.py @@ -19,6 +19,7 @@ from typing import List from typing import Literal from typing import Optional +from typing import Self from typing import Set from typing import Tuple from typing import Type @@ -27,17 +28,19 @@ from typing import get_args import numpy as np +from pydantic import BaseModel +from pydantic import ConfigDict +from pydantic import Field +from pydantic import model_serializer +from pydantic import model_validator +from pydantic._internal._model_construction import ModelMetaclass +from pydantic._internal._validators import import_string +from pydantic_core import PydanticCustomError +from pydantic_core.core_schema import SerializerFunctionWrapHandler from typing_inspect import is_union_type -from evidently._pydantic_compat import SHAPE_DICT -from evidently._pydantic_compat import BaseConfig -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import ModelMetaclass -from evidently._pydantic_compat import import_string - if TYPE_CHECKING: - from evidently._pydantic_compat import DictStrAny + from pydantic import DictStrAny md5_kwargs = {"usedforsecurity": False} if sys.version_info >= (3, 9) else {} @@ -47,7 +50,7 @@ def pydantic_type_validator(type_: Type[Any], prioritize: bool = False): def decorator(f): - from evidently._pydantic_compat import _VALIDATORS + from pydantic import _VALIDATORS for cls, validators in _VALIDATORS: if cls is type_: @@ -68,8 +71,8 @@ def decorator(f): class FrozenBaseMeta(ModelMetaclass): def __new__(mcs, name, bases, namespace, **kwargs): - res = super().__new__(mcs, name, bases, namespace, **kwargs) - res.__config__.frozen = True + res: Type[BaseModel] = super().__new__(mcs, name, bases, namespace, **kwargs) + res.model_config["frozen"] = True return res @@ -194,25 +197,21 @@ def is_not_abstract(cls): class PolymorphicModel(BaseModel): - class Config(BaseConfig): - # value to put into "type" field - type_alias: ClassVar[Optional[str]] = None - # flag to mark alias required. If not required, classpath is used by default - alias_required: ClassVar[bool] = True - # flag to register aliaes for grand-parent base type - # eg PolymorphicModel -> A -> B -> C, where A and B are base types. only if A has this flag, C can be parsed as both A and B. - transitive_aliases: ClassVar[bool] = False - # flag to mark type as base. This means it will be possible to parse all subclasses of it as this type - is_base_type: ClassVar[bool] = False - - __config__: ClassVar[Type[Config]] = Config + model_config = ConfigDict(arbitrary_types_allowed=True) + + # Configuration values + __type_alias__: ClassVar[Optional[str]] = None + __alias_required__: ClassVar[bool] = True + # __transitive_aliases__: ClassVar[bool] = False + __is_base_type__: ClassVar[bool] = False + + type: str = Field(default="") @classmethod def __get_type__(cls): - config = cls.__dict__.get("Config") - if config is not None and config.__dict__.get("type_alias") is not None: - return config.type_alias - if cls.__config__.alias_required and is_not_abstract(cls): + if cls.__type_alias__ is not None: + return cls.__type_alias__ + if cls.__alias_required__ and is_not_abstract(cls): raise ValueError(f"Alias is required for {cls.__name__}") return cls.__get_classpath__() @@ -220,66 +219,88 @@ def __get_type__(cls): def __get_classpath__(cls): return get_classpath(cls) - type: str = Field("") + @classmethod + def __subtypes__(cls) -> Tuple[Type["PolymorphicModel"], ...]: + return tuple(all_subclasses(cls)) + + @classmethod + def __get_is_base_type__(cls) -> bool: + return cls.__dict__.get("__is_base_type__", False) def __init_subclass__(cls): super().__init_subclass__() - if cls == PolymorphicModel: + if cls == PolymorphicModel or cls.__get_is_base_type__(): return typename = cls.__get_type__() literal_typename = Literal[typename] - type_field = cls.__fields__["type"] + type_field = cls.model_fields["type"] type_field.default = typename - type_field.field_info.default = typename - type_field.type_ = type_field.outer_type_ = literal_typename + type_field.annotation = literal_typename base_class = get_base_class(cls) if (base_class, typename) not in LOADED_TYPE_ALIASES: register_loaded_alias(base_class, cls, typename) if base_class != cls: - base_typefield = base_class.__fields__["type"] - base_typefield_type = base_typefield.type_ + base_typefield = base_class.model_fields["type"] + base_typefield_type = base_typefield.annotation if is_union_type(base_typefield_type): subclass_literals = get_args(base_typefield_type) + (literal_typename,) else: subclass_literals = (base_typefield_type, literal_typename) - base_typefield.type_ = base_typefield.outer_type_ = Union[subclass_literals] + base_typefield.annotation = Union[subclass_literals] - @classmethod - def __subtypes__(cls: Type[TPM]) -> Tuple[Type["TPM"], ...]: - return tuple(all_subclasses(cls)) - - @classmethod - def __is_base_type__(cls) -> bool: - config = cls.__dict__.get("Config") - if config is not None and config.__dict__.get("is_base_type") is not None: - return config.is_base_type - return False + def __str__(self): + return f"{self.__class__.__name__}[{self.__get_type__()}]({super().__str__()})" @classmethod - def validate(cls: Type[TPM], value: Any) -> TPM: + def model_validate( + cls, + value: Any, + *, + strict: bool | None = None, + from_attributes: bool | None = None, + context: Any | None = None, + ) -> Self: if isinstance(value, dict) and "type" in value: typename = value.pop("type") - key = (get_base_class(cls), typename) # type: ignore[arg-type] - if key in LOADED_TYPE_ALIASES: - subcls = LOADED_TYPE_ALIASES[key] - else: - if key in TYPE_ALIASES: - classpath = TYPE_ALIASES[key] + try: + key = (get_base_class(cls), typename) + + if key in LOADED_TYPE_ALIASES: + subcls = LOADED_TYPE_ALIASES[key] else: - if "." not in typename: - raise ValueError(f'Unknown alias "{typename}"') - classpath = typename - if not any(classpath.startswith(p) for p in ALLOWED_TYPE_PREFIXES): - raise ValueError(f"{classpath} does not match any allowed prefixes") - try: - subcls = import_string(classpath) - except ImportError as e: - raise ValueError(f"Error importing subclass from '{classpath}'") from e - return subcls.validate(value) # type: ignore[return-value] - return super().validate(value) # type: ignore[misc] + if key in TYPE_ALIASES: + classpath = TYPE_ALIASES[key] + else: + if "." not in typename: + raise PydanticCustomError("unknown_alias", f'Unknown alias "{typename}"') + classpath = typename + if not any(classpath.startswith(p) for p in ALLOWED_TYPE_PREFIXES): + raise PydanticCustomError("invalid_prefix", f"{classpath} does not match any allowed prefixes") + try: + subcls = import_string(classpath) + except ImportError as e: + raise PydanticCustomError("import_error", f"Error importing subclass from '{classpath}'") from e + return subcls.model_validate( + value, strict=strict, from_attributes=from_attributes, context=context + ) # Pydantic v2 uses model_validate + finally: + value["type"] = typename + return super().model_validate(obj=value, strict=strict, from_attributes=from_attributes, context=context) + + @model_validator(mode="wrap") + def _delegate_validation(cls, data: dict, handler) -> Any: + if "type" in data and data["type"] != cls.__get_type__(): + return cls.model_validate(data) + return handler(data) + + @model_serializer(mode="wrap") + def _delegate_serialization(self, nxt: SerializerFunctionWrapHandler): + if f"serializer={self.__class__.__name__}" not in str(nxt): + return self.model_dump() + return nxt(self) def get_value_fingerprint(value: Any) -> FingerprintPart: @@ -310,6 +331,8 @@ def get_value_fingerprint(value: Any) -> FingerprintPart: EBM = TypeVar("EBM", bound="EvidentlyBaseModel") +print(__file__) + class EvidentlyBaseModel(FrozenBaseModel, PolymorphicModel): class Config: diff --git a/src/evidently/suite/base_suite.py b/src/evidently/suite/base_suite.py index 4ef869d426..623c4f9744 100644 --- a/src/evidently/suite/base_suite.py +++ b/src/evidently/suite/base_suite.py @@ -16,10 +16,10 @@ from typing import Union import ujson +from pydantic import BaseModel +from pydantic import parse_obj_as import evidently -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import ErrorResult from evidently.base_metric import GenericInputData from evidently.base_metric import Metric diff --git a/src/evidently/ui/api/models.py b/src/evidently/ui/api/models.py index 74fd7a255f..f9f6b84427 100644 --- a/src/evidently/ui/api/models.py +++ b/src/evidently/ui/api/models.py @@ -6,8 +6,9 @@ from typing import Optional from typing import TypeVar -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import Extra +from pydantic import BaseModel +from pydantic import Extra + from evidently.base_metric import Metric from evidently.model.dashboard import DashboardInfo from evidently.model.widget import BaseWidgetInfo diff --git a/src/evidently/ui/app.py b/src/evidently/ui/app.py index 4a6ce949ad..bc70f74955 100644 --- a/src/evidently/ui/app.py +++ b/src/evidently/ui/app.py @@ -1,8 +1,8 @@ import os import uvicorn +from pydantic import SecretStr -from evidently._pydantic_compat import SecretStr from evidently.ui.components.base import AppBuilder from evidently.ui.components.storage import LocalStorageComponent from evidently.ui.config import AppConfig diff --git a/src/evidently/ui/base.py b/src/evidently/ui/base.py index bb6c0139cd..29911bb144 100644 --- a/src/evidently/ui/base.py +++ b/src/evidently/ui/base.py @@ -18,11 +18,11 @@ from typing import Union import uuid6 +from pydantic import BaseModel +from pydantic import Field +from pydantic import PrivateAttr +from pydantic import parse_obj_as -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import PrivateAttr -from evidently._pydantic_compat import parse_obj_as from evidently.core import new_id from evidently.future.report import Snapshot as SnapshotV2 from evidently.model.dashboard import DashboardInfo diff --git a/src/evidently/ui/components/base.py b/src/evidently/ui/components/base.py index ba0dd54905..854decf81f 100644 --- a/src/evidently/ui/components/base.py +++ b/src/evidently/ui/components/base.py @@ -15,8 +15,8 @@ from litestar.types import ControllerRouterHandler from litestar.types import ExceptionHandlersMap from litestar.types import Middleware +from pydantic import Extra -from evidently._pydantic_compat import Extra from evidently.pydantic_utils import PolymorphicModel from evidently.ui.utils import parse_json diff --git a/src/evidently/ui/components/security.py b/src/evidently/ui/components/security.py index 54b67b9eca..cf0bc6d764 100644 --- a/src/evidently/ui/components/security.py +++ b/src/evidently/ui/components/security.py @@ -11,8 +11,8 @@ from litestar.types import Receive from litestar.types import Scope from litestar.types import Send +from pydantic import SecretStr -from evidently._pydantic_compat import SecretStr from evidently.pydantic_utils import register_type_alias from evidently.ui.components.base import Component from evidently.ui.components.base import ComponentContext diff --git a/src/evidently/ui/config.py b/src/evidently/ui/config.py index f63f6695a8..43a2a01d89 100644 --- a/src/evidently/ui/config.py +++ b/src/evidently/ui/config.py @@ -10,10 +10,10 @@ from dynaconf.utils.boxing import DynaBox from litestar import Litestar from litestar.di import Provide +from pydantic import BaseModel +from pydantic import PrivateAttr +from pydantic import parse_obj_as -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import PrivateAttr -from evidently._pydantic_compat import parse_obj_as from evidently.ui.components.base import SECTION_COMPONENT_TYPE_MAPPING from evidently.ui.components.base import AppBuilder from evidently.ui.components.base import Component diff --git a/src/evidently/ui/dashboards/base.py b/src/evidently/ui/dashboards/base.py index bbc7e1a1c8..26e5df9eb3 100644 --- a/src/evidently/ui/dashboards/base.py +++ b/src/evidently/ui/dashboards/base.py @@ -10,10 +10,10 @@ from typing import Union import uuid6 +from pydantic import BaseModel +from pydantic import Field +from pydantic import validator -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import validator from evidently.base_metric import Metric from evidently.core import new_id from evidently.model.dashboard import DashboardInfo diff --git a/src/evidently/ui/dashboards/test_suites.py b/src/evidently/ui/dashboards/test_suites.py index a1b3eee0ab..54ca88ad57 100644 --- a/src/evidently/ui/dashboards/test_suites.py +++ b/src/evidently/ui/dashboards/test_suites.py @@ -12,8 +12,8 @@ import pandas as pd from plotly import graph_objs as go +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.model.widget import BaseWidgetInfo from evidently.pydantic_utils import EvidentlyBaseModel from evidently.pydantic_utils import autoregister diff --git a/src/evidently/ui/dashboards/utils.py b/src/evidently/ui/dashboards/utils.py index b8eaec7a82..ad123fcaf5 100644 --- a/src/evidently/ui/dashboards/utils.py +++ b/src/evidently/ui/dashboards/utils.py @@ -11,8 +11,8 @@ from typing import Union import plotly.io as pio +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.base_metric import ColumnName from evidently.base_metric import Metric from evidently.pydantic_utils import EvidentlyBaseModel diff --git a/src/evidently/ui/managers/auth.py b/src/evidently/ui/managers/auth.py index 81d43f04e4..03940c1dc6 100644 --- a/src/evidently/ui/managers/auth.py +++ b/src/evidently/ui/managers/auth.py @@ -8,7 +8,8 @@ from typing import Set from typing import Tuple -from evidently._pydantic_compat import BaseModel +from pydantic import BaseModel + from evidently.ui.base import EntityType from evidently.ui.base import Org from evidently.ui.base import Team diff --git a/src/evidently/ui/managers/projects.py b/src/evidently/ui/managers/projects.py index 2d4e9c4817..da5a351d74 100644 --- a/src/evidently/ui/managers/projects.py +++ b/src/evidently/ui/managers/projects.py @@ -5,9 +5,9 @@ from typing import Union from litestar.params import Dependency +from pydantic import parse_obj_as from typing_extensions import Annotated -from evidently._pydantic_compat import parse_obj_as from evidently.suite.base_suite import Snapshot from evidently.ui.base import BlobStorage from evidently.ui.base import DataStorage diff --git a/src/evidently/ui/storage/local/base.py b/src/evidently/ui/storage/local/base.py index 546e4f405c..46da1a1051 100644 --- a/src/evidently/ui/storage/local/base.py +++ b/src/evidently/ui/storage/local/base.py @@ -12,10 +12,10 @@ import uuid6 from fsspec import AbstractFileSystem from fsspec import get_fs_token_paths +from pydantic import PrivateAttr +from pydantic import ValidationError +from pydantic import parse_obj_as -from evidently._pydantic_compat import PrivateAttr -from evidently._pydantic_compat import ValidationError -from evidently._pydantic_compat import parse_obj_as from evidently.suite.base_suite import Snapshot from evidently.test_suite import TestSuite from evidently.tests.base_test import Test diff --git a/src/evidently/ui/storage/utils.py b/src/evidently/ui/storage/utils.py index 5b6f45d1ac..5f50af2cd3 100644 --- a/src/evidently/ui/storage/utils.py +++ b/src/evidently/ui/storage/utils.py @@ -6,7 +6,8 @@ from typing import Optional from typing import Tuple -from evidently._pydantic_compat import BaseModel +from pydantic import BaseModel + from evidently.base_metric import MetricResult from evidently.core import BaseResult from evidently.utils import NumpyEncoder diff --git a/src/evidently/ui/utils.py b/src/evidently/ui/utils.py index 3f9acc230f..7bcb1f4ae3 100644 --- a/src/evidently/ui/utils.py +++ b/src/evidently/ui/utils.py @@ -7,9 +7,9 @@ from typing import Union import requests +from pydantic import BaseModel +from pydantic import parse_obj_as -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import parse_obj_as from evidently.ui.storage.common import SECRET_HEADER_NAME from evidently.utils import NumpyEncoder diff --git a/src/evidently/ui/workspace/cloud.py b/src/evidently/ui/workspace/cloud.py index 1cfdc79ceb..70531379cb 100644 --- a/src/evidently/ui/workspace/cloud.py +++ b/src/evidently/ui/workspace/cloud.py @@ -13,10 +13,10 @@ from typing import overload import pandas as pd +from pydantic import parse_obj_as from requests import HTTPError from requests import Response -from evidently._pydantic_compat import parse_obj_as from evidently.future.datasets import DataDefinition from evidently.future.datasets import Dataset from evidently.pipeline.column_mapping import ColumnMapping diff --git a/src/evidently/ui/workspace/remote.py b/src/evidently/ui/workspace/remote.py index 334bb20753..c192716239 100644 --- a/src/evidently/ui/workspace/remote.py +++ b/src/evidently/ui/workspace/remote.py @@ -15,11 +15,11 @@ from typing import overload from urllib.error import HTTPError +from pydantic import parse_obj_as from requests import Request from requests import Response from requests import Session -from evidently._pydantic_compat import parse_obj_as from evidently.errors import EvidentlyError from evidently.suite.base_suite import Snapshot from evidently.ui.api.service import EVIDENTLY_APPLICATION_NAME diff --git a/src/evidently/utils/data_preprocessing.py b/src/evidently/utils/data_preprocessing.py index e7e7b0baaf..5416688660 100644 --- a/src/evidently/utils/data_preprocessing.py +++ b/src/evidently/utils/data_preprocessing.py @@ -11,8 +11,8 @@ import numpy as np import pandas as pd +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.core import ColumnType from evidently.pipeline.column_mapping import ColumnMapping from evidently.pipeline.column_mapping import RecomType diff --git a/src/evidently/utils/llm/wrapper.py b/src/evidently/utils/llm/wrapper.py index 8f27f51409..5e0b1129bf 100644 --- a/src/evidently/utils/llm/wrapper.py +++ b/src/evidently/utils/llm/wrapper.py @@ -19,8 +19,9 @@ from typing import Type from typing import TypeVar -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import SecretStr +from pydantic import BaseModel +from pydantic import SecretStr + from evidently.options.base import Options from evidently.options.option import Option from evidently.utils.llm.base import LLMMessage diff --git a/tests/collector/test_app.py b/tests/collector/test_app.py index e01d263956..ee9497421b 100644 --- a/tests/collector/test_app.py +++ b/tests/collector/test_app.py @@ -5,8 +5,8 @@ import pandas as pd import pytest from litestar.testing import TestClient +from pydantic import parse_obj_as -from evidently._pydantic_compat import parse_obj_as from evidently.collector.app import check_snapshots_factory from evidently.collector.config import CollectorConfig from evidently.collector.config import CollectorServiceConfig diff --git a/tests/collector/test_config.py b/tests/collector/test_config.py index 668ddd92fb..5fbe8486b8 100644 --- a/tests/collector/test_config.py +++ b/tests/collector/test_config.py @@ -3,8 +3,8 @@ from unittest.mock import Mock import pytest +from pydantic import ValidationError -from evidently._pydantic_compat import ValidationError from evidently.collector.config import IntervalTrigger from evidently.collector.config import RowsCountOrIntervalTrigger from evidently.collector.config import RowsCountTrigger diff --git a/tests/conftest.py b/tests/conftest.py index 69752e4451..70e990e517 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,8 +1,8 @@ import numpy as np import pandas as pd import pytest +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.pydantic_utils import PolymorphicModel from evidently.utils.types import ApproxValue diff --git a/tests/features/test_multicolumn.py b/tests/features/test_multicolumn.py index 7736532f90..f10d65eddf 100644 --- a/tests/features/test_multicolumn.py +++ b/tests/features/test_multicolumn.py @@ -2,8 +2,8 @@ from typing import Optional import pandas as pd +from pydantic import PrivateAttr -from evidently._pydantic_compat import PrivateAttr from evidently.base_metric import ColumnName from evidently.core import ColumnType from evidently.features.feature_generator import FeatureGenerator diff --git a/tests/metrics/data_quality/test_column_value_list_metric.py b/tests/metrics/data_quality/test_column_value_list_metric.py index 0d8872bf65..23414b5fa4 100644 --- a/tests/metrics/data_quality/test_column_value_list_metric.py +++ b/tests/metrics/data_quality/test_column_value_list_metric.py @@ -4,8 +4,8 @@ import numpy as np import pandas as pd import pytest +from pydantic import parse_obj_as -from evidently._pydantic_compat import parse_obj_as from evidently.metrics import ColumnValueListMetric from evidently.metrics.data_quality.column_value_list_metric import ColumnValueListMetricResult from evidently.metrics.data_quality.column_value_list_metric import ValueListStat diff --git a/tests/metrics/recsys/test_precision_top_k.py b/tests/metrics/recsys/test_precision_top_k.py index 074a73888b..d9202eb1af 100644 --- a/tests/metrics/recsys/test_precision_top_k.py +++ b/tests/metrics/recsys/test_precision_top_k.py @@ -2,8 +2,8 @@ import numpy as np import pandas as pd +from pydantic import parse_obj_as -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import MetricResult from evidently.metrics import PrecisionTopKMetric from evidently.metrics.recsys.base_top_k import TopKMetricResult diff --git a/tests/multitest/conftest.py b/tests/multitest/conftest.py index d7d5fdabfb..60b3a478c0 100644 --- a/tests/multitest/conftest.py +++ b/tests/multitest/conftest.py @@ -12,8 +12,9 @@ from typing import TypeVar from typing import Union +from pydantic import BaseModel + import evidently -from evidently._pydantic_compat import BaseModel from evidently.base_metric import Metric from evidently.base_metric import MetricResult from evidently.pydantic_utils import PolymorphicModel diff --git a/tests/test_metric_results.py b/tests/test_metric_results.py index fb9e79eca1..29b2db0611 100644 --- a/tests/test_metric_results.py +++ b/tests/test_metric_results.py @@ -8,11 +8,11 @@ from typing import Type import pytest +from pydantic import BaseModel +from pydantic import Field +from pydantic import parse_obj_as import evidently -from evidently._pydantic_compat import BaseModel -from evidently._pydantic_compat import Field -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import MetricResult from evidently.tests.base_test import EnumValueMixin diff --git a/tests/test_pydantic_aliases.py b/tests/test_pydantic_aliases.py index d6130f3514..e2e88989e2 100644 --- a/tests/test_pydantic_aliases.py +++ b/tests/test_pydantic_aliases.py @@ -9,9 +9,9 @@ from typing import TypeVar import pytest +from pydantic import import_string import evidently -from evidently._pydantic_compat import import_string from evidently.base_metric import BasePreset from evidently.base_metric import ColumnName from evidently.base_metric import Metric diff --git a/tests/ui/conftest.py b/tests/ui/conftest.py index 7265889b0f..3a5c31da5d 100644 --- a/tests/ui/conftest.py +++ b/tests/ui/conftest.py @@ -7,8 +7,8 @@ from litestar import get from litestar.datastructures import State from litestar.testing import TestClient +from pydantic import BaseModel -from evidently._pydantic_compat import BaseModel from evidently.ui.app import create_app from evidently.ui.base import Project from evidently.ui.components.base import Component diff --git a/tests/ui/test_app.py b/tests/ui/test_app.py index ea931f54f4..12e25e62db 100644 --- a/tests/ui/test_app.py +++ b/tests/ui/test_app.py @@ -7,9 +7,9 @@ import pytest from litestar.testing import TestClient +from pydantic import parse_obj_as import evidently -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import InputData from evidently.base_metric import Metric from evidently.base_metric import MetricResult diff --git a/tests/ui/test_dashboards.py b/tests/ui/test_dashboards.py index 6942cef4a5..c462bcc8ec 100644 --- a/tests/ui/test_dashboards.py +++ b/tests/ui/test_dashboards.py @@ -2,8 +2,8 @@ from typing import Dict import pytest +from pydantic import parse_obj_as -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import ColumnName from evidently.base_metric import InputData from evidently.base_metric import Metric diff --git a/tests/utils/test_pydantic_utils.py b/tests/utils/test_pydantic_utils.py index 341fd5fac8..6a6308ae5f 100644 --- a/tests/utils/test_pydantic_utils.py +++ b/tests/utils/test_pydantic_utils.py @@ -4,9 +4,9 @@ from typing import Union import pytest +from pydantic import ValidationError +from pydantic import parse_obj_as -from evidently._pydantic_compat import ValidationError -from evidently._pydantic_compat import parse_obj_as from evidently.base_metric import Metric from evidently.base_metric import MetricResult from evidently.core import IncludeTags From 76d8cc1b687190312d39780a31d2bda04dd0bd6e Mon Sep 17 00:00:00 2001 From: mike0sv Date: Mon, 17 Mar 2025 18:12:53 +0000 Subject: [PATCH 2/2] change config fields to class fields --- src/evidently/base_metric.py | 33 ++-- src/evidently/calculations/data_drift.py | 42 ++--- src/evidently/collector/config.py | 16 +- src/evidently/collector/storage.py | 9 +- src/evidently/core.py | 16 +- .../descriptors/BERTScore_descriptor.py | 5 +- .../descriptors/contains_link_descriptor.py | 5 +- .../descriptors/custom_descriptor.py | 7 +- .../descriptors/exact_match_descriptor.py | 5 +- src/evidently/descriptors/hf_descriptor.py | 7 +- .../descriptors/is_valid_json_descriptor.py | 5 +- .../descriptors/is_valid_python_descriptor.py | 5 +- .../descriptors/is_valid_sql_descriptor.py | 5 +- .../descriptors/json_match_descriptor.py | 5 +- .../json_schema_match_descriptor.py | 4 +- src/evidently/descriptors/llm_judges.py | 33 ++-- ..._letter_character_percentage_descriptor.py | 5 +- .../oov_words_percentage_descriptor.py | 4 +- .../descriptors/openai_descriptor.py | 4 +- .../descriptors/regexp_descriptor.py | 5 +- .../descriptors/semantic_similarity.py | 5 +- .../descriptors/sentence_count_descriptor.py | 5 +- .../descriptors/sentiment_descriptor.py | 5 +- .../descriptors/text_contains_descriptor.py | 13 +- .../descriptors/text_length_descriptor.py | 5 +- .../descriptors/text_part_descriptor.py | 8 +- .../trigger_words_presence_descriptor.py | 4 +- .../descriptors/word_count_descriptor.py | 5 +- src/evidently/descriptors/words_descriptor.py | 13 +- src/evidently/features/BERTScore_feature.py | 3 +- .../features/OOV_words_percentage_feature.py | 3 +- .../features/contains_link_feature.py | 3 +- src/evidently/features/custom_feature.py | 10 +- src/evidently/features/exact_match_feature.py | 3 +- src/evidently/features/generated_features.py | 19 +- src/evidently/features/hf_feature.py | 6 +- .../features/is_valid_json_feature.py | 3 +- .../features/is_valid_python_feature.py | 3 +- .../features/is_valid_sql_feature.py | 3 +- src/evidently/features/json_match_feature.py | 4 +- .../features/json_schema_match_feature.py | 3 +- src/evidently/features/llm_judge.py | 9 +- ...non_letter_character_percentage_feature.py | 3 +- src/evidently/features/openai_feature.py | 4 +- src/evidently/features/regexp_feature.py | 3 +- .../features/semantic_similarity_feature.py | 3 +- .../features/sentence_count_feature.py | 3 +- src/evidently/features/sentiment_feature.py | 3 +- .../features/text_contains_feature.py | 12 +- src/evidently/features/text_length_feature.py | 3 +- src/evidently/features/text_part_feature.py | 6 +- .../trigger_words_presence_feature.py | 3 +- src/evidently/features/word_count_feature.py | 3 +- src/evidently/features/words_feature.py | 18 +- src/evidently/future/backport.py | 43 ++--- src/evidently/future/metric_types.py | 11 +- .../future/metrics/column_statistics.py | 4 +- .../classification_performance.py | 4 +- src/evidently/metric_preset/data_drift.py | 4 +- src/evidently/metric_preset/data_quality.py | 4 +- src/evidently/metric_preset/metric_preset.py | 4 +- src/evidently/metric_preset/recsys.py | 4 +- .../metric_preset/regression_performance.py | 4 +- src/evidently/metric_preset/target_drift.py | 4 +- src/evidently/metric_preset/text_evals.py | 4 +- src/evidently/metric_results.py | 173 ++++++++---------- .../class_balance_metric.py | 11 +- .../class_separation_metric.py | 21 +-- .../classification_dummy_metric.py | 14 +- .../classification_quality_metric.py | 17 +- .../confusion_matrix_metric.py | 19 +- .../lift_curve_metric.py | 15 +- .../lift_table_metric.py | 19 +- .../classification_performance/objects.py | 9 +- .../pr_curve_metric.py | 15 +- .../pr_table_metric.py | 11 +- .../probability_distribution_metric.py | 19 +- .../quality_by_class_metric.py | 24 ++- .../quality_by_feature_table.py | 19 +- .../roc_curve_metric.py | 15 +- src/evidently/metrics/custom_metric.py | 7 +- .../metrics/data_drift/column_drift_metric.py | 4 +- .../data_drift/column_interaction_plot.py | 33 ++-- .../metrics/data_drift/column_value_plot.py | 15 +- .../metrics/data_drift/data_drift_table.py | 17 +- .../data_drift/dataset_drift_metric.py | 7 +- .../data_drift/embedding_drift_methods.py | 16 +- .../metrics/data_drift/embeddings_drift.py | 25 +-- .../metrics/data_drift/feature_importance.py | 9 +- .../data_drift/target_by_features_table.py | 23 ++- .../text_descriptors_drift_metric.py | 7 +- .../text_domain_classifier_drift_metric.py | 20 +- .../metrics/data_drift/text_metric.py | 11 +- .../column_missing_values_metric.py | 23 +-- .../data_integrity/column_regexp_metric.py | 37 ++-- .../data_integrity/column_summary_metric.py | 58 +++--- .../dataset_missing_values_metric.py | 48 +++-- .../data_integrity/dataset_summary_metric.py | 43 ++--- .../data_quality/column_category_metric.py | 33 ++-- .../column_correlations_metric.py | 17 +- .../column_distribution_metric.py | 17 +- .../data_quality/column_quantile_metric.py | 20 +- .../data_quality/column_value_list_metric.py | 32 ++-- .../data_quality/column_value_range_metric.py | 26 ++- .../conflict_prediction_metric.py | 12 +- .../data_quality/conflict_target_metric.py | 19 +- .../dataset_correlations_metric.py | 48 +++-- .../metrics/data_quality/stability_metric.py | 7 +- .../text_descriptors_correlation_metric.py | 19 +- .../text_descriptors_distribution.py | 19 +- src/evidently/metrics/recsys/base_top_k.py | 14 +- src/evidently/metrics/recsys/diversity.py | 21 +-- src/evidently/metrics/recsys/f_beta_top_k.py | 4 +- src/evidently/metrics/recsys/hit_rate_k.py | 17 +- src/evidently/metrics/recsys/item_bias.py | 23 ++- src/evidently/metrics/recsys/map_k.py | 5 +- src/evidently/metrics/recsys/mar_k.py | 5 +- src/evidently/metrics/recsys/mrr.py | 17 +- src/evidently/metrics/recsys/ndcg_k.py | 4 +- src/evidently/metrics/recsys/novelty.py | 21 +-- .../metrics/recsys/pairwise_distance.py | 11 +- .../metrics/recsys/personalisation.py | 24 ++- .../metrics/recsys/popularity_bias.py | 31 ++-- .../metrics/recsys/precision_recall_k.py | 11 +- .../metrics/recsys/precision_top_k.py | 5 +- src/evidently/metrics/recsys/rec_examples.py | 23 ++- src/evidently/metrics/recsys/recall_top_k.py | 5 +- .../metrics/recsys/scores_distribution.py | 25 ++- src/evidently/metrics/recsys/serendipity.py | 21 +-- src/evidently/metrics/recsys/train_stats.py | 19 +- src/evidently/metrics/recsys/user_bias.py | 21 +-- .../abs_perc_error_in_time.py | 4 +- .../error_bias_table.py | 45 +++-- .../error_distribution.py | 14 +- .../regression_performance/error_in_time.py | 4 +- .../regression_performance/error_normality.py | 29 +-- .../metrics/regression_performance/objects.py | 22 +-- .../predicted_and_actual_in_time.py | 4 +- .../predicted_vs_actual.py | 20 +- .../regression_dummy_metric.py | 7 +- .../regression_performance_metrics.py | 54 +++--- .../regression_quality.py | 46 ++--- .../regression_performance/top_error.py | 21 +-- src/evidently/pydantic_utils.py | 16 +- .../test_preset/classification_binary.py | 4 +- .../test_preset/classification_binary_topk.py | 4 +- .../test_preset/classification_multiclass.py | 4 +- src/evidently/test_preset/data_drift.py | 4 +- src/evidently/test_preset/data_quality.py | 4 +- src/evidently/test_preset/data_stability.py | 4 +- .../test_preset/no_target_performance.py | 4 +- src/evidently/test_preset/recsys.py | 4 +- src/evidently/test_preset/regression.py | 4 +- src/evidently/test_preset/test_preset.py | 4 +- src/evidently/tests/base_test.py | 38 ++-- .../tests/classification_performance_tests.py | 42 ++--- src/evidently/tests/custom_test.py | 3 +- src/evidently/tests/data_drift_tests.py | 18 +- src/evidently/tests/data_integrity_tests.py | 66 +++---- src/evidently/tests/data_quality_tests.py | 87 +++------ src/evidently/tests/recsys_tests.py | 48 ++--- .../tests/regression_performance_tests.py | 18 +- src/evidently/ui/api/models.py | 4 +- src/evidently/ui/base.py | 3 +- src/evidently/ui/components/base.py | 7 +- src/evidently/ui/components/local_storage.py | 9 +- src/evidently/ui/components/security.py | 9 +- src/evidently/ui/components/storage.py | 12 +- src/evidently/ui/dashboards/base.py | 6 +- src/evidently/ui/dashboards/reports.py | 10 +- src/evidently/ui/dashboards/test_suites.py | 7 +- src/evidently/utils/llm/prompts.py | 27 +-- src/evidently/utils/llm/wrapper.py | 3 +- src/evidently/utils/types.py | 3 +- 174 files changed, 1156 insertions(+), 1499 deletions(-) diff --git a/src/evidently/base_metric.py b/src/evidently/base_metric.py index c9cd7def95..1cddb9bae6 100644 --- a/src/evidently/base_metric.py +++ b/src/evidently/base_metric.py @@ -50,16 +50,14 @@ def fields(cls) -> FieldPath: class MetricResult(PolymorphicModel, BaseResult, metaclass=WithFieldsPathMetaclass): # type: ignore[misc] # pydantic Config - class Config: - type_alias = "evidently:metric_result:MetricResult" - field_tags = {"type": {IncludeTags.TypeField}} - is_base_type = True - alias_required = True + __type_alias__: ClassVar = "evidently:metric_result:MetricResult" + __field_tags__: ClassVar = {"type": {IncludeTags.TypeField}} + __is_base_type__: ClassVar = True + __alias_required__: ClassVar = True class ErrorResult(BaseResult): - class Config: - underscore_attrs_are_private = True + __underscore_attrs_are_private__: ClassVar = True _exception: Optional[BaseException] = None # todo: fix serialization of exceptions @@ -82,8 +80,7 @@ class DatasetType(Enum): @autoregister class ColumnName(EnumValueMixin, EvidentlyBaseModel): - class Config: - type_alias = "evidently:base:ColumnName" + __type_alias__: ClassVar = "evidently:base:ColumnName" name: str display_name: DisplayName @@ -232,15 +229,13 @@ def result_type(cls) -> Type[MetricResult]: class BasePreset(EvidentlyBaseModel): - class Config: - type_alias = "evidently:base:BasePreset" - transitive_aliases = True - is_base_type = True + __type_alias__: ClassVar = "evidently:base:BasePreset" + __transitive_aliases__: ClassVar = True + __is_base_type__: ClassVar = True class Metric(WithTestAndMetricDependencies, Generic[TResult], metaclass=WithResultFieldPathMetaclass): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True _context: Optional["Context"] = None @@ -330,12 +325,8 @@ def get_options_fingerprint(self) -> FingerprintPart: class ColumnMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnMetricResult" - field_tags = { - "column_name": {IncludeTags.Parameter}, - "column_type": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnMetricResult" + __field_tags__: ClassVar = {"column_name": {IncludeTags.Parameter}, "column_type": {IncludeTags.Parameter}} column_name: str # todo: use enum diff --git a/src/evidently/calculations/data_drift.py b/src/evidently/calculations/data_drift.py index c59318d40a..226b840500 100644 --- a/src/evidently/calculations/data_drift.py +++ b/src/evidently/calculations/data_drift.py @@ -1,6 +1,7 @@ """Methods and types for data drift calculations.""" from dataclasses import dataclass +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -34,17 +35,15 @@ class DriftStatsField(MetricResult): - class Config: - type_alias = "evidently:metric_result:DriftStatsField" - dict_exclude_fields = {"characteristic_examples", "characteristic_words", "correlations"} - # todo: after tests PR - field_tags = { - "characteristic_examples": {IncludeTags.Render}, - "characteristic_words": {IncludeTags.Render}, - "correlations": {IncludeTags.Render}, - "small_distribution": {IncludeTags.Extra}, - } - pd_include = False + __type_alias__: ClassVar = "evidently:metric_result:DriftStatsField" + __dict_exclude_fields__: ClassVar = {"characteristic_examples", "characteristic_words", "correlations"} + __field_tags__: ClassVar = { + "characteristic_examples": {IncludeTags.Render}, + "characteristic_words": {IncludeTags.Render}, + "correlations": {IncludeTags.Render}, + "small_distribution": {IncludeTags.Extra}, + } + __pd_include__: ClassVar = False distribution: Optional[Distribution] characteristic_examples: Optional[Examples] @@ -54,16 +53,14 @@ class Config: class ColumnDataDriftMetrics(ColumnMetricResult): - class Config: - # todo: change to field_tags: render - type_alias = "evidently:metric_result:ColumnDataDriftMetrics" - dict_exclude_fields = {"scatter"} - pd_exclude_fields = {"scatter"} - field_tags = { - "stattest_name": {IncludeTags.Parameter}, - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnDataDriftMetrics" + __dict_exclude_fields__: ClassVar = {"scatter"} + __pd_exclude_fields__: ClassVar = {"scatter"} + __field_tags__: ClassVar = { + "stattest_name": {IncludeTags.Parameter}, + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + } stattest_name: str stattest_threshold: Optional[float] @@ -87,8 +84,7 @@ class DatasetDrift: class DatasetDriftMetrics(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetDriftMetrics" + __type_alias__: ClassVar = "evidently:metric_result:DatasetDriftMetrics" number_of_columns: int number_of_drifted_columns: int diff --git a/src/evidently/collector/config.py b/src/evidently/collector/config.py index 0348586389..291a298865 100644 --- a/src/evidently/collector/config.py +++ b/src/evidently/collector/config.py @@ -3,6 +3,7 @@ import time import warnings from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -43,8 +44,7 @@ def save(self, path: str): class CollectorTrigger(PolymorphicModel): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True @abc.abstractmethod def is_ready(self, config: "CollectorConfig", storage: "CollectorStorage") -> bool: @@ -53,8 +53,7 @@ def is_ready(self, config: "CollectorConfig", storage: "CollectorStorage") -> bo @autoregister class IntervalTrigger(CollectorTrigger): - class Config: - type_alias = "evidently:collector_trigger:IntervalTrigger" + __type_alias__: ClassVar = "evidently:collector_trigger:IntervalTrigger" interval: float = Field(gt=0) last_triggered: float = 0 @@ -69,8 +68,7 @@ def is_ready(self, config: "CollectorConfig", storage: "CollectorStorage") -> bo @autoregister class RowsCountTrigger(CollectorTrigger): - class Config: - type_alias = "evidently:collector_trigger:RowsCountTrigger" + __type_alias__: ClassVar = "evidently:collector_trigger:RowsCountTrigger" rows_count: int = Field(default=1, gt=0) @@ -81,8 +79,7 @@ def is_ready(self, config: "CollectorConfig", storage: "CollectorStorage") -> bo @autoregister class RowsCountOrIntervalTrigger(CollectorTrigger): - class Config: - type_alias = "evidently:collector_trigger:RowsCountOrIntervalTrigger" + __type_alias__: ClassVar = "evidently:collector_trigger:RowsCountOrIntervalTrigger" rows_count_trigger: RowsCountTrigger interval_trigger: IntervalTrigger @@ -135,8 +132,7 @@ def to_report_base(self) -> Union[TestSuite, Report]: class CollectorConfig(Config): - class Config: - underscore_attrs_are_private = True + __underscore_attrs_are_private__: ClassVar = True id: str = "" trigger: CollectorTrigger diff --git a/src/evidently/collector/storage.py b/src/evidently/collector/storage.py index 9b5bd96237..0d00d66414 100644 --- a/src/evidently/collector/storage.py +++ b/src/evidently/collector/storage.py @@ -1,6 +1,7 @@ import abc from asyncio import Lock from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Sequence @@ -42,9 +43,8 @@ def __exit__(self, exc_type, exc_val, exc_tb): class CollectorStorage(PolymorphicModel): - class Config: - underscore_attrs_are_private = True - is_base_type = True + __underscore_attrs_are_private__: ClassVar = True + __is_base_type__: ClassVar = True _locks: Dict[str, Lock] = {} @@ -89,8 +89,7 @@ def take_reports(self, id: str) -> Sequence[ReportPopper]: @autoregister class InMemoryStorage(CollectorStorage): - class Config: - type_alias = "evidently:collector_storage:InMemoryStorage" + __type_alias__: ClassVar = "evidently:collector_storage:InMemoryStorage" max_log_events: int = 10 diff --git a/src/evidently/core.py b/src/evidently/core.py index b3f9e5f535..fba80ab0ba 100644 --- a/src/evidently/core.py +++ b/src/evidently/core.py @@ -15,7 +15,6 @@ import numpy as np import pandas as pd import uuid6 -from pydantic import BaseConfig from pydantic import BaseModel from pydantic_core.core_schema import ModelField from typing_inspect import is_literal_type @@ -90,20 +89,7 @@ def np_array_valudator(value): class BaseResult(BaseModel): - class Config(BaseConfig): - arbitrary_types_allowed = True - dict_include: bool = True - pd_include: bool = True - pd_name_mapping: Dict[str, str] = {} - - dict_include_fields: set = set() - dict_exclude_fields: set = set() - pd_include_fields: set = set() - pd_exclude_fields: set = set() - - tags: Set[IncludeTags] = set() - field_tags: Dict[str, set] = {} - extract_as_obj: bool = False + __arbitrary_types_allowed__: ClassVar = True if TYPE_CHECKING: __config__: ClassVar[Type[Config]] = Config diff --git a/src/evidently/descriptors/BERTScore_descriptor.py b/src/evidently/descriptors/BERTScore_descriptor.py index f10253b636..99700d5812 100644 --- a/src/evidently/descriptors/BERTScore_descriptor.py +++ b/src/evidently/descriptors/BERTScore_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features.BERTScore_feature import BERTScoreFeature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeatures class BERTScore(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:BERTScore" + __type_alias__: ClassVar = "evidently:descriptor:BERTScore" with_column: str diff --git a/src/evidently/descriptors/contains_link_descriptor.py b/src/evidently/descriptors/contains_link_descriptor.py index dfc78f7e6a..22cc66ba6b 100644 --- a/src/evidently/descriptors/contains_link_descriptor.py +++ b/src/evidently/descriptors/contains_link_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import contains_link_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class ContainsLink(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:ContainsLink" + __type_alias__: ClassVar = "evidently:descriptor:ContainsLink" def feature(self, column_name: str) -> GeneratedFeature: return contains_link_feature.ContainsLink(column_name, self.display_name) diff --git a/src/evidently/descriptors/custom_descriptor.py b/src/evidently/descriptors/custom_descriptor.py index 04920b7eb4..4b73f25708 100644 --- a/src/evidently/descriptors/custom_descriptor.py +++ b/src/evidently/descriptors/custom_descriptor.py @@ -1,4 +1,5 @@ from typing import Callable +from typing import ClassVar from typing import Union import pandas as pd @@ -13,8 +14,7 @@ class CustomColumnEval(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:CustomColumnEval" + __type_alias__: ClassVar = "evidently:descriptor:CustomColumnEval" func: Callable[[pd.Series], pd.Series] display_name: str @@ -32,8 +32,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class CustomPairColumnEval(GeneralDescriptor): - class Config: - type_alias = "evidently:descriptor:CustomPairColumnEval" + __type_alias__: ClassVar = "evidently:descriptor:CustomPairColumnEval" func: Callable[[pd.Series, pd.Series], pd.Series] display_name: str diff --git a/src/evidently/descriptors/exact_match_descriptor.py b/src/evidently/descriptors/exact_match_descriptor.py index 7c03cf948f..cca2590c53 100644 --- a/src/evidently/descriptors/exact_match_descriptor.py +++ b/src/evidently/descriptors/exact_match_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features.exact_match_feature import ExactMatchFeature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeatures class ExactMatch(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:ExactMatch" + __type_alias__: ClassVar = "evidently:descriptor:ExactMatch" with_column: str diff --git a/src/evidently/descriptors/hf_descriptor.py b/src/evidently/descriptors/hf_descriptor.py index f0c080a438..d31b5b4b8b 100644 --- a/src/evidently/descriptors/hf_descriptor.py +++ b/src/evidently/descriptors/hf_descriptor.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Optional from evidently.features.generated_features import FeatureDescriptor @@ -7,8 +8,7 @@ class HuggingFaceModel(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:HuggingFaceModel" + __type_alias__: ClassVar = "evidently:descriptor:HuggingFaceModel" model: str params: Optional[dict] = None @@ -23,8 +23,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class HuggingFaceToxicityModel(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:HuggingFaceToxicityModel" + __type_alias__: ClassVar = "evidently:descriptor:HuggingFaceToxicityModel" model: Optional[str] = None toxic_label: Optional[str] = None diff --git a/src/evidently/descriptors/is_valid_json_descriptor.py b/src/evidently/descriptors/is_valid_json_descriptor.py index e09202577c..504100b0e8 100644 --- a/src/evidently/descriptors/is_valid_json_descriptor.py +++ b/src/evidently/descriptors/is_valid_json_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import is_valid_json_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class IsValidJSON(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:IsValidJSON" + __type_alias__: ClassVar = "evidently:descriptor:IsValidJSON" def feature(self, column_name: str) -> GeneratedFeature: return is_valid_json_feature.IsValidJSON(column_name, self.display_name) diff --git a/src/evidently/descriptors/is_valid_python_descriptor.py b/src/evidently/descriptors/is_valid_python_descriptor.py index 48560174d8..a7b0fa9419 100644 --- a/src/evidently/descriptors/is_valid_python_descriptor.py +++ b/src/evidently/descriptors/is_valid_python_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import is_valid_python_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class IsValidPython(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:IsValidPython" + __type_alias__: ClassVar = "evidently:descriptor:IsValidPython" def feature(self, column_name: str) -> GeneratedFeature: return is_valid_python_feature.IsValidPython(column_name, self.display_name) diff --git a/src/evidently/descriptors/is_valid_sql_descriptor.py b/src/evidently/descriptors/is_valid_sql_descriptor.py index bc9715987a..be1d209a16 100644 --- a/src/evidently/descriptors/is_valid_sql_descriptor.py +++ b/src/evidently/descriptors/is_valid_sql_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import is_valid_sql_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class IsValidSQL(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:IsValidSQL" + __type_alias__: ClassVar = "evidently:descriptor:IsValidSQL" def feature(self, column_name: str) -> GeneratedFeature: return is_valid_sql_feature.IsValidSQL(column_name, self.display_name) diff --git a/src/evidently/descriptors/json_match_descriptor.py b/src/evidently/descriptors/json_match_descriptor.py index 3d961d9284..6be6cf3c03 100644 --- a/src/evidently/descriptors/json_match_descriptor.py +++ b/src/evidently/descriptors/json_match_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import json_match_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class JSONMatch(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:JSONMatch" + __type_alias__: ClassVar = "evidently:descriptor:JSONMatch" with_column: str diff --git a/src/evidently/descriptors/json_schema_match_descriptor.py b/src/evidently/descriptors/json_schema_match_descriptor.py index f85818370e..0c950b3739 100644 --- a/src/evidently/descriptors/json_schema_match_descriptor.py +++ b/src/evidently/descriptors/json_schema_match_descriptor.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from evidently.features import json_schema_match_feature @@ -6,8 +7,7 @@ class JSONSchemaMatch(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:JSONSchemaMatch" + __type_alias__: ClassVar = "evidently:descriptor:JSONSchemaMatch" expected_schema: Dict[str, type] validate_types: bool = False diff --git a/src/evidently/descriptors/llm_judges.py b/src/evidently/descriptors/llm_judges.py index e7c7e5ba0a..aab827b31c 100644 --- a/src/evidently/descriptors/llm_judges.py +++ b/src/evidently/descriptors/llm_judges.py @@ -48,8 +48,7 @@ def get_input_columns(self, column_name: str) -> Dict[str, str]: class LLMEval(BaseLLMEval): - class Config: - type_alias = "evidently:descriptor:LLMEval" + __type_alias__: ClassVar = "evidently:descriptor:LLMEval" name: ClassVar = "LLMEval" @@ -64,8 +63,7 @@ def get_subcolumn(self) -> Optional[str]: class BinaryClassificationLLMEval(BaseLLMEval): - class Config: - type_alias = "evidently:descriptor:BinaryClassificationLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:BinaryClassificationLLMEval" template: ClassVar[BinaryClassificationPromptTemplate] include_category: Optional[bool] = None @@ -87,8 +85,7 @@ def get_subcolumn(self) -> Optional[str]: class NegativityLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:NegativityLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:NegativityLLMEval" name: ClassVar = "Negativity" template: ClassVar = BinaryClassificationPromptTemplate( @@ -107,8 +104,7 @@ class Config: class PIILLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:PIILLMEval" + __type_alias__: ClassVar = "evidently:descriptor:PIILLMEval" name: ClassVar = "PII" template: ClassVar = BinaryClassificationPromptTemplate( @@ -128,8 +124,7 @@ class Config: class DeclineLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:DeclineLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:DeclineLLMEval" name: ClassVar = "Decline" template: ClassVar = BinaryClassificationPromptTemplate( @@ -146,8 +141,7 @@ class Config: class ContextQualityLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:ContextQualityLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:ContextQualityLLMEval" name: ClassVar = "ContextQuality" @@ -182,8 +176,7 @@ def get_input_columns(self, column_name: str) -> Dict[str, str]: class BiasLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:BiasLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:BiasLLMEval" name: ClassVar = "Bias" template: ClassVar = BinaryClassificationPromptTemplate( @@ -206,8 +199,7 @@ class Config: class ToxicityLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:ToxicityLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:ToxicityLLMEval" name: ClassVar = "Toxicity" template: ClassVar = BinaryClassificationPromptTemplate( @@ -230,8 +222,7 @@ class Config: class CorrectnessLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:CorrectnessLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:CorrectnessLLMEval" name: ClassVar = "Correctness" target_output: str @@ -272,8 +263,7 @@ def get_input_columns(self, column_name: str) -> Dict[str, str]: class FaithfulnessLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:FaithfulnessLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:FaithfulnessLLMEval" name: ClassVar = "Faithfulness" context: str @@ -315,8 +305,7 @@ def get_input_columns(self, column_name: str) -> Dict[str, str]: class CompletenessLLMEval(BinaryClassificationLLMEval): - class Config: - type_alias = "evidently:descriptor:CompletenessLLMEval" + __type_alias__: ClassVar = "evidently:descriptor:CompletenessLLMEval" name: ClassVar = "Completeness" context: str diff --git a/src/evidently/descriptors/non_letter_character_percentage_descriptor.py b/src/evidently/descriptors/non_letter_character_percentage_descriptor.py index 2105f804f5..1073b2ee7a 100644 --- a/src/evidently/descriptors/non_letter_character_percentage_descriptor.py +++ b/src/evidently/descriptors/non_letter_character_percentage_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import non_letter_character_percentage_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class NonLetterCharacterPercentage(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:NonLetterCharacterPercentage" + __type_alias__: ClassVar = "evidently:descriptor:NonLetterCharacterPercentage" def feature(self, column_name: str) -> GeneratedFeature: return non_letter_character_percentage_feature.NonLetterCharacterPercentage(column_name, self.display_name) diff --git a/src/evidently/descriptors/oov_words_percentage_descriptor.py b/src/evidently/descriptors/oov_words_percentage_descriptor.py index e61f07c831..ff074c9924 100644 --- a/src/evidently/descriptors/oov_words_percentage_descriptor.py +++ b/src/evidently/descriptors/oov_words_percentage_descriptor.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Tuple from evidently.features.generated_features import FeatureDescriptor @@ -6,8 +7,7 @@ class OOV(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:OOV" + __type_alias__: ClassVar = "evidently:descriptor:OOV" ignore_words: Tuple = () diff --git a/src/evidently/descriptors/openai_descriptor.py b/src/evidently/descriptors/openai_descriptor.py index 89d40d1aa3..b02c25dd0e 100644 --- a/src/evidently/descriptors/openai_descriptor.py +++ b/src/evidently/descriptors/openai_descriptor.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -7,8 +8,7 @@ class OpenAIPrompting(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:OpenAIPrompting" + __type_alias__: ClassVar = "evidently:descriptor:OpenAIPrompting" prompt: str prompt_replace_string: str diff --git a/src/evidently/descriptors/regexp_descriptor.py b/src/evidently/descriptors/regexp_descriptor.py index ec0ecf62dc..a8c537c560 100644 --- a/src/evidently/descriptors/regexp_descriptor.py +++ b/src/evidently/descriptors/regexp_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import regexp_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class RegExp(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:RegExp" + __type_alias__: ClassVar = "evidently:descriptor:RegExp" reg_exp: str diff --git a/src/evidently/descriptors/semantic_similarity.py b/src/evidently/descriptors/semantic_similarity.py index 72a34d78ce..e2bbad7966 100644 --- a/src/evidently/descriptors/semantic_similarity.py +++ b/src/evidently/descriptors/semantic_similarity.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeatures from evidently.features.semantic_similarity_feature import SemanticSimilarityFeature class SemanticSimilarity(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:SemanticSimilarity" + __type_alias__: ClassVar = "evidently:descriptor:SemanticSimilarity" with_column: str diff --git a/src/evidently/descriptors/sentence_count_descriptor.py b/src/evidently/descriptors/sentence_count_descriptor.py index 0d7d256fb3..608fbd866a 100644 --- a/src/evidently/descriptors/sentence_count_descriptor.py +++ b/src/evidently/descriptors/sentence_count_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import sentence_count_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class SentenceCount(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:SentenceCount" + __type_alias__: ClassVar = "evidently:descriptor:SentenceCount" def feature(self, column_name: str) -> GeneratedFeature: return sentence_count_feature.SentenceCount(column_name, self.display_name) diff --git a/src/evidently/descriptors/sentiment_descriptor.py b/src/evidently/descriptors/sentiment_descriptor.py index 026fb317cc..89dab0bb49 100644 --- a/src/evidently/descriptors/sentiment_descriptor.py +++ b/src/evidently/descriptors/sentiment_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import sentiment_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class Sentiment(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:Sentiment" + __type_alias__: ClassVar = "evidently:descriptor:Sentiment" def feature(self, column_name: str) -> GeneratedFeature: return sentiment_feature.Sentiment(column_name, self.display_name) diff --git a/src/evidently/descriptors/text_contains_descriptor.py b/src/evidently/descriptors/text_contains_descriptor.py index 4795c4f77f..6c6e872904 100644 --- a/src/evidently/descriptors/text_contains_descriptor.py +++ b/src/evidently/descriptors/text_contains_descriptor.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from evidently.features import text_contains_feature @@ -6,8 +7,7 @@ class Contains(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:Contains" + __type_alias__: ClassVar = "evidently:descriptor:Contains" items: List[str] mode: str = "any" @@ -24,8 +24,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class DoesNotContain(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:DoesNotContain" + __type_alias__: ClassVar = "evidently:descriptor:DoesNotContain" items: List[str] mode: str = "all" @@ -42,8 +41,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class ItemMatch(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:ItemMatch" + __type_alias__: ClassVar = "evidently:descriptor:ItemMatch" with_column: str mode: str = "any" @@ -59,8 +57,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class ItemNoMatch(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:ItemNoMatch" + __type_alias__: ClassVar = "evidently:descriptor:ItemNoMatch" with_column: str mode: str = "any" diff --git a/src/evidently/descriptors/text_length_descriptor.py b/src/evidently/descriptors/text_length_descriptor.py index e42e6f98df..460a7388fb 100644 --- a/src/evidently/descriptors/text_length_descriptor.py +++ b/src/evidently/descriptors/text_length_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import text_length_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class TextLength(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:TextLength" + __type_alias__: ClassVar = "evidently:descriptor:TextLength" def feature(self, column_name: str) -> GeneratedFeature: return text_length_feature.TextLength(column_name, self.display_name) diff --git a/src/evidently/descriptors/text_part_descriptor.py b/src/evidently/descriptors/text_part_descriptor.py index 913b849580..113638462b 100644 --- a/src/evidently/descriptors/text_part_descriptor.py +++ b/src/evidently/descriptors/text_part_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import text_part_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class BeginsWith(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:BeginsWith" + __type_alias__: ClassVar = "evidently:descriptor:BeginsWith" prefix: str case_sensitive: bool = True @@ -20,8 +21,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class EndsWith(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:EndsWith" + __type_alias__: ClassVar = "evidently:descriptor:EndsWith" suffix: str case_sensitive: bool = True diff --git a/src/evidently/descriptors/trigger_words_presence_descriptor.py b/src/evidently/descriptors/trigger_words_presence_descriptor.py index 1e9eada7a5..0e53e0e7e5 100644 --- a/src/evidently/descriptors/trigger_words_presence_descriptor.py +++ b/src/evidently/descriptors/trigger_words_presence_descriptor.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from evidently.features import trigger_words_presence_feature @@ -6,8 +7,7 @@ class TriggerWordsPresence(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:TriggerWordsPresence" + __type_alias__: ClassVar = "evidently:descriptor:TriggerWordsPresence" words_list: List[str] lemmatize: bool = True diff --git a/src/evidently/descriptors/word_count_descriptor.py b/src/evidently/descriptors/word_count_descriptor.py index 7671764a95..4a115819a5 100644 --- a/src/evidently/descriptors/word_count_descriptor.py +++ b/src/evidently/descriptors/word_count_descriptor.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.features import word_count_feature from evidently.features.generated_features import FeatureDescriptor from evidently.features.generated_features import GeneratedFeature class WordCount(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:WordCount" + __type_alias__: ClassVar = "evidently:descriptor:WordCount" def feature(self, column_name: str) -> GeneratedFeature: return word_count_feature.WordCount(column_name, self.display_name) diff --git a/src/evidently/descriptors/words_descriptor.py b/src/evidently/descriptors/words_descriptor.py index 1b96164505..b207e8dc61 100644 --- a/src/evidently/descriptors/words_descriptor.py +++ b/src/evidently/descriptors/words_descriptor.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from evidently.features import words_feature @@ -6,8 +7,7 @@ class ExcludesWords(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:ExcludesWords" + __type_alias__: ClassVar = "evidently:descriptor:ExcludesWords" words_list: List[str] mode: str = "all" @@ -24,8 +24,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class IncludesWords(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:IncludesWords" + __type_alias__: ClassVar = "evidently:descriptor:IncludesWords" words_list: List[str] mode: str = "any" @@ -42,8 +41,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class WordMatch(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:WordMatch" + __type_alias__: ClassVar = "evidently:descriptor:WordMatch" with_column: str mode: str = "any" @@ -59,8 +57,7 @@ def feature(self, column_name: str) -> GeneratedFeature: class WordNoMatch(FeatureDescriptor): - class Config: - type_alias = "evidently:descriptor:WordNoMatch" + __type_alias__: ClassVar = "evidently:descriptor:WordNoMatch" with_column: str mode: str = "any" diff --git a/src/evidently/features/BERTScore_feature.py b/src/evidently/features/BERTScore_feature.py index 88dfecdc14..c696cd09c6 100644 --- a/src/evidently/features/BERTScore_feature.py +++ b/src/evidently/features/BERTScore_feature.py @@ -13,8 +13,7 @@ class BERTScoreFeature(GeneratedFeature): - class Config: - type_alias = "evidently:feature:BERTScoreFeature" + __type_alias__: ClassVar = "evidently:feature:BERTScoreFeature" __feature_type__: ClassVar = ColumnType.Numerical columns: List[str] diff --git a/src/evidently/features/OOV_words_percentage_feature.py b/src/evidently/features/OOV_words_percentage_feature.py index 68bef44bbe..f925ec828f 100644 --- a/src/evidently/features/OOV_words_percentage_feature.py +++ b/src/evidently/features/OOV_words_percentage_feature.py @@ -16,8 +16,7 @@ class OOVWordsPercentage(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:OOVWordsPercentage" + __type_alias__: ClassVar = "evidently:feature:OOVWordsPercentage" __feature_type__: ClassVar = ColumnType.Numerical display_name_template: ClassVar = "OOV Words % for {column_name}" diff --git a/src/evidently/features/contains_link_feature.py b/src/evidently/features/contains_link_feature.py index e3e6310292..14bfaa93e9 100644 --- a/src/evidently/features/contains_link_feature.py +++ b/src/evidently/features/contains_link_feature.py @@ -10,8 +10,7 @@ class ContainsLink(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:ContainsLink" + __type_alias__: ClassVar = "evidently:feature:ContainsLink" __feature_type__: ClassVar = ColumnType.Categorical display_name_template: ClassVar = "{column_name} contains link" diff --git a/src/evidently/features/custom_feature.py b/src/evidently/features/custom_feature.py index 91924cb07e..4de7cdd3b8 100644 --- a/src/evidently/features/custom_feature.py +++ b/src/evidently/features/custom_feature.py @@ -1,4 +1,5 @@ from typing import Callable +from typing import ClassVar from typing import Tuple import pandas as pd @@ -14,8 +15,7 @@ class CustomFeature(FeatureTypeFieldMixin, GeneratedFeature): - class Config: - type_alias = "evidently:feature:CustomFeature" + __type_alias__: ClassVar = "evidently:feature:CustomFeature" display_name: str name: str = Field(default_factory=lambda: str(new_id())) @@ -31,8 +31,7 @@ def _as_column(self) -> "ColumnName": class CustomSingleColumnFeature(FeatureTypeFieldMixin, GeneratedFeature): - class Config: - type_alias = "evidently:feature:CustomSingleColumnFeature" + __type_alias__: ClassVar = "evidently:feature:CustomSingleColumnFeature" display_name: str func: Callable[[pd.Series], pd.Series] @@ -56,8 +55,7 @@ def get_fingerprint_parts(self) -> Tuple[FingerprintPart, ...]: class CustomPairColumnFeature(FeatureTypeFieldMixin, GeneratedFeature): - class Config: - type_alias = "evidently:feature:CustomPairColumnFeature" + __type_alias__: ClassVar = "evidently:feature:CustomPairColumnFeature" display_name: str func: Callable[[pd.Series, pd.Series], pd.Series] diff --git a/src/evidently/features/exact_match_feature.py b/src/evidently/features/exact_match_feature.py index 4f46d43802..ea5f210998 100644 --- a/src/evidently/features/exact_match_feature.py +++ b/src/evidently/features/exact_match_feature.py @@ -10,8 +10,7 @@ class ExactMatchFeature(GeneratedFeature): - class Config: - type_alias = "evidently:feature:ExactMatchFeature" + __type_alias__: ClassVar = "evidently:feature:ExactMatchFeature" __feature_type__: ClassVar = ColumnType.Categorical columns: List[str] diff --git a/src/evidently/features/generated_features.py b/src/evidently/features/generated_features.py index 5e96487df0..62aa6ff63b 100644 --- a/src/evidently/features/generated_features.py +++ b/src/evidently/features/generated_features.py @@ -28,8 +28,7 @@ class FeatureResult(Generic[TEngineDataType]): class GeneratedFeatures(EvidentlyBaseModel): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True display_name: Optional[str] = None """ @@ -190,16 +189,14 @@ def _as_column(self) -> "ColumnName": class BaseDescriptor(EvidentlyBaseModel): - class Config: - type_alias = "evidently:descriptor:BaseDescriptor" - is_base_type = True + __type_alias__: ClassVar = "evidently:descriptor:BaseDescriptor" + __is_base_type__: ClassVar = True display_name: Optional[str] = None class GeneralDescriptor(BaseDescriptor): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True @abc.abstractmethod def feature(self) -> GeneratedFeatures: @@ -210,9 +207,8 @@ def as_column(self) -> "ColumnName": class MultiColumnFeatureDescriptor(BaseDescriptor): - class Config: - type_alias = "evidently:descriptor:MultiColumnFeatureDescriptor" - is_base_type = True + __type_alias__: ClassVar = "evidently:descriptor:MultiColumnFeatureDescriptor" + __is_base_type__: ClassVar = True def feature(self, columns: List[str]) -> GeneratedFeature: raise NotImplementedError() @@ -225,8 +221,7 @@ def on(self, columns: List[str]) -> "ColumnName": class FeatureDescriptor(BaseDescriptor): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True @abc.abstractmethod def feature(self, column_name: str) -> GeneratedFeatures: diff --git a/src/evidently/features/hf_feature.py b/src/evidently/features/hf_feature.py index 5c517ceb93..97bd4e80a1 100644 --- a/src/evidently/features/hf_feature.py +++ b/src/evidently/features/hf_feature.py @@ -15,8 +15,7 @@ class HuggingFaceFeature(FeatureTypeFieldMixin, DataFeature): - class Config: - type_alias = "evidently:feature:HuggingFaceFeature" + __type_alias__: ClassVar = "evidently:feature:HuggingFaceFeature" column_name: str model: str @@ -42,8 +41,7 @@ def __hash__(self): class HuggingFaceToxicityFeature(DataFeature): - class Config: - type_alias = "evidently:feature:HuggingFaceToxicityFeature" + __type_alias__: ClassVar = "evidently:feature:HuggingFaceToxicityFeature" __feature_type__: ClassVar = ColumnType.Numerical column_name: str diff --git a/src/evidently/features/is_valid_json_feature.py b/src/evidently/features/is_valid_json_feature.py index acb15f0662..f96cd2af4d 100644 --- a/src/evidently/features/is_valid_json_feature.py +++ b/src/evidently/features/is_valid_json_feature.py @@ -8,8 +8,7 @@ class IsValidJSON(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:IsValidJSON" + __type_alias__: ClassVar = "evidently:feature:IsValidJSON" __feature_type__: ClassVar = ColumnType.Categorical display_name_template: ClassVar = "JSON valid for {column_name}" diff --git a/src/evidently/features/is_valid_python_feature.py b/src/evidently/features/is_valid_python_feature.py index 4880a5d615..0b81d52c01 100644 --- a/src/evidently/features/is_valid_python_feature.py +++ b/src/evidently/features/is_valid_python_feature.py @@ -8,8 +8,7 @@ class IsValidPython(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:IsValidPython" + __type_alias__: ClassVar = "evidently:feature:IsValidPython" __feature_type__: ClassVar = ColumnType.Categorical display_name_template: ClassVar = "Valid Python for {column_name}" diff --git a/src/evidently/features/is_valid_sql_feature.py b/src/evidently/features/is_valid_sql_feature.py index efae711238..432955100d 100644 --- a/src/evidently/features/is_valid_sql_feature.py +++ b/src/evidently/features/is_valid_sql_feature.py @@ -7,8 +7,7 @@ class IsValidSQL(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:IsValidSQL" + __type_alias__: ClassVar = "evidently:feature:IsValidSQL" __feature_type__: ClassVar = ColumnType.Categorical display_name_template: ClassVar = "SQL Validity Check for {column_name}" diff --git a/src/evidently/features/json_match_feature.py b/src/evidently/features/json_match_feature.py index ad766e7692..eeab4546f5 100644 --- a/src/evidently/features/json_match_feature.py +++ b/src/evidently/features/json_match_feature.py @@ -1,4 +1,5 @@ import json +from typing import ClassVar import pandas as pd @@ -10,8 +11,7 @@ class JSONMatch(FeatureTypeFieldMixin, GeneratedFeature): - class Config: - type_alias = "evidently:feature:JSONMatch" + __type_alias__: ClassVar = "evidently:feature:JSONMatch" first_column: str second_column: str diff --git a/src/evidently/features/json_schema_match_feature.py b/src/evidently/features/json_schema_match_feature.py index e81e8ba01b..fe0d82a2fc 100644 --- a/src/evidently/features/json_schema_match_feature.py +++ b/src/evidently/features/json_schema_match_feature.py @@ -12,8 +12,7 @@ class JSONSchemaMatch(GeneratedFeature): - class Config: - type_alias = "evidently:feature:JSONSchemaMatch" + __type_alias__: ClassVar = "evidently:feature:JSONSchemaMatch" __feature_type__: ClassVar = ColumnType.Categorical column_name: str diff --git a/src/evidently/features/llm_judge.py b/src/evidently/features/llm_judge.py index b14199e9b6..29b48114c0 100644 --- a/src/evidently/features/llm_judge.py +++ b/src/evidently/features/llm_judge.py @@ -28,8 +28,7 @@ class BaseLLMPromptTemplate(PromptTemplate): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True def iterate_messages(self, data: pd.DataFrame, input_columns: Dict[str, str]) -> Iterator[LLMRequest[dict]]: template = self.get_template() @@ -59,8 +58,7 @@ class Uncertainty(str, Enum): @autoregister class BinaryClassificationPromptTemplate(BaseLLMPromptTemplate, EnumValueMixin): - class Config: - type_alias = "evidently:prompt_template:BinaryClassificationPromptTemplate" + __type_alias__: ClassVar = "evidently:prompt_template:BinaryClassificationPromptTemplate" criteria: str = "" instructions_template: str = ( @@ -166,8 +164,7 @@ def get_type(self, subcolumn: Optional[str]) -> ColumnType: class LLMJudge(GeneratedFeatures): - class Config: - type_alias = "evidently:feature:LLMJudge" + __type_alias__: ClassVar = "evidently:feature:LLMJudge" """Generic LLM judge generated features""" diff --git a/src/evidently/features/non_letter_character_percentage_feature.py b/src/evidently/features/non_letter_character_percentage_feature.py index 97acbe4e22..a2d1c0f8df 100644 --- a/src/evidently/features/non_letter_character_percentage_feature.py +++ b/src/evidently/features/non_letter_character_percentage_feature.py @@ -9,8 +9,7 @@ class NonLetterCharacterPercentage(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:NonLetterCharacterPercentage" + __type_alias__: ClassVar = "evidently:feature:NonLetterCharacterPercentage" __feature_type__: ClassVar = ColumnType.Numerical display_name_template: ClassVar = "Non Letter Character % for {column_name}" diff --git a/src/evidently/features/openai_feature.py b/src/evidently/features/openai_feature.py index 6e79436911..5927da6acc 100644 --- a/src/evidently/features/openai_feature.py +++ b/src/evidently/features/openai_feature.py @@ -1,4 +1,5 @@ from itertools import repeat +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -16,8 +17,7 @@ class OpenAIFeature(FeatureTypeFieldMixin, GeneratedFeature): - class Config: - type_alias = "evidently:feature:OpenAIFeature" + __type_alias__: ClassVar = "evidently:feature:OpenAIFeature" column_name: str feature_id: str diff --git a/src/evidently/features/regexp_feature.py b/src/evidently/features/regexp_feature.py index af6a8a3e1a..3801327fb0 100644 --- a/src/evidently/features/regexp_feature.py +++ b/src/evidently/features/regexp_feature.py @@ -10,8 +10,7 @@ class RegExp(GeneratedFeature): - class Config: - type_alias = "evidently:feature:RegExp" + __type_alias__: ClassVar = "evidently:feature:RegExp" __feature_type__: ClassVar = ColumnType.Categorical column_name: str diff --git a/src/evidently/features/semantic_similarity_feature.py b/src/evidently/features/semantic_similarity_feature.py index 5680bbfff6..3a772b5427 100644 --- a/src/evidently/features/semantic_similarity_feature.py +++ b/src/evidently/features/semantic_similarity_feature.py @@ -11,8 +11,7 @@ class SemanticSimilarityFeature(GeneratedFeature): - class Config: - type_alias = "evidently:feature:SemanticSimilarityFeature" + __type_alias__: ClassVar = "evidently:feature:SemanticSimilarityFeature" __feature_type__: ClassVar = ColumnType.Numerical columns: List[str] diff --git a/src/evidently/features/sentence_count_feature.py b/src/evidently/features/sentence_count_feature.py index 356a9d8393..40c3f38895 100644 --- a/src/evidently/features/sentence_count_feature.py +++ b/src/evidently/features/sentence_count_feature.py @@ -10,8 +10,7 @@ class SentenceCount(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:SentenceCount" + __type_alias__: ClassVar = "evidently:feature:SentenceCount" __feature_type__: ClassVar = ColumnType.Numerical _reg: ClassVar[re.Pattern] = re.compile(r"(? ColumnName: class EndsWith(GeneratedFeature): - class Config: - type_alias = "evidently:feature:EndsWith" + __type_alias__: ClassVar = "evidently:feature:EndsWith" __feature_type__: ClassVar = ColumnType.Categorical column_name: str diff --git a/src/evidently/features/trigger_words_presence_feature.py b/src/evidently/features/trigger_words_presence_feature.py index 027bea560f..2b604c3234 100644 --- a/src/evidently/features/trigger_words_presence_feature.py +++ b/src/evidently/features/trigger_words_presence_feature.py @@ -13,8 +13,7 @@ class TriggerWordsPresent(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:TriggerWordsPresent" + __type_alias__: ClassVar = "evidently:feature:TriggerWordsPresent" __feature_type__: ClassVar = ColumnType.Categorical column_name: str diff --git a/src/evidently/features/word_count_feature.py b/src/evidently/features/word_count_feature.py index 47e707ec27..2d37cb18d2 100644 --- a/src/evidently/features/word_count_feature.py +++ b/src/evidently/features/word_count_feature.py @@ -10,8 +10,7 @@ class WordCount(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:WordCount" + __type_alias__: ClassVar = "evidently:feature:WordCount" __feature_type__: ClassVar = ColumnType.Numerical _reg: ClassVar[re.Pattern] = re.compile(r"[^a-zA-Z ]+") diff --git a/src/evidently/features/words_feature.py b/src/evidently/features/words_feature.py index 470ba64260..11100b2d33 100644 --- a/src/evidently/features/words_feature.py +++ b/src/evidently/features/words_feature.py @@ -45,8 +45,7 @@ def _listed_words_present( class WordsPresence(ApplyColumnGeneratedFeature): - class Config: - type_alias = "evidently:feature:WordsPresence" + __type_alias__: ClassVar = "evidently:feature:WordsPresence" __feature_type__: ClassVar = ColumnType.Categorical column_name: str @@ -85,8 +84,7 @@ def apply(self, value: Any): class IncludesWords(WordsPresence): - class Config: - type_alias = "evidently:feature:IncludesWords" + __type_alias__: ClassVar = "evidently:feature:IncludesWords" def __init__( self, @@ -109,8 +107,7 @@ def _feature_display_name(self): class ExcludesWords(WordsPresence): - class Config: - type_alias = "evidently:feature:ExcludesWords" + __type_alias__: ClassVar = "evidently:feature:ExcludesWords" def __init__( self, @@ -133,8 +130,7 @@ def _feature_display_name(self): class RowWordPresence(GeneratedFeature): - class Config: - type_alias = "evidently:feature:RowWordPresence" + __type_alias__: ClassVar = "evidently:feature:RowWordPresence" __feature_type__: ClassVar = ColumnType.Categorical columns: List[str] @@ -185,8 +181,7 @@ def _feature_name(self): class WordMatch(RowWordPresence): - class Config: - type_alias = "evidently:feature:WordMatch" + __type_alias__: ClassVar = "evidently:feature:WordMatch" def __init__(self, columns: List[str], mode: str, lemmatize: bool, display_name: Optional[str] = None): super().__init__(columns=columns, mode="includes_" + mode, lemmatize=lemmatize, display_name=display_name) @@ -199,8 +194,7 @@ def _as_column(self) -> "ColumnName": class WordNoMatch(RowWordPresence): - class Config: - type_alias = "evidently:feature:WordNoMatch" + __type_alias__: ClassVar = "evidently:feature:WordNoMatch" def __init__(self, columns: List[str], mode: str, lemmatize: bool, display_name: Optional[str] = None): super().__init__(columns=columns, mode="excludes_" + mode, lemmatize=lemmatize, display_name=display_name) diff --git a/src/evidently/future/backport.py b/src/evidently/future/backport.py index 4d16612ec7..0e85107c90 100644 --- a/src/evidently/future/backport.py +++ b/src/evidently/future/backport.py @@ -64,52 +64,45 @@ class MetricResultV2Adapter(MetricResultV1): - class Config: - type_alias = "evidently:metric_result:MetricResultV2Adapter" + __type_alias__: ClassVar = "evidently:metric_result:MetricResultV2Adapter" widget: List[dict] class PresetMetricValueV1(MetricResultV2Adapter): - class Config: - type_alias = "evidently:metric_result:PresetMetricValueV1" + __type_alias__: ClassVar = "evidently:metric_result:PresetMetricValueV1" class SingleValueV1(MetricResultV2Adapter): - class Config: - type_alias = "evidently:metric_result:SingleValueV1" + __type_alias__: ClassVar = "evidently:metric_result:SingleValueV1" value: Union[float, int, str] class ByLabelValueV1(MetricResultV2Adapter): - class Config: - type_alias = "evidently:metric_result:ByLabelValueV1" - field_tags = {"values": {IncludeTags.Render}} + __type_alias__: ClassVar = "evidently:metric_result:ByLabelValueV1" + __field_tags__: ClassVar = {"values": {IncludeTags.Render}} values: Dict[Label, Union[float, int, bool, str]] class ByLabelCountValueV1(MetricResultV2Adapter): - class Config: - type_alias = "evidently:metric_result:ByLabelCountValueV1" - field_tags = {"values": {IncludeTags.Render}} + __type_alias__: ClassVar = "evidently:metric_result:ByLabelCountValueV1" + __field_tags__: ClassVar = {"values": {IncludeTags.Render}} counts: Dict[Label, int] shares: Dict[Label, float] class CountValueV1(MetricResultV2Adapter): - class Config: - type_alias = "evidently:metric_result:CountValueV1" + __type_alias__: ClassVar = "evidently:metric_result:CountValueV1" count: int share: float class MeanStdValueV1(MetricResultV2Adapter): - class Config: - type_alias = "evidently:metric_result:MeanStdValueV1" + __type_alias__: ClassVar = "evidently:metric_result:MeanStdValueV1" mean: float std: float @@ -155,8 +148,7 @@ def metric_result_v2_to_v1(metric_result: MetricResultV2, ignore_widget: bool = class MetricV2Adapter(MetricV1[MetricResultV2Adapter]): - class Config: - type_alias = "evidently:metric:MetricV2Adapter" + __type_alias__: ClassVar = "evidently:metric:MetricV2Adapter" metric: Union[MetricV2, dict] fingerprint: Fingerprint = "" @@ -172,8 +164,7 @@ def get_fingerprint(self) -> Fingerprint: class MetricV2PresetAdapter(MetricV1[MetricResultV2Adapter]): - class Config: - type_alias = "evidently:metric:MetricV2PresetAdapter" + __type_alias__: ClassVar = "evidently:metric:MetricV2PresetAdapter" id: str @@ -358,13 +349,11 @@ def snapshot_v2_to_v1(snapshot: SnapshotV2) -> SnapshotV1: class DashboardPanelV2(DashboardPanel): - class Config: - type_alias = "evidently:dashboard_panel:DashboardPanelV2" + __type_alias__: ClassVar = "evidently:dashboard_panel:DashboardPanelV2" class SingleValueDashboardPanel(DashboardPanelV2): - class Config: - type_alias = "evidently:dashboard_panel:SingleValueDashboardPanel" + __type_alias__: ClassVar = "evidently:dashboard_panel:SingleValueDashboardPanel" title: str = "" filter: ReportFilter = ReportFilter(metadata_values={}, tag_values=[], include_test_suites=True) @@ -383,8 +372,7 @@ async def build( class TestV2Adapter(TestV1): - class Config: - type_alias = "evidently:test:TestV2Adapter" + __type_alias__: ClassVar = "evidently:test:TestV2Adapter" name: ClassVar[str] = "TestV2Adapter" group: ClassVar[str] = "TestV2Adapter" @@ -399,8 +387,7 @@ def groups(self) -> Dict[str, str]: class TestV2Parameters(TestParameters): - class Config: - type_alias = "evidently:test_parameters:TestV2Parameters" + __type_alias__: ClassVar = "evidently:test_parameters:TestV2Parameters" class TestsConfig(MetricV2): diff --git a/src/evidently/future/metric_types.py b/src/evidently/future/metric_types.py index bb9722fb25..8ddc1894f0 100644 --- a/src/evidently/future/metric_types.py +++ b/src/evidently/future/metric_types.py @@ -675,8 +675,7 @@ def __get_type__(cls): class MetricTest(AutoAliasMixin, EvidentlyBaseModel): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True __alias_type__: ClassVar[str] = "test_v2" is_critical: bool = True @@ -709,8 +708,7 @@ def bind_mean_std(self, fingerprint: Fingerprint, is_mean: bool = True): class BoundTest(AutoAliasMixin, EvidentlyBaseModel, Generic[TResult], ABC): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True __alias_type__: ClassVar[str] = "bound_test" test: MetricTest @@ -727,9 +725,8 @@ def run_test(self, context: "Context", calculation: MetricCalculationBase[TResul class Metric(AutoAliasMixin, EvidentlyBaseModel, Generic[TCalculation]): __alias_type__: ClassVar[str] = "metric_v2" - class Config: - is_base_type = True - smart_union = True + __is_base_type__: ClassVar = True + __smart_union__: ClassVar = True __calculation_type__: ClassVar[Type[TCalculation]] diff --git a/src/evidently/future/metrics/column_statistics.py b/src/evidently/future/metrics/column_statistics.py index 4688ccd7ad..85dbd24c66 100644 --- a/src/evidently/future/metrics/column_statistics.py +++ b/src/evidently/future/metrics/column_statistics.py @@ -1,5 +1,6 @@ import abc from collections import Counter +from typing import ClassVar from typing import Dict from typing import Generic from typing import List @@ -202,8 +203,7 @@ def display_name(self) -> str: class CategoryCount(ColumnMetric, CountMetric): - class Config: - smart_union = True + __smart_union__: ClassVar = True category: Optional[CategoryCountLabel] = None categories: List[CategoryCountLabel] = [] diff --git a/src/evidently/metric_preset/classification_performance.py b/src/evidently/metric_preset/classification_performance.py index 30bbaa9e3b..57d671ce4d 100644 --- a/src/evidently/metric_preset/classification_performance.py +++ b/src/evidently/metric_preset/classification_performance.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -19,8 +20,7 @@ class ClassificationPreset(MetricPreset): - class Config: - type_alias = "evidently:metric_preset:ClassificationPreset" + __type_alias__: ClassVar = "evidently:metric_preset:ClassificationPreset" """ Metrics preset for classification performance. diff --git a/src/evidently/metric_preset/data_drift.py b/src/evidently/metric_preset/data_drift.py index c0bc5ed5f4..650dbaa733 100644 --- a/src/evidently/metric_preset/data_drift.py +++ b/src/evidently/metric_preset/data_drift.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -15,8 +16,7 @@ class DataDriftPreset(MetricPreset): - class Config: - type_alias = "evidently:metric_preset:DataDriftPreset" + __type_alias__: ClassVar = "evidently:metric_preset:DataDriftPreset" """Metric Preset for Data Drift analysis. diff --git a/src/evidently/metric_preset/data_quality.py b/src/evidently/metric_preset/data_quality.py index 92e0ad37be..08c082e30a 100644 --- a/src/evidently/metric_preset/data_quality.py +++ b/src/evidently/metric_preset/data_quality.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -13,8 +14,7 @@ class DataQualityPreset(MetricPreset): - class Config: - type_alias = "evidently:metric_preset:DataQualityPreset" + __type_alias__: ClassVar = "evidently:metric_preset:DataQualityPreset" """Metric preset for Data Quality analysis. diff --git a/src/evidently/metric_preset/metric_preset.py b/src/evidently/metric_preset/metric_preset.py index 35859ba870..e02d83dd4c 100644 --- a/src/evidently/metric_preset/metric_preset.py +++ b/src/evidently/metric_preset/metric_preset.py @@ -1,5 +1,6 @@ import abc from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -16,8 +17,7 @@ class MetricPreset(BasePreset): """Base class for metric presets""" - class Config: - is_base_type = True + __is_base_type__: ClassVar = True @abc.abstractmethod def generate_metrics( diff --git a/src/evidently/metric_preset/recsys.py b/src/evidently/metric_preset/recsys.py index 4e3cdb5c83..c3df555885 100644 --- a/src/evidently/metric_preset/recsys.py +++ b/src/evidently/metric_preset/recsys.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -27,8 +28,7 @@ class RecsysPreset(MetricPreset): - class Config: - type_alias = "evidently:metric_preset:RecsysPreset" + __type_alias__: ClassVar = "evidently:metric_preset:RecsysPreset" """Metric preset for recsys performance analysis. diff --git a/src/evidently/metric_preset/regression_performance.py b/src/evidently/metric_preset/regression_performance.py index 154d4e510c..14d70a2348 100644 --- a/src/evidently/metric_preset/regression_performance.py +++ b/src/evidently/metric_preset/regression_performance.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -18,8 +19,7 @@ class RegressionPreset(MetricPreset): - class Config: - type_alias = "evidently:metric_preset:RegressionPreset" + __type_alias__: ClassVar = "evidently:metric_preset:RegressionPreset" """Metric preset for Regression performance analysis. diff --git a/src/evidently/metric_preset/target_drift.py b/src/evidently/metric_preset/target_drift.py index 3e73c7568e..8b00af3464 100644 --- a/src/evidently/metric_preset/target_drift.py +++ b/src/evidently/metric_preset/target_drift.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -16,8 +17,7 @@ class TargetDriftPreset(MetricPreset): - class Config: - type_alias = "evidently:metric_preset:TargetDriftPreset" + __type_alias__: ClassVar = "evidently:metric_preset:TargetDriftPreset" """Metric preset for Target Drift analysis. diff --git a/src/evidently/metric_preset/text_evals.py b/src/evidently/metric_preset/text_evals.py index 8750baadc4..a9fee1e41c 100644 --- a/src/evidently/metric_preset/text_evals.py +++ b/src/evidently/metric_preset/text_evals.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -16,8 +17,7 @@ class TextEvals(MetricPreset): - class Config: - type_alias = "evidently:metric_preset:TextEvals" + __type_alias__: ClassVar = "evidently:metric_preset:TextEvals" column_name: str descriptors: Optional[List[FeatureDescriptor]] = None diff --git a/src/evidently/metric_results.py b/src/evidently/metric_results.py index 5a1e1d2cff..df72e30e1e 100644 --- a/src/evidently/metric_results.py +++ b/src/evidently/metric_results.py @@ -1,8 +1,8 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional from typing import Sequence -from typing import Set from typing import Tuple from typing import Type from typing import TypeVar @@ -73,33 +73,29 @@ def column_scatter_valudator(value): class Distribution(MetricResult): - class Config: - type_alias = "evidently:metric_result:Distribution" - pd_include = False - tags = {IncludeTags.Render} - smart_union = True - extract_as_obj = True + __type_alias__: ClassVar = "evidently:metric_result:Distribution" + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __smart_union__: ClassVar = True + __extract_as_obj__: ClassVar = True x: Union[np.ndarray, list, pd.Categorical, pd.Series] y: Union[np.ndarray, list, pd.Categorical, pd.Series] class ConfusionMatrix(MetricResult): - class Config: - type_alias = "evidently:metric_result:ConfusionMatrix" - smart_union = True - - field_tags = {"labels": {IncludeTags.Parameter}} + __type_alias__: ClassVar = "evidently:metric_result:ConfusionMatrix" + __smart_union__: ClassVar = True + __field_tags__: ClassVar = {"labels": {IncludeTags.Parameter}} labels: Sequence[Label] values: list # todo better typing class PredictionData(MetricResult): - class Config: - type_alias = "evidently:metric_result:PredictionData" - dict_include = False - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:PredictionData" + __dict_include__: ClassVar = False + __smart_union__: ClassVar = True predictions: pd.Series labels: LabelList @@ -126,19 +122,17 @@ def validate_prediction_probas(cls, value: pd.DataFrame, values): class StatsByFeature(MetricResult): - class Config: - type_alias = "evidently:metric_result:StatsByFeature" - dict_include = False - pd_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:StatsByFeature" + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} plot_data: pd.DataFrame # todo what type of plot? predictions: Optional[PredictionData] class DatasetUtilityColumns(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetUtilityColumns" + __type_alias__: ClassVar = "evidently:metric_result:DatasetUtilityColumns" date: Optional[str] id: Optional[str] @@ -147,12 +141,11 @@ class Config: class DatasetColumns(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetColumns" - dict_exclude_fields = {"task", "target_type"} - pd_include = False - tags = {IncludeTags.Parameter} - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:DatasetColumns" + __dict_exclude_fields__: ClassVar = {"task", "target_type"} + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Parameter} + __smart_union__: ClassVar = True utility_columns: DatasetUtilityColumns target_type: Optional[str] @@ -245,13 +238,11 @@ def column_scatter_from_df(df: Optional[pd.DataFrame], with_index: bool) -> Opti class ScatterAggField(MetricResult): - class Config: - type_alias = "evidently:metric_result:ScatterAggField" - smart_union = True - dict_include = False - pd_include = False - - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:ScatterAggField" + __smart_union__: ClassVar = True + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} scatter: ColumnAggScatter x_name: str @@ -259,13 +250,11 @@ class Config: class ScatterField(MetricResult): - class Config: - type_alias = "evidently:metric_result:ScatterField" - smart_union = True - dict_include = False - pd_include = False - - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:ScatterField" + __smart_union__: ClassVar = True + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} scatter: ColumnScatter x_name: str @@ -273,14 +262,12 @@ class Config: class ColumnScatterResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnScatterResult" - smart_union = True - dict_include = False - pd_include = False - - tags = {IncludeTags.Render} - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ColumnScatterResult" + __smart_union__: ClassVar = True + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: ColumnScatter reference: Optional[ColumnScatter] @@ -289,9 +276,8 @@ class Config: class ColumnAggScatterResult(ColumnScatterResult): - class Config: - type_alias = "evidently:metric_result:ColumnAggScatterResult" - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ColumnAggScatterResult" + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} # TODO: fix type collision with super type current: ColumnAggScatter # type: ignore[assignment] @@ -302,10 +288,9 @@ class Config: class Boxes(MetricResult): - class Config: - type_alias = "evidently:metric_result:Boxes" - dict_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:Boxes" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} mins: PlotData lowers: PlotData @@ -315,10 +300,9 @@ class Config: class RatesPlotData(MetricResult): - class Config: - type_alias = "evidently:metric_result:RatesPlotData" - dict_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:RatesPlotData" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} thrs: PlotData tpr: PlotData @@ -328,10 +312,9 @@ class Config: class PRCurveData(MetricResult): - class Config: - type_alias = "evidently:metric_result:PRCurveData" - dict_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:PRCurveData" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} pr: PlotData rcl: PlotData @@ -342,10 +325,9 @@ class Config: class ROCCurveData(MetricResult): - class Config: - type_alias = "evidently:metric_result:ROCCurveData" - dict_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:ROCCurveData" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} fpr: PlotData tpr: PlotData @@ -356,10 +338,9 @@ class Config: class LiftCurveData(MetricResult): - class Config: - type_alias = "evidently:metric_result:LiftCurveData" - dict_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:LiftCurveData" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} lift: PlotData top: PlotData @@ -379,11 +360,10 @@ class Config: class HistogramData(MetricResult): - class Config: - type_alias = "evidently:metric_result:HistogramData" - dict_include = False - tags = {IncludeTags.Render} - extract_as_obj = True + __type_alias__: ClassVar = "evidently:metric_result:HistogramData" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __extract_as_obj__: ClassVar = True x: pd.Series count: pd.Series @@ -426,16 +406,15 @@ def to_df(self): class Histogram(MetricResult): - class Config: - type_alias = "evidently:metric_result:Histogram" - dict_include = False - tags = {IncludeTags.Render} - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "current_log": {IncludeTags.Current}, - "reference_log": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:Histogram" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "current_log": {IncludeTags.Current}, + "reference_log": {IncludeTags.Reference}, + } current: HistogramData reference: Optional[HistogramData] @@ -446,17 +425,14 @@ class Config: # todo need better config overriding logic in metricresult class DistributionIncluded(Distribution): - class Config: - type_alias = "evidently:metric_result:DistributionIncluded" - tags: Set[IncludeTags] = set() - dict_include = True - field_tags = {"x": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:DistributionIncluded" + __dict_include__: ClassVar = True + __field_tags__: ClassVar = {"x": {IncludeTags.Extra}} class ColumnCorrelations(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnCorrelations" - field_tags = {"column_name": {IncludeTags.Parameter}, "kind": {IncludeTags.Parameter}} + __type_alias__: ClassVar = "evidently:metric_result:ColumnCorrelations" + __field_tags__: ClassVar = {"column_name": {IncludeTags.Parameter}, "kind": {IncludeTags.Parameter}} column_name: str kind: str @@ -472,8 +448,7 @@ def get_pandas(self) -> pd.DataFrame: class DatasetClassificationQuality(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetClassificationQuality" + __type_alias__: ClassVar = "evidently:metric_result:DatasetClassificationQuality" accuracy: float precision: float diff --git a/src/evidently/metrics/classification_performance/class_balance_metric.py b/src/evidently/metrics/classification_performance/class_balance_metric.py index 9ad56f8d63..7db9aa6ff9 100644 --- a/src/evidently/metrics/classification_performance/class_balance_metric.py +++ b/src/evidently/metrics/classification_performance/class_balance_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -17,17 +18,15 @@ class ClassificationClassBalanceResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationClassBalanceResult" - dict_exclude_fields = {"plot_data"} - pd_exclude_fields = {"plot_data"} + __type_alias__: ClassVar = "evidently:metric_result:ClassificationClassBalanceResult" + __dict_exclude_fields__: ClassVar = {"plot_data"} + __pd_exclude_fields__: ClassVar = {"plot_data"} plot_data: Histogram class ClassificationClassBalance(Metric[ClassificationClassBalanceResult]): - class Config: - type_alias = "evidently:metric:ClassificationClassBalance" + __type_alias__: ClassVar = "evidently:metric:ClassificationClassBalance" def calculate(self, data: InputData) -> ClassificationClassBalanceResult: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/classification_performance/class_separation_metric.py b/src/evidently/metrics/classification_performance/class_separation_metric.py index d19653be5c..4547ed3991 100644 --- a/src/evidently/metrics/classification_performance/class_separation_metric.py +++ b/src/evidently/metrics/classification_performance/class_separation_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -29,15 +30,14 @@ class ClassificationClassSeparationPlotResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationClassSeparationPlotResults" - dict_exclude_fields = {"current", "reference"} - pd_exclude_fields = {"current", "reference"} - field_tags = { - "current": {IncludeTags.Current, IncludeTags.Extra}, - "reference": {IncludeTags.Reference, IncludeTags.Extra}, - "target_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ClassificationClassSeparationPlotResults" + __dict_exclude_fields__: ClassVar = {"current", "reference"} + __pd_exclude_fields__: ClassVar = {"current", "reference"} + __field_tags__: ClassVar = { + "current": {IncludeTags.Current, IncludeTags.Extra}, + "reference": {IncludeTags.Reference, IncludeTags.Extra}, + "target_name": {IncludeTags.Parameter}, + } target_name: str @@ -73,8 +73,7 @@ def _quantiles(qdf, value): class ClassificationClassSeparationPlot(UsesRawDataMixin, Metric[ClassificationClassSeparationPlotResults]): - class Config: - type_alias = "evidently:metric:ClassificationClassSeparationPlot" + __type_alias__: ClassVar = "evidently:metric:ClassificationClassSeparationPlot" def __init__(self, options: AnyOptions = None): super().__init__(options=options) diff --git a/src/evidently/metrics/classification_performance/classification_dummy_metric.py b/src/evidently/metrics/classification_performance/classification_dummy_metric.py index bf64666a32..a882a6ef37 100644 --- a/src/evidently/metrics/classification_performance/classification_dummy_metric.py +++ b/src/evidently/metrics/classification_performance/classification_dummy_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -30,12 +31,10 @@ class ClassificationDummyMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationDummyMetricResults" - dict_exclude_fields = {"metrics_matrix"} - pd_exclude_fields = {"metrics_matrix"} - - field_tags = {"by_reference_dummy": {IncludeTags.Reference}, "metrics_matrix": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:ClassificationDummyMetricResults" + __dict_exclude_fields__: ClassVar = {"metrics_matrix"} + __pd_exclude_fields__: ClassVar = {"metrics_matrix"} + __field_tags__: ClassVar = {"by_reference_dummy": {IncludeTags.Reference}, "metrics_matrix": {IncludeTags.Extra}} dummy: DatasetClassificationQuality by_reference_dummy: Optional[DatasetClassificationQuality] @@ -44,8 +43,7 @@ class Config: class ClassificationDummyMetric(ThresholdClassificationMetric[ClassificationDummyMetricResults]): - class Config: - type_alias = "evidently:metric:ClassificationDummyMetric" + __type_alias__: ClassVar = "evidently:metric:ClassificationDummyMetric" _quality_metric: ClassificationQualityMetric diff --git a/src/evidently/metrics/classification_performance/classification_quality_metric.py b/src/evidently/metrics/classification_performance/classification_quality_metric.py index 0e4f9e9ecc..3c03e9884b 100644 --- a/src/evidently/metrics/classification_performance/classification_quality_metric.py +++ b/src/evidently/metrics/classification_performance/classification_quality_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -19,13 +20,12 @@ class ClassificationQualityMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationQualityMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "target_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ClassificationQualityMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "target_name": {IncludeTags.Parameter}, + } current: DatasetClassificationQuality reference: Optional[DatasetClassificationQuality] @@ -33,8 +33,7 @@ class Config: class ClassificationQualityMetric(ThresholdClassificationMetric[ClassificationQualityMetricResult]): - class Config: - type_alias = "evidently:metric:ClassificationQualityMetric" + __type_alias__: ClassVar = "evidently:metric:ClassificationQualityMetric" _confusion_matrix_metric: ClassificationConfusionMatrix diff --git a/src/evidently/metrics/classification_performance/confusion_matrix_metric.py b/src/evidently/metrics/classification_performance/confusion_matrix_metric.py index e36cd7c7e4..67164c9d5b 100644 --- a/src/evidently/metrics/classification_performance/confusion_matrix_metric.py +++ b/src/evidently/metrics/classification_performance/confusion_matrix_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -24,14 +25,13 @@ class ClassificationConfusionMatrixResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationConfusionMatrixResult" - field_tags = { - "current_matrix": {IncludeTags.Current}, - "reference_matrix": {IncludeTags.Reference}, - "target_names": {IncludeTags.Parameter}, - } - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:ClassificationConfusionMatrixResult" + __field_tags__: ClassVar = { + "current_matrix": {IncludeTags.Current}, + "reference_matrix": {IncludeTags.Reference}, + "target_names": {IncludeTags.Parameter}, + } + __smart_union__: ClassVar = True current_matrix: ConfusionMatrix reference_matrix: Optional[ConfusionMatrix] @@ -49,8 +49,7 @@ def confusion_matric_metric(self): class ClassificationConfusionMatrix( ThresholdClassificationMetric[ClassificationConfusionMatrixResult], ClassificationConfusionMatrixParameters ): - class Config: - type_alias = "evidently:metric:ClassificationConfusionMatrix" + __type_alias__: ClassVar = "evidently:metric:ClassificationConfusionMatrix" def __init__( self, diff --git a/src/evidently/metrics/classification_performance/lift_curve_metric.py b/src/evidently/metrics/classification_performance/lift_curve_metric.py index e5bb02915d..3d9fa9fc73 100644 --- a/src/evidently/metrics/classification_performance/lift_curve_metric.py +++ b/src/evidently/metrics/classification_performance/lift_curve_metric.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -26,19 +27,19 @@ class ClassificationLiftCurveResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationLiftCurveResults" - pd_include = False - - field_tags = {"current_lift_curve": {IncludeTags.Current}, "reference_lift_curve": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ClassificationLiftCurveResults" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "current_lift_curve": {IncludeTags.Current}, + "reference_lift_curve": {IncludeTags.Reference}, + } current_lift_curve: Optional[LiftCurve] = None reference_lift_curve: Optional[LiftCurve] = None class ClassificationLiftCurve(Metric[ClassificationLiftCurveResults]): - class Config: - type_alias = "evidently:metric:ClassificationLiftCurve" + __type_alias__: ClassVar = "evidently:metric:ClassificationLiftCurve" def calculate(self, data: InputData) -> ClassificationLiftCurveResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/classification_performance/lift_table_metric.py b/src/evidently/metrics/classification_performance/lift_table_metric.py index 3e5a4fe426..1cb6421391 100644 --- a/src/evidently/metrics/classification_performance/lift_table_metric.py +++ b/src/evidently/metrics/classification_performance/lift_table_metric.py @@ -1,5 +1,6 @@ from typing import TYPE_CHECKING from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -45,14 +46,13 @@ def validate(cls: Type["Model"], value: Any): # type: ignore[override, misc] class ClassificationLiftTableResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationLiftTableResults" - pd_include = False - field_tags = { - "current_lift_table": {IncludeTags.Current}, - "reference_lift_table": {IncludeTags.Reference}, - "top": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ClassificationLiftTableResults" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "current_lift_table": {IncludeTags.Current}, + "reference_lift_table": {IncludeTags.Reference}, + "top": {IncludeTags.Parameter}, + } current_lift_table: Optional[LiftTable] = None reference_lift_table: Optional[LiftTable] = None @@ -60,8 +60,7 @@ class Config: class ClassificationLiftTable(Metric[ClassificationLiftTableResults]): - class Config: - type_alias = "evidently:metric:ClassificationLiftTable" + __type_alias__: ClassVar = "evidently:metric:ClassificationLiftTable" """ Evidently metric with inherited behaviour, provides data for lift analysis diff --git a/src/evidently/metrics/classification_performance/objects.py b/src/evidently/metrics/classification_performance/objects.py index 8fcd091872..c39b9dbd85 100644 --- a/src/evidently/metrics/classification_performance/objects.py +++ b/src/evidently/metrics/classification_performance/objects.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import Optional @@ -10,8 +11,7 @@ class ClassMetric(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassMetric" + __type_alias__: ClassVar = "evidently:metric_result:ClassMetric" precision: float recall: float @@ -24,9 +24,8 @@ class Config: class ClassificationReport(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationReport" - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:ClassificationReport" + __smart_union__: ClassVar = True classes: ClassesMetrics accuracy: float diff --git a/src/evidently/metrics/classification_performance/pr_curve_metric.py b/src/evidently/metrics/classification_performance/pr_curve_metric.py index ad86e57161..36bd35d47d 100644 --- a/src/evidently/metrics/classification_performance/pr_curve_metric.py +++ b/src/evidently/metrics/classification_performance/pr_curve_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -23,19 +24,19 @@ class ClassificationPRCurveResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationPRCurveResults" - pd_include = False - - field_tags = {"current_pr_curve": {IncludeTags.Current}, "reference_pr_curve": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ClassificationPRCurveResults" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "current_pr_curve": {IncludeTags.Current}, + "reference_pr_curve": {IncludeTags.Reference}, + } current_pr_curve: Optional[PRCurve] = None reference_pr_curve: Optional[PRCurve] = None class ClassificationPRCurve(Metric[ClassificationPRCurveResults]): - class Config: - type_alias = "evidently:metric:ClassificationPRCurve" + __type_alias__: ClassVar = "evidently:metric:ClassificationPRCurve" def calculate(self, data: InputData) -> ClassificationPRCurveResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/classification_performance/pr_table_metric.py b/src/evidently/metrics/classification_performance/pr_table_metric.py index 0c5f879e8f..8bd91d2ea7 100644 --- a/src/evidently/metrics/classification_performance/pr_table_metric.py +++ b/src/evidently/metrics/classification_performance/pr_table_metric.py @@ -1,5 +1,6 @@ from typing import TYPE_CHECKING from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -44,18 +45,16 @@ def validate(cls: Type["Model"], value: Any): # type: ignore[override, misc] class ClassificationPRTableResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationPRTableResults" - pd_include = False - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ClassificationPRTableResults" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: Optional[PRTable] = None reference: Optional[PRTable] = None class ClassificationPRTable(Metric[ClassificationPRTableResults]): - class Config: - type_alias = "evidently:metric:ClassificationPRTable" + __type_alias__: ClassVar = "evidently:metric:ClassificationPRTable" def calculate(self, data: InputData) -> ClassificationPRTableResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/classification_performance/probability_distribution_metric.py b/src/evidently/metrics/classification_performance/probability_distribution_metric.py index 1a1f014207..5b4487d6cf 100644 --- a/src/evidently/metrics/classification_performance/probability_distribution_metric.py +++ b/src/evidently/metrics/classification_performance/probability_distribution_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import Iterable from typing import List @@ -22,21 +23,21 @@ class ClassificationProbDistributionResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationProbDistributionResults" - dict_include = False - pd_include = False - tags = {IncludeTags.Render} - - field_tags = {"current_distribution": {IncludeTags.Current}, "reference_distribution": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ClassificationProbDistributionResults" + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __field_tags__: ClassVar = { + "current_distribution": {IncludeTags.Current}, + "reference_distribution": {IncludeTags.Reference}, + } current_distribution: Optional[Dict[str, list]] # todo use DistributionField? reference_distribution: Optional[Dict[str, list]] class ClassificationProbDistribution(Metric[ClassificationProbDistributionResults]): - class Config: - type_alias = "evidently:metric:ClassificationProbDistribution" + __type_alias__: ClassVar = "evidently:metric:ClassificationProbDistribution" @staticmethod def get_distribution(dataset: pd.DataFrame, target_name: str, prediction_labels: Iterable) -> Dict[str, list]: diff --git a/src/evidently/metrics/classification_performance/quality_by_class_metric.py b/src/evidently/metrics/classification_performance/quality_by_class_metric.py index 41a7d9c53a..ae13d8ec59 100644 --- a/src/evidently/metrics/classification_performance/quality_by_class_metric.py +++ b/src/evidently/metrics/classification_performance/quality_by_class_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -27,9 +28,8 @@ class ClassificationQuality(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationQuality" - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:ClassificationQuality" + __smart_union__: ClassVar = True metrics: ClassesMetrics roc_aucs: Optional[List[float]] @@ -40,14 +40,13 @@ def metrics_dict(self): class ClassificationQualityByClassResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationQualityByClassResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "columns": {IncludeTags.Parameter}, - } - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:ClassificationQualityByClassResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "columns": {IncludeTags.Parameter}, + } + __smart_union__: ClassVar = True columns: DatasetColumns current: ClassificationQuality @@ -68,8 +67,7 @@ def get_pandas(self) -> pd.DataFrame: class ClassificationQualityByClass(ThresholdClassificationMetric[ClassificationQualityByClassResult]): - class Config: - type_alias = "evidently:metric:ClassificationQualityByClass" + __type_alias__: ClassVar = "evidently:metric:ClassificationQualityByClass" def __init__( self, diff --git a/src/evidently/metrics/classification_performance/quality_by_feature_table.py b/src/evidently/metrics/classification_performance/quality_by_feature_table.py index fbbab8bf88..fa4225adfa 100644 --- a/src/evidently/metrics/classification_performance/quality_by_feature_table.py +++ b/src/evidently/metrics/classification_performance/quality_by_feature_table.py @@ -1,4 +1,5 @@ import json +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -33,14 +34,13 @@ class ClassificationQualityByFeatureTableResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationQualityByFeatureTableResults" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "target_name": {IncludeTags.Parameter}, - "columns": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ClassificationQualityByFeatureTableResults" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "target_name": {IncludeTags.Parameter}, + "columns": {IncludeTags.Parameter}, + } current: StatsByFeature reference: Optional[StatsByFeature] @@ -50,8 +50,7 @@ class Config: class ClassificationQualityByFeatureTable(UsesRawDataMixin, Metric[ClassificationQualityByFeatureTableResults]): - class Config: - type_alias = "evidently:metric:ClassificationQualityByFeatureTable" + __type_alias__: ClassVar = "evidently:metric:ClassificationQualityByFeatureTable" columns: Optional[List[str]] descriptors: Optional[Dict[str, Dict[str, FeatureDescriptor]]] diff --git a/src/evidently/metrics/classification_performance/roc_curve_metric.py b/src/evidently/metrics/classification_performance/roc_curve_metric.py index 098240a47c..9c589f6a3f 100644 --- a/src/evidently/metrics/classification_performance/roc_curve_metric.py +++ b/src/evidently/metrics/classification_performance/roc_curve_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -26,19 +27,19 @@ class ClassificationRocCurveResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ClassificationRocCurveResults" - pd_include = False - - field_tags = {"current_roc_curve": {IncludeTags.Current}, "reference_roc_curve": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ClassificationRocCurveResults" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "current_roc_curve": {IncludeTags.Current}, + "reference_roc_curve": {IncludeTags.Reference}, + } current_roc_curve: Optional[ROCCurve] = None reference_roc_curve: Optional[ROCCurve] = None class ClassificationRocCurve(Metric[ClassificationRocCurveResults]): - class Config: - type_alias = "evidently:metric:ClassificationRocCurve" + __type_alias__: ClassVar = "evidently:metric:ClassificationRocCurve" def calculate(self, data: InputData) -> ClassificationRocCurveResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/custom_metric.py b/src/evidently/metrics/custom_metric.py index 58f6594221..c1e56cfa0c 100644 --- a/src/evidently/metrics/custom_metric.py +++ b/src/evidently/metrics/custom_metric.py @@ -1,4 +1,5 @@ from typing import Callable +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -18,8 +19,7 @@ class CustomCallableMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:CustomCallableMetricResult" + __type_alias__: ClassVar = "evidently:metric_result:CustomCallableMetricResult" value: float @@ -28,8 +28,7 @@ class Config: class CustomValueMetric(Metric[CustomCallableMetricResult]): - class Config: - type_alias = "evidently:metric:CustomValueMetric" + __type_alias__: ClassVar = "evidently:metric:CustomValueMetric" func: str title: Optional[str] = None diff --git a/src/evidently/metrics/data_drift/column_drift_metric.py b/src/evidently/metrics/data_drift/column_drift_metric.py index 53788873c8..4400db769b 100644 --- a/src/evidently/metrics/data_drift/column_drift_metric.py +++ b/src/evidently/metrics/data_drift/column_drift_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -247,8 +248,7 @@ def get_one_column_drift( class ColumnDriftMetric(UsesRawDataMixin, ColumnMetric[ColumnDataDriftMetrics]): - class Config: - type_alias = "evidently:metric:ColumnDriftMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnDriftMetric" """Calculate drift metric for a column""" diff --git a/src/evidently/metrics/data_drift/column_interaction_plot.py b/src/evidently/metrics/data_drift/column_interaction_plot.py index b04eb439e5..38fcee8dd0 100644 --- a/src/evidently/metrics/data_drift/column_interaction_plot.py +++ b/src/evidently/metrics/data_drift/column_interaction_plot.py @@ -1,5 +1,6 @@ import json from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -36,21 +37,20 @@ class ColumnInteractionPlotResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnInteractionPlotResults" - dict_include = False - pd_include = False - tags = {IncludeTags.Render} - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "current_scatter": {IncludeTags.Current}, - "current_contour": {IncludeTags.Current}, - "current_boxes": {IncludeTags.Current}, - "reference_scatter": {IncludeTags.Reference}, - "reference_contour": {IncludeTags.Reference}, - "reference_boxes": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnInteractionPlotResults" + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "current_scatter": {IncludeTags.Current}, + "current_contour": {IncludeTags.Current}, + "current_boxes": {IncludeTags.Current}, + "reference_scatter": {IncludeTags.Reference}, + "reference_contour": {IncludeTags.Reference}, + "reference_boxes": {IncludeTags.Reference}, + } y_type: ColumnType x_type: ColumnType @@ -66,8 +66,7 @@ class Config: class ColumnInteractionPlot(UsesRawDataMixin, Metric[ColumnInteractionPlotResults]): - class Config: - type_alias = "evidently:metric:ColumnInteractionPlot" + __type_alias__: ClassVar = "evidently:metric:ColumnInteractionPlot" x_column: str y_column: str diff --git a/src/evidently/metrics/data_drift/column_value_plot.py b/src/evidently/metrics/data_drift/column_value_plot.py index 883e6b0349..111ae566dc 100644 --- a/src/evidently/metrics/data_drift/column_value_plot.py +++ b/src/evidently/metrics/data_drift/column_value_plot.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -31,12 +32,11 @@ class ColumnValuePlotResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnValuePlotResults" - dict_include = False - pd_include = False - tags = {IncludeTags.Render} - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ColumnValuePlotResults" + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} column_name: str datetime_column_name: Optional[str] @@ -49,8 +49,7 @@ class Config: class ColumnValuePlot(UsesRawDataMixin, Metric[ColumnValuePlotResults]): - class Config: - type_alias = "evidently:metric:ColumnValuePlot" + __type_alias__: ClassVar = "evidently:metric:ColumnValuePlot" column_name: str diff --git a/src/evidently/metrics/data_drift/data_drift_table.py b/src/evidently/metrics/data_drift/data_drift_table.py index 819f464565..31fd8e369a 100644 --- a/src/evidently/metrics/data_drift/data_drift_table.py +++ b/src/evidently/metrics/data_drift/data_drift_table.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -36,13 +37,12 @@ class DataDriftTableResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:DataDriftTableResults" - dict_exclude_fields = {"dataset_columns"} - field_tags = { - "current_fi": {IncludeTags.Extra, IncludeTags.Current}, - "reference_fi": {IncludeTags.Extra, IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:DataDriftTableResults" + __dict_exclude_fields__: ClassVar = {"dataset_columns"} + __field_tags__: ClassVar = { + "current_fi": {IncludeTags.Extra, IncludeTags.Current}, + "reference_fi": {IncludeTags.Extra, IncludeTags.Reference}, + } number_of_columns: int number_of_drifted_columns: int @@ -55,8 +55,7 @@ class Config: class DataDriftTable(UsesRawDataMixin, WithDriftOptions[DataDriftTableResults]): - class Config: - type_alias = "evidently:metric:DataDriftTable" + __type_alias__: ClassVar = "evidently:metric:DataDriftTable" columns: Optional[List[str]] feature_importance: Optional[bool] diff --git a/src/evidently/metrics/data_drift/dataset_drift_metric.py b/src/evidently/metrics/data_drift/dataset_drift_metric.py index c1fe1be46e..995db31ddc 100644 --- a/src/evidently/metrics/data_drift/dataset_drift_metric.py +++ b/src/evidently/metrics/data_drift/dataset_drift_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -18,8 +19,7 @@ class DatasetDriftMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetDriftMetricResults" + __type_alias__: ClassVar = "evidently:metric_result:DatasetDriftMetricResults" drift_share: float number_of_columns: int @@ -31,8 +31,7 @@ class Config: class DatasetDriftMetric( WithDriftOptions[DatasetDriftMetricResults], ): - class Config: - type_alias = "evidently:metric:DatasetDriftMetric" + __type_alias__: ClassVar = "evidently:metric:DatasetDriftMetric" columns: Optional[List[str]] drift_share: float diff --git a/src/evidently/metrics/data_drift/embedding_drift_methods.py b/src/evidently/metrics/data_drift/embedding_drift_methods.py index 7383f6b4bd..52db6634ea 100644 --- a/src/evidently/metrics/data_drift/embedding_drift_methods.py +++ b/src/evidently/metrics/data_drift/embedding_drift_methods.py @@ -1,5 +1,6 @@ import abc from typing import Callable +from typing import ClassVar from typing import Optional from typing import Tuple @@ -47,8 +48,7 @@ def get_pca_df( class DriftMethod(EvidentlyBaseModel): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True @abc.abstractmethod def __call__(self, current_emb: pd.DataFrame, reference_emb: pd.DataFrame) -> Tuple[float, bool, str]: @@ -57,8 +57,7 @@ def __call__(self, current_emb: pd.DataFrame, reference_emb: pd.DataFrame) -> Tu @autoregister class DistanceDriftMethod(DriftMethod): - class Config: - type_alias = "evidently:drift_method:DistanceDriftMethod" + __type_alias__: ClassVar = "evidently:drift_method:DistanceDriftMethod" dist: str = "euclidean" threshold: float = 0.2 @@ -129,8 +128,7 @@ def calc_roc_auc_random(y_test, i): @autoregister class ModelDriftMethod(DriftMethod): - class Config: - type_alias = "evidently:drift_method:ModelDriftMethod" + __type_alias__: ClassVar = "evidently:drift_method:ModelDriftMethod" threshold: float = 0.55 bootstrap: Optional[bool] = None @@ -188,8 +186,7 @@ def model( @autoregister class RatioDriftMethod(DriftMethod): - class Config: - type_alias = "evidently:drift_method:RatioDriftMethod" + __type_alias__: ClassVar = "evidently:drift_method:RatioDriftMethod" component_stattest: str = "wasserstein" component_stattest_threshold: float = 0.1 @@ -267,8 +264,7 @@ def MMD2u_bstrp(K, m, n, x_idx, y_idx): @autoregister class MMDDriftMethod(DriftMethod): - class Config: - type_alias = "evidently:drift_method:MMDDriftMethod" + __type_alias__: ClassVar = "evidently:drift_method:MMDDriftMethod" threshold: float = 0.015 bootstrap: Optional[bool] = None diff --git a/src/evidently/metrics/data_drift/embeddings_drift.py b/src/evidently/metrics/data_drift/embeddings_drift.py index 345a6eb0ca..01d8c027c5 100644 --- a/src/evidently/metrics/data_drift/embeddings_drift.py +++ b/src/evidently/metrics/data_drift/embeddings_drift.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -26,19 +27,14 @@ class EmbeddingsDriftMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:EmbeddingsDriftMetricResults" - dict_exclude_fields = { - "reference", - "current", - } - - field_tags = { - "current": {IncludeTags.Current, IncludeTags.Render}, - "reference": {IncludeTags.Reference, IncludeTags.Render}, - "embeddings_name": {IncludeTags.Parameter}, - "method_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:EmbeddingsDriftMetricResults" + __dict_exclude_fields__: ClassVar = {"reference", "current"} + __field_tags__: ClassVar = { + "current": {IncludeTags.Current, IncludeTags.Render}, + "reference": {IncludeTags.Reference, IncludeTags.Render}, + "embeddings_name": {IncludeTags.Parameter}, + "method_name": {IncludeTags.Parameter}, + } embeddings_name: str drift_score: float @@ -49,8 +45,7 @@ class Config: class EmbeddingsDriftMetric(Metric[EmbeddingsDriftMetricResults]): - class Config: - type_alias = "evidently:metric:EmbeddingsDriftMetric" + __type_alias__: ClassVar = "evidently:metric:EmbeddingsDriftMetric" embeddings_name: str drift_method: Optional[DriftMethod] diff --git a/src/evidently/metrics/data_drift/feature_importance.py b/src/evidently/metrics/data_drift/feature_importance.py index 2fd7545712..29aa9342e9 100644 --- a/src/evidently/metrics/data_drift/feature_importance.py +++ b/src/evidently/metrics/data_drift/feature_importance.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -22,9 +23,8 @@ class FeatureImportanceMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:FeatureImportanceMetricResult" - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:FeatureImportanceMetricResult" + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: Optional[Dict[str, float]] = None reference: Optional[Dict[str, float]] = None @@ -42,8 +42,7 @@ def get_pandas(self) -> pd.DataFrame: class FeatureImportanceMetric(Metric[FeatureImportanceMetricResult]): - class Config: - type_alias = "evidently:metric:FeatureImportanceMetric" + __type_alias__: ClassVar = "evidently:metric:FeatureImportanceMetric" def calculate(self, data: InputData) -> FeatureImportanceMetricResult: if data.additional_data.get("current_feature_importance") is not None: diff --git a/src/evidently/metrics/data_drift/target_by_features_table.py b/src/evidently/metrics/data_drift/target_by_features_table.py index 9049fe3c3f..d99daa1245 100644 --- a/src/evidently/metrics/data_drift/target_by_features_table.py +++ b/src/evidently/metrics/data_drift/target_by_features_table.py @@ -1,4 +1,5 @@ import json +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -33,16 +34,15 @@ class TargetByFeaturesTableResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:TargetByFeaturesTableResults" - dict_include = False - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "target_name": {IncludeTags.Parameter}, - "columns": {IncludeTags.Parameter}, - "task": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:TargetByFeaturesTableResults" + __dict_include__: ClassVar = False + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "target_name": {IncludeTags.Parameter}, + "columns": {IncludeTags.Parameter}, + "task": {IncludeTags.Parameter}, + } current: StatsByFeature reference: Optional[StatsByFeature] @@ -52,8 +52,7 @@ class Config: class TargetByFeaturesTable(UsesRawDataMixin, Metric[TargetByFeaturesTableResults]): - class Config: - type_alias = "evidently:metric:TargetByFeaturesTable" + __type_alias__: ClassVar = "evidently:metric:TargetByFeaturesTable" columns: Optional[List[str]] _text_features_gen: Optional[ diff --git a/src/evidently/metrics/data_drift/text_descriptors_drift_metric.py b/src/evidently/metrics/data_drift/text_descriptors_drift_metric.py index 78ae9321c3..5609a00b02 100644 --- a/src/evidently/metrics/data_drift/text_descriptors_drift_metric.py +++ b/src/evidently/metrics/data_drift/text_descriptors_drift_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -43,8 +44,7 @@ class TextDescriptorsDriftMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:TextDescriptorsDriftMetricResults" + __type_alias__: ClassVar = "evidently:metric_result:TextDescriptorsDriftMetricResults" number_of_columns: int number_of_drifted_columns: int @@ -55,8 +55,7 @@ class Config: class TextDescriptorsDriftMetric(UsesRawDataMixin, Metric[TextDescriptorsDriftMetricResults]): - class Config: - type_alias = "evidently:metric:TextDescriptorsDriftMetric" + __type_alias__: ClassVar = "evidently:metric:TextDescriptorsDriftMetric" column_name: str stattest: Optional[PossibleStatTestType] = None diff --git a/src/evidently/metrics/data_drift/text_domain_classifier_drift_metric.py b/src/evidently/metrics/data_drift/text_domain_classifier_drift_metric.py index 01c7eb7a9c..29878c5d42 100644 --- a/src/evidently/metrics/data_drift/text_domain_classifier_drift_metric.py +++ b/src/evidently/metrics/data_drift/text_domain_classifier_drift_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Tuple @@ -26,21 +27,19 @@ class TextDomainField(MetricResult): - class Config: - type_alias = "evidently:metric_result:TextDomainField" + __type_alias__: ClassVar = "evidently:metric_result:TextDomainField" characteristic_examples: Optional[List[str]] characteristic_words: Optional[List[str]] class TextDomainClassifierDriftResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:TextDomainClassifierDriftResult" - field_tags = { - "current": {IncludeTags.Current, IncludeTags.Extra}, - "reference": {IncludeTags.Reference, IncludeTags.Extra}, - "text_column_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:TextDomainClassifierDriftResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current, IncludeTags.Extra}, + "reference": {IncludeTags.Reference, IncludeTags.Extra}, + "text_column_name": {IncludeTags.Parameter}, + } text_column_name: str domain_classifier_roc_auc: float @@ -51,8 +50,7 @@ class Config: class TextDomainClassifierDriftMetric(Metric[TextDomainClassifierDriftResult]): - class Config: - type_alias = "evidently:metric:TextDomainClassifierDriftMetric" + __type_alias__: ClassVar = "evidently:metric:TextDomainClassifierDriftMetric" text_column_name: str diff --git a/src/evidently/metrics/data_drift/text_metric.py b/src/evidently/metrics/data_drift/text_metric.py index 24a7f7b5d8..62fdcccfe9 100644 --- a/src/evidently/metrics/data_drift/text_metric.py +++ b/src/evidently/metrics/data_drift/text_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from evidently.base_metric import InputData @@ -12,17 +13,15 @@ class CommentResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:CommentResults" - dict_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:CommentResults" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} text: str class Comment(Metric[CommentResults]): - class Config: - type_alias = "evidently:metric:Comment" + __type_alias__: ClassVar = "evidently:metric:Comment" text: str diff --git a/src/evidently/metrics/data_integrity/column_missing_values_metric.py b/src/evidently/metrics/data_integrity/column_missing_values_metric.py index 431cae96bf..16b2e417e7 100644 --- a/src/evidently/metrics/data_integrity/column_missing_values_metric.py +++ b/src/evidently/metrics/data_integrity/column_missing_values_metric.py @@ -26,10 +26,9 @@ class ColumnMissingValues(MetricResult): """Statistics about missing values in a column""" - class Config: - type_alias = "evidently:metric_result:ColumnMissingValues" - pd_exclude_fields = {"different_missing_values"} - field_tags = {"number_of_rows": {IncludeTags.Extra}, "different_missing_values": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:ColumnMissingValues" + __pd_exclude_fields__: ClassVar = {"different_missing_values"} + __field_tags__: ClassVar = {"number_of_rows": {IncludeTags.Extra}, "different_missing_values": {IncludeTags.Extra}} # count of rows in the column number_of_rows: int @@ -44,13 +43,12 @@ class Config: class ColumnMissingValuesMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnMissingValuesMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnMissingValuesMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + } column_name: str current: ColumnMissingValues @@ -58,8 +56,7 @@ class Config: class ColumnMissingValuesMetric(Metric[ColumnMissingValuesMetricResult]): - class Config: - type_alias = "evidently:metric:ColumnMissingValuesMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnMissingValuesMetric" """Count missing values in a column. diff --git a/src/evidently/metrics/data_integrity/column_regexp_metric.py b/src/evidently/metrics/data_integrity/column_regexp_metric.py index 697188a83e..49aa506aae 100644 --- a/src/evidently/metrics/data_integrity/column_regexp_metric.py +++ b/src/evidently/metrics/data_integrity/column_regexp_metric.py @@ -1,5 +1,6 @@ import collections import re +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -27,15 +28,13 @@ class DataIntegrityValueByRegexpStat(MetricResult): """Statistics about matched by a regular expression values in a column for one dataset""" - class Config: - type_alias = "evidently:metric_result:DataIntegrityValueByRegexpStat" - pd_exclude_fields = {"table_of_matched", "table_of_not_matched"} - - field_tags = { - "number_of_rows": {IncludeTags.Extra}, - "table_of_matched": {IncludeTags.Extra}, - "table_of_not_matched": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:DataIntegrityValueByRegexpStat" + __pd_exclude_fields__: ClassVar = {"table_of_matched", "table_of_not_matched"} + __field_tags__: ClassVar = { + "number_of_rows": {IncludeTags.Extra}, + "table_of_matched": {IncludeTags.Extra}, + "table_of_not_matched": {IncludeTags.Extra}, + } # count of matched values in the column, without NaNs number_of_matched: int @@ -50,15 +49,14 @@ class Config: class DataIntegrityValueByRegexpMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:DataIntegrityValueByRegexpMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - "reg_exp": {IncludeTags.Parameter}, - "top": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:DataIntegrityValueByRegexpMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + "reg_exp": {IncludeTags.Parameter}, + "top": {IncludeTags.Parameter}, + } # name of the column that we check by the regular expression column_name: str @@ -72,8 +70,7 @@ class Config: class ColumnRegExpMetric(Metric[DataIntegrityValueByRegexpMetricResult]): - class Config: - type_alias = "evidently:metric:ColumnRegExpMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnRegExpMetric" """Count number of values in a column matched or not by a regular expression (regexp)""" diff --git a/src/evidently/metrics/data_integrity/column_summary_metric.py b/src/evidently/metrics/data_integrity/column_summary_metric.py index 73b9ad8ad1..03dffaca49 100644 --- a/src/evidently/metrics/data_integrity/column_summary_metric.py +++ b/src/evidently/metrics/data_integrity/column_summary_metric.py @@ -1,5 +1,6 @@ import json import warnings +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -54,8 +55,7 @@ class ColumnCharacteristics(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnCharacteristics" + __type_alias__: ClassVar = "evidently:metric_result:ColumnCharacteristics" number_of_rows: int count: int @@ -64,8 +64,7 @@ class Config: class NumericCharacteristics(ColumnCharacteristics): - class Config: - type_alias = "evidently:metric_result:NumericCharacteristics" + __type_alias__: ClassVar = "evidently:metric_result:NumericCharacteristics" mean: Optional[Numeric] std: Optional[Numeric] @@ -83,8 +82,7 @@ class Config: class CategoricalCharacteristics(ColumnCharacteristics): - class Config: - type_alias = "evidently:metric_result:CategoricalCharacteristics" + __type_alias__: ClassVar = "evidently:metric_result:CategoricalCharacteristics" unique: Optional[int] unique_percentage: Optional[float] @@ -95,8 +93,7 @@ class Config: class DatetimeCharacteristics(ColumnCharacteristics): - class Config: - type_alias = "evidently:metric_result:DatetimeCharacteristics" + __type_alias__: ClassVar = "evidently:metric_result:DatetimeCharacteristics" unique: Optional[int] unique_percentage: Optional[float] @@ -107,8 +104,7 @@ class Config: class TextCharacteristics(ColumnCharacteristics): - class Config: - type_alias = "evidently:metric_result:TextCharacteristics" + __type_alias__: ClassVar = "evidently:metric_result:TextCharacteristics" text_length_min: Optional[float] text_length_mean: Optional[float] @@ -122,17 +118,15 @@ class Config: class DataInTimePlots(MetricResult): - class Config: - type_alias = "evidently:metric_result:DataInTimePlots" - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:DataInTimePlots" + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: pd.DataFrame reference: Optional[pd.DataFrame] class DataInTime(MetricResult): - class Config: - type_alias = "evidently:metric_result:DataInTime" + __type_alias__: ClassVar = "evidently:metric_result:DataInTime" data_for_plots: DataInTimePlots freq: str @@ -140,9 +134,8 @@ class Config: class DataByTarget(MetricResult): - class Config: - type_alias = "evidently:metric_result:DataByTarget" - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:DataByTarget" + __smart_union__: ClassVar = True box_data: Optional[Dict[str, dict]] scatter_data: Optional[Dict[str, Dict[str, list]]] @@ -153,11 +146,10 @@ class Config: class DataQualityPlot(MetricResult): - class Config: - type_alias = "evidently:metric_result:DataQualityPlot" - dict_include = False - pd_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:DataQualityPlot" + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} bins_for_hist: Optional[Histogram] data_in_time: Optional[DataInTime] @@ -328,17 +320,12 @@ def _split_periods(curr_data: pd.DataFrame, ref_data: pd.DataFrame, feature_name class ColumnSummaryResult(ColumnMetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnSummaryResult" - pd_name_mapping = { - "reference_characteristics": "reference", - "current_characteristics": "current", - } - - field_tags = { - "current_characteristics": {IncludeTags.Current}, - "reference_characteristics": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnSummaryResult" + __pd_name_mapping__: ClassVar = {"reference_characteristics": "reference", "current_characteristics": "current"} + __field_tags__: ClassVar = { + "current_characteristics": {IncludeTags.Current}, + "reference_characteristics": {IncludeTags.Reference}, + } reference_characteristics: Optional[ColumnCharacteristics] current_characteristics: ColumnCharacteristics @@ -346,8 +333,7 @@ class Config: class ColumnSummaryMetric(UsesRawDataMixin, ColumnMetric[ColumnSummaryResult]): - class Config: - type_alias = "evidently:metric:ColumnSummaryMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnSummaryMetric" _generated_text_features: Optional[Dict[str, Union[TextLength, NonLetterCharacterPercentage, OOVWordsPercentage]]] diff --git a/src/evidently/metrics/data_integrity/dataset_missing_values_metric.py b/src/evidently/metrics/data_integrity/dataset_missing_values_metric.py index 27c0aa094a..34580c4887 100644 --- a/src/evidently/metrics/data_integrity/dataset_missing_values_metric.py +++ b/src/evidently/metrics/data_integrity/dataset_missing_values_metric.py @@ -44,27 +44,25 @@ def null_valudator(value): class DatasetMissingValues(MetricResult): """Statistics about missed values in a dataset""" - class Config: - type_alias = "evidently:metric_result:DatasetMissingValues" - pd_exclude_fields = { - "different_missing_values_by_column", - "different_missing_values", - "number_of_different_missing_values_by_column", - "number_of_missing_values_by_column", - "share_of_missing_values_by_column", - "columns_with_missing_values", - } - - field_tags = { - "different_missing_values": {IncludeTags.Extra}, - "different_missing_values_by_column": {IncludeTags.Extra}, - "number_of_different_missing_values_by_column": {IncludeTags.Extra}, - "number_of_missing_values_by_column": {IncludeTags.Extra}, - "share_of_missing_values_by_column": {IncludeTags.Extra}, - "number_of_rows": {IncludeTags.Extra}, - "number_of_columns": {IncludeTags.Extra}, - "columns_with_missing_values": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:DatasetMissingValues" + __pd_exclude_fields__: ClassVar = { + "different_missing_values_by_column", + "different_missing_values", + "number_of_different_missing_values_by_column", + "number_of_missing_values_by_column", + "share_of_missing_values_by_column", + "columns_with_missing_values", + } + __field_tags__: ClassVar = { + "different_missing_values": {IncludeTags.Extra}, + "different_missing_values_by_column": {IncludeTags.Extra}, + "number_of_different_missing_values_by_column": {IncludeTags.Extra}, + "number_of_missing_values_by_column": {IncludeTags.Extra}, + "share_of_missing_values_by_column": {IncludeTags.Extra}, + "number_of_rows": {IncludeTags.Extra}, + "number_of_columns": {IncludeTags.Extra}, + "columns_with_missing_values": {IncludeTags.Extra}, + } # set of different missing values in the dataset different_missing_values: Dict[MissingValue, int] @@ -99,17 +97,15 @@ class Config: class DatasetMissingValuesMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetMissingValuesMetricResult" - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:DatasetMissingValuesMetricResult" + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: DatasetMissingValues reference: Optional[DatasetMissingValues] = None class DatasetMissingValuesMetric(Metric[DatasetMissingValuesMetricResult]): - class Config: - type_alias = "evidently:metric:DatasetMissingValuesMetric" + __type_alias__: ClassVar = "evidently:metric:DatasetMissingValuesMetric" """Count missing values in a dataset. diff --git a/src/evidently/metrics/data_integrity/dataset_summary_metric.py b/src/evidently/metrics/data_integrity/dataset_summary_metric.py index dc121385dc..1bd6cff9c5 100644 --- a/src/evidently/metrics/data_integrity/dataset_summary_metric.py +++ b/src/evidently/metrics/data_integrity/dataset_summary_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -53,20 +54,18 @@ def from_dtype(cls, dtype: Union[np.dtype, ExtensionDtype]): class DatasetSummary(MetricResult): """Columns information in a dataset""" - class Config: - type_alias = "evidently:metric_result:DatasetSummary" - dict_exclude_fields = {"columns_type_data"} - pd_exclude_fields = {"columns_type_data", "nans_by_columns", "number_uniques_by_columns"} - - field_tags = { - "target": {IncludeTags.Parameter}, - "prediction": {IncludeTags.Parameter}, - "date_column": {IncludeTags.Parameter}, - "id_column": {IncludeTags.Parameter}, - "columns_type_data": {IncludeTags.Extra}, - "nans_by_columns": {IncludeTags.Extra}, - "number_uniques_by_columns": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:DatasetSummary" + __dict_exclude_fields__: ClassVar = {"columns_type_data"} + __pd_exclude_fields__: ClassVar = {"columns_type_data", "nans_by_columns", "number_uniques_by_columns"} + __field_tags__: ClassVar = { + "target": {IncludeTags.Parameter}, + "prediction": {IncludeTags.Parameter}, + "date_column": {IncludeTags.Parameter}, + "id_column": {IncludeTags.Parameter}, + "columns_type_data": {IncludeTags.Extra}, + "nans_by_columns": {IncludeTags.Extra}, + "number_uniques_by_columns": {IncludeTags.Extra}, + } target: Optional[str] prediction: Optional[Union[str, Sequence[str]]] @@ -96,13 +95,12 @@ def columns_type(self) -> Dict[Label, np.dtype]: class DatasetSummaryMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetSummaryMetricResult" - field_tags = { - "almost_duplicated_threshold": {IncludeTags.Parameter}, - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:DatasetSummaryMetricResult" + __field_tags__: ClassVar = { + "almost_duplicated_threshold": {IncludeTags.Parameter}, + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + } almost_duplicated_threshold: float current: DatasetSummary @@ -110,8 +108,7 @@ class Config: class DatasetSummaryMetric(Metric[DatasetSummaryMetricResult]): - class Config: - type_alias = "evidently:metric:DatasetSummaryMetric" + __type_alias__: ClassVar = "evidently:metric:DatasetSummaryMetric" """Common dataset(s) columns/features characteristics""" diff --git a/src/evidently/metrics/data_quality/column_category_metric.py b/src/evidently/metrics/data_quality/column_category_metric.py index fa2af32b7a..dc31f6d5b0 100644 --- a/src/evidently/metrics/data_quality/column_category_metric.py +++ b/src/evidently/metrics/data_quality/column_category_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -21,9 +22,8 @@ class CategoryStat(MetricResult): - class Config: - type_alias = "evidently:metric_result:CategoryStat" - field_tags = {"all_num": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:CategoryStat" + __field_tags__: ClassVar = {"all_num": {IncludeTags.Extra}} all_num: int category_num: int @@ -31,24 +31,22 @@ class Config: class CountOfValues(MetricResult): - class Config: - type_alias = "evidently:metric_result:CountOfValues" + __type_alias__: ClassVar = "evidently:metric_result:CountOfValues" current: HistogramData reference: Optional[HistogramData] = None class ColumnCategoryMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnCategoryMetricResult" - pd_exclude_fields = {"counts"} - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - "counts": {IncludeTags.Extra}, - } - smart_union = True + __type_alias__: ClassVar = "evidently:metric_result:ColumnCategoryMetricResult" + __pd_exclude_fields__: ClassVar = {"counts"} + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + "counts": {IncludeTags.Extra}, + } + __smart_union__: ClassVar = True def __init__(self, **data) -> None: """for backward compatibility""" @@ -82,9 +80,8 @@ def counts_of_values(self) -> Dict[str, pd.DataFrame]: class ColumnCategoryMetric(Metric[ColumnCategoryMetricResult]): """Calculates count and shares of values in the predefined values list""" - class Config: - type_alias = "evidently:metric:ColumnCategoryMetric" - smart_union = True + __type_alias__: ClassVar = "evidently:metric:ColumnCategoryMetric" + __smart_union__: ClassVar = True column_name: ColumnName category: Union[bool, int, float, str] diff --git a/src/evidently/metrics/data_quality/column_correlations_metric.py b/src/evidently/metrics/data_quality/column_correlations_metric.py index 8f8d6fa968..94a05701dc 100644 --- a/src/evidently/metrics/data_quality/column_correlations_metric.py +++ b/src/evidently/metrics/data_quality/column_correlations_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -26,13 +27,12 @@ class ColumnCorrelationsMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnCorrelationsMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnCorrelationsMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + } column_name: str current: Dict[str, ColumnCorrelations] @@ -55,8 +55,7 @@ def get_pandas(self) -> pd.DataFrame: class ColumnCorrelationsMetric(Metric[ColumnCorrelationsMetricResult]): - class Config: - type_alias = "evidently:metric:ColumnCorrelationsMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnCorrelationsMetric" """Calculates correlations between the selected column and all the other columns. In the current and reference (if presented) datasets""" diff --git a/src/evidently/metrics/data_quality/column_distribution_metric.py b/src/evidently/metrics/data_quality/column_distribution_metric.py index eb8f9ab32f..61bed86088 100644 --- a/src/evidently/metrics/data_quality/column_distribution_metric.py +++ b/src/evidently/metrics/data_quality/column_distribution_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -24,13 +25,12 @@ class ColumnDistributionMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnDistributionMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnDistributionMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + } column_name: str current: Distribution @@ -38,8 +38,7 @@ class Config: class ColumnDistributionMetric(Metric[ColumnDistributionMetricResult]): - class Config: - type_alias = "evidently:metric:ColumnDistributionMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnDistributionMetric" """Calculates distribution for the column""" diff --git a/src/evidently/metrics/data_quality/column_quantile_metric.py b/src/evidently/metrics/data_quality/column_quantile_metric.py index af0ec30af3..3c58ddca0f 100644 --- a/src/evidently/metrics/data_quality/column_quantile_metric.py +++ b/src/evidently/metrics/data_quality/column_quantile_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -27,8 +28,7 @@ class QuantileStats(MetricResult): - class Config: - type_alias = "evidently:metric_result:QuantileStats" + __type_alias__: ClassVar = "evidently:metric_result:QuantileStats" value: float # calculated value of the quantile @@ -37,13 +37,12 @@ class Config: class ColumnQuantileMetricResult(ColumnMetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnQuantileMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "quantile": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnQuantileMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "quantile": {IncludeTags.Parameter}, + } # range of the quantile (from 0 to 1) quantile: float @@ -52,8 +51,7 @@ class Config: class ColumnQuantileMetric(Metric[ColumnQuantileMetricResult]): - class Config: - type_alias = "evidently:metric:ColumnQuantileMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnQuantileMetric" """Calculates quantile with specified range""" diff --git a/src/evidently/metrics/data_quality/column_value_list_metric.py b/src/evidently/metrics/data_quality/column_value_list_metric.py index 6bba50477d..36f2d37437 100644 --- a/src/evidently/metrics/data_quality/column_value_list_metric.py +++ b/src/evidently/metrics/data_quality/column_value_list_metric.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import List from typing import Optional from typing import Tuple @@ -24,13 +25,12 @@ class ValueListStat(MetricResult): - class Config: - type_alias = "evidently:metric_result:ValueListStat" - field_tags = { - "values_in_list_dist": {IncludeTags.Extra}, - "values_not_in_list_dist": {IncludeTags.Extra}, - "rows_count": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:ValueListStat" + __field_tags__: ClassVar = { + "values_in_list_dist": {IncludeTags.Extra}, + "values_not_in_list_dist": {IncludeTags.Extra}, + "rows_count": {IncludeTags.Extra}, + } def __init__(self, **data: Any): if "values_in_list" in data: @@ -64,14 +64,13 @@ def values_not_in_list(self) -> List[Tuple[Any, int]]: class ColumnValueListMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnValueListMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - "values": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnValueListMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + "values": {IncludeTags.Parameter}, + } column_name: str values: List[Any] @@ -80,8 +79,7 @@ class Config: class ColumnValueListMetric(Metric[ColumnValueListMetricResult]): - class Config: - type_alias = "evidently:metric:ColumnValueListMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnValueListMetric" """Calculates count and shares of values in the predefined values list""" diff --git a/src/evidently/metrics/data_quality/column_value_range_metric.py b/src/evidently/metrics/data_quality/column_value_range_metric.py index 6aa1817b78..fc42352a0d 100644 --- a/src/evidently/metrics/data_quality/column_value_range_metric.py +++ b/src/evidently/metrics/data_quality/column_value_range_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -31,9 +32,8 @@ class ValuesInRangeStat(MetricResult): - class Config: - type_alias = "evidently:metric_result:ValuesInRangeStat" - field_tags = {"number_of_values": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:ValuesInRangeStat" + __field_tags__: ClassVar = {"number_of_values": {IncludeTags.Extra}} number_in_range: int number_not_in_range: int @@ -45,15 +45,14 @@ class Config: class ColumnValueRangeMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ColumnValueRangeMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - "left": {IncludeTags.Parameter}, - "right": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:ColumnValueRangeMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + "left": {IncludeTags.Parameter}, + "right": {IncludeTags.Parameter}, + } column_name: str left: Numeric @@ -63,8 +62,7 @@ class Config: class ColumnValueRangeMetric(Metric[ColumnValueRangeMetricResult]): - class Config: - type_alias = "evidently:metric:ColumnValueRangeMetric" + __type_alias__: ClassVar = "evidently:metric:ColumnValueRangeMetric" """Calculates count and shares of values in the predefined values range""" diff --git a/src/evidently/metrics/data_quality/conflict_prediction_metric.py b/src/evidently/metrics/data_quality/conflict_prediction_metric.py index ff096bc614..cb760f46c1 100644 --- a/src/evidently/metrics/data_quality/conflict_prediction_metric.py +++ b/src/evidently/metrics/data_quality/conflict_prediction_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -15,25 +16,22 @@ class ConflictPredictionData(MetricResult): - class Config: - type_alias = "evidently:metric_result:ConflictPredictionData" + __type_alias__: ClassVar = "evidently:metric_result:ConflictPredictionData" number_not_stable_prediction: int share_not_stable_prediction: float class ConflictPredictionMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ConflictPredictionMetricResults" - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:ConflictPredictionMetricResults" + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: ConflictPredictionData reference: Optional[ConflictPredictionData] class ConflictPredictionMetric(Metric[ConflictPredictionMetricResults]): - class Config: - type_alias = "evidently:metric:ConflictPredictionMetric" + __type_alias__: ClassVar = "evidently:metric:ConflictPredictionMetric" def calculate(self, data: InputData) -> ConflictPredictionMetricResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/data_quality/conflict_target_metric.py b/src/evidently/metrics/data_quality/conflict_target_metric.py index cf30121e98..e0e5100d04 100644 --- a/src/evidently/metrics/data_quality/conflict_target_metric.py +++ b/src/evidently/metrics/data_quality/conflict_target_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -15,14 +16,13 @@ class ConflictTargetMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:ConflictTargetMetricResults" - field_tags = { - "number_not_stable_target": {IncludeTags.Current}, - "share_not_stable_target": {IncludeTags.Current}, - "number_not_stable_target_ref": {IncludeTags.Reference}, - "share_not_stable_target_ref": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:ConflictTargetMetricResults" + __field_tags__: ClassVar = { + "number_not_stable_target": {IncludeTags.Current}, + "share_not_stable_target": {IncludeTags.Current}, + "number_not_stable_target_ref": {IncludeTags.Reference}, + "share_not_stable_target_ref": {IncludeTags.Reference}, + } number_not_stable_target: int share_not_stable_target: float @@ -31,8 +31,7 @@ class Config: class ConflictTargetMetric(Metric[ConflictTargetMetricResults]): - class Config: - type_alias = "evidently:metric:ConflictTargetMetric" + __type_alias__: ClassVar = "evidently:metric:ConflictTargetMetric" def calculate(self, data: InputData) -> ConflictTargetMetricResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/data_quality/dataset_correlations_metric.py b/src/evidently/metrics/data_quality/dataset_correlations_metric.py index c24528baf5..f21d2db215 100644 --- a/src/evidently/metrics/data_quality/dataset_correlations_metric.py +++ b/src/evidently/metrics/data_quality/dataset_correlations_metric.py @@ -1,4 +1,5 @@ import copy +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -33,14 +34,13 @@ class CorrelationStats(MetricResult): - class Config: - type_alias = "evidently:metric_result:CorrelationStats" - field_tags = { - "abs_max_target_features_correlation": {IncludeTags.Extra}, - "abs_max_prediction_features_correlation": {IncludeTags.Extra}, - "abs_max_correlation": {IncludeTags.Extra}, - "abs_max_features_correlation": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:CorrelationStats" + __field_tags__: ClassVar = { + "abs_max_target_features_correlation": {IncludeTags.Extra}, + "abs_max_prediction_features_correlation": {IncludeTags.Extra}, + "abs_max_correlation": {IncludeTags.Extra}, + "abs_max_features_correlation": {IncludeTags.Extra}, + } target_prediction_correlation: Optional[float] = None abs_max_target_features_correlation: Optional[float] = None @@ -50,13 +50,11 @@ class Config: class DatasetCorrelation(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetCorrelation" - dict_exclude_fields = {"correlation", "correlations_calculate"} - pd_include = False - pd_exclude_fields = {"correlation", "correlations_calculate"} - - field_tags = {"correlations_calculate": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:DatasetCorrelation" + __dict_exclude_fields__: ClassVar = {"correlation", "correlations_calculate"} + __pd_include__: ClassVar = False + __pd_exclude_fields__: ClassVar = {"correlation", "correlations_calculate"} + __field_tags__: ClassVar = {"correlations_calculate": {IncludeTags.Extra}} correlation: Dict[str, pd.DataFrame] stats: Dict[str, CorrelationStats] @@ -64,15 +62,14 @@ class Config: class DatasetCorrelationsMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:DatasetCorrelationsMetricResult" - dict_exclude_fields = {"target_correlation"} - pd_exclude_fields = {"target_correlation"} - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "target_correlation": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:DatasetCorrelationsMetricResult" + __dict_exclude_fields__: ClassVar = {"target_correlation"} + __pd_exclude_fields__: ClassVar = {"target_correlation"} + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "target_correlation": {IncludeTags.Parameter}, + } current: DatasetCorrelation reference: Optional[DatasetCorrelation] @@ -80,8 +77,7 @@ class Config: class DatasetCorrelationsMetric(Metric[DatasetCorrelationsMetricResult]): - class Config: - type_alias = "evidently:metric:DatasetCorrelationsMetric" + __type_alias__: ClassVar = "evidently:metric:DatasetCorrelationsMetric" """Calculate different correlations with target, predictions and features""" diff --git a/src/evidently/metrics/data_quality/stability_metric.py b/src/evidently/metrics/data_quality/stability_metric.py index 2ee4a8b4df..4a6d880888 100644 --- a/src/evidently/metrics/data_quality/stability_metric.py +++ b/src/evidently/metrics/data_quality/stability_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -13,16 +14,14 @@ class DataQualityStabilityMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:DataQualityStabilityMetricResult" + __type_alias__: ClassVar = "evidently:metric_result:DataQualityStabilityMetricResult" number_not_stable_target: Optional[int] = None number_not_stable_prediction: Optional[int] = None class DataQualityStabilityMetric(Metric[DataQualityStabilityMetricResult]): - class Config: - type_alias = "evidently:metric:DataQualityStabilityMetric" + __type_alias__: ClassVar = "evidently:metric:DataQualityStabilityMetric" """Calculates stability by target and prediction""" diff --git a/src/evidently/metrics/data_quality/text_descriptors_correlation_metric.py b/src/evidently/metrics/data_quality/text_descriptors_correlation_metric.py index 22ebfa7c58..8dd1926a42 100644 --- a/src/evidently/metrics/data_quality/text_descriptors_correlation_metric.py +++ b/src/evidently/metrics/data_quality/text_descriptors_correlation_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -29,14 +30,13 @@ class TextDescriptorsCorrelationMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:TextDescriptorsCorrelationMetricResult" - pd_include = False - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:TextDescriptorsCorrelationMetricResult" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + } column_name: str current: Dict[str, Dict[str, ColumnCorrelations]] @@ -44,8 +44,7 @@ class Config: class TextDescriptorsCorrelationMetric(Metric[TextDescriptorsCorrelationMetricResult]): - class Config: - type_alias = "evidently:metric:TextDescriptorsCorrelationMetric" + __type_alias__: ClassVar = "evidently:metric:TextDescriptorsCorrelationMetric" """Calculates correlations between each auto-generated text feature for column_name and other dataset columns""" diff --git a/src/evidently/metrics/data_quality/text_descriptors_distribution.py b/src/evidently/metrics/data_quality/text_descriptors_distribution.py index 891f6a7f1c..6b330cc496 100644 --- a/src/evidently/metrics/data_quality/text_descriptors_distribution.py +++ b/src/evidently/metrics/data_quality/text_descriptors_distribution.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -29,14 +30,13 @@ class TextDescriptorsDistributionResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:TextDescriptorsDistributionResult" - pd_include = False - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "column_name": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:TextDescriptorsDistributionResult" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "column_name": {IncludeTags.Parameter}, + } column_name: str current: Dict[str, Distribution] @@ -44,8 +44,7 @@ class Config: class TextDescriptorsDistribution(Metric[TextDescriptorsDistributionResult]): - class Config: - type_alias = "evidently:metric:TextDescriptorsDistribution" + __type_alias__: ClassVar = "evidently:metric:TextDescriptorsDistribution" """Calculates distribution for the column""" diff --git a/src/evidently/metrics/recsys/base_top_k.py b/src/evidently/metrics/recsys/base_top_k.py index 24c4f6f666..f46419175a 100644 --- a/src/evidently/metrics/recsys/base_top_k.py +++ b/src/evidently/metrics/recsys/base_top_k.py @@ -1,4 +1,5 @@ import abc +from typing import ClassVar from typing import List from typing import Optional @@ -21,13 +22,12 @@ class TopKMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:TopKMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "k": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:TopKMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "k": {IncludeTags.Parameter}, + } k: int current: pd.Series diff --git a/src/evidently/metrics/recsys/diversity.py b/src/evidently/metrics/recsys/diversity.py index 342ecde007..c48eae2901 100644 --- a/src/evidently/metrics/recsys/diversity.py +++ b/src/evidently/metrics/recsys/diversity.py @@ -1,4 +1,5 @@ from itertools import combinations +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -28,15 +29,14 @@ class DiversityMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:DiversityMetricResult" - field_tags = { - "k": {IncludeTags.Parameter}, - "current_value": {IncludeTags.Current}, - "current_distr": {IncludeTags.Current}, - "reference_value": {IncludeTags.Reference}, - "reference_distr": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:DiversityMetricResult" + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "current_value": {IncludeTags.Current}, + "current_distr": {IncludeTags.Current}, + "reference_value": {IncludeTags.Reference}, + "reference_distr": {IncludeTags.Reference}, + } k: int current_value: float @@ -46,8 +46,7 @@ class Config: class DiversityMetric(Metric[DiversityMetricResult]): - class Config: - type_alias = "evidently:metric:DiversityMetric" + __type_alias__: ClassVar = "evidently:metric:DiversityMetric" """Intra list diversity""" diff --git a/src/evidently/metrics/recsys/f_beta_top_k.py b/src/evidently/metrics/recsys/f_beta_top_k.py index b6a32c4d51..7e698a06c7 100644 --- a/src/evidently/metrics/recsys/f_beta_top_k.py +++ b/src/evidently/metrics/recsys/f_beta_top_k.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Optional import numpy as np @@ -13,8 +14,7 @@ class FBetaTopKMetric(TopKMetric): - class Config: - type_alias = "evidently:metric:FBetaTopKMetric" + __type_alias__: ClassVar = "evidently:metric:FBetaTopKMetric" k: int beta: Optional[float] diff --git a/src/evidently/metrics/recsys/hit_rate_k.py b/src/evidently/metrics/recsys/hit_rate_k.py index 1eb8065f57..02669d25aa 100644 --- a/src/evidently/metrics/recsys/hit_rate_k.py +++ b/src/evidently/metrics/recsys/hit_rate_k.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Optional import pandas as pd @@ -13,13 +14,12 @@ class HitRateKMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:HitRateKMetricResult" - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "k": {IncludeTags.Parameter}, - } + __type_alias__: ClassVar = "evidently:metric_result:HitRateKMetricResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "k": {IncludeTags.Parameter}, + } k: int current: pd.Series @@ -27,8 +27,7 @@ class Config: class HitRateKMetric(Metric[HitRateKMetricResult]): - class Config: - type_alias = "evidently:metric:HitRateKMetric" + __type_alias__: ClassVar = "evidently:metric:HitRateKMetric" k: int min_rel_score: Optional[int] diff --git a/src/evidently/metrics/recsys/item_bias.py b/src/evidently/metrics/recsys/item_bias.py index 67ccecc38d..ab619b65a2 100644 --- a/src/evidently/metrics/recsys/item_bias.py +++ b/src/evidently/metrics/recsys/item_bias.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -21,16 +22,15 @@ class ItemBiasMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ItemBiasMetricResult" - field_tags = { - "k": {IncludeTags.Parameter}, - "column_name": {IncludeTags.Parameter}, - "current_train_distr": {IncludeTags.Current}, - "current_distr": {IncludeTags.Current}, - "reference_train_distr": {IncludeTags.Reference}, - "reference_distr": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:ItemBiasMetricResult" + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "column_name": {IncludeTags.Parameter}, + "current_train_distr": {IncludeTags.Current}, + "current_distr": {IncludeTags.Current}, + "reference_train_distr": {IncludeTags.Reference}, + "reference_distr": {IncludeTags.Reference}, + } k: int column_name: str @@ -41,8 +41,7 @@ class Config: class ItemBiasMetric(Metric[ItemBiasMetricResult]): - class Config: - type_alias = "evidently:metric:ItemBiasMetric" + __type_alias__: ClassVar = "evidently:metric:ItemBiasMetric" k: int column_name: str diff --git a/src/evidently/metrics/recsys/map_k.py b/src/evidently/metrics/recsys/map_k.py index 9ffc38d9e1..3ee60e35b2 100644 --- a/src/evidently/metrics/recsys/map_k.py +++ b/src/evidently/metrics/recsys/map_k.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.metrics.recsys.base_top_k import TopKMetric from evidently.metrics.recsys.base_top_k import TopKMetricRenderer from evidently.renderers.base_renderer import default_renderer class MAPKMetric(TopKMetric): - class Config: - type_alias = "evidently:metric:MAPKMetric" + __type_alias__: ClassVar = "evidently:metric:MAPKMetric" def key(self): return "map" diff --git a/src/evidently/metrics/recsys/mar_k.py b/src/evidently/metrics/recsys/mar_k.py index 425613a2b3..fd32671ccb 100644 --- a/src/evidently/metrics/recsys/mar_k.py +++ b/src/evidently/metrics/recsys/mar_k.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.metrics.recsys.base_top_k import TopKMetric from evidently.metrics.recsys.base_top_k import TopKMetricRenderer from evidently.renderers.base_renderer import default_renderer class MARKMetric(TopKMetric): - class Config: - type_alias = "evidently:metric:MARKMetric" + __type_alias__: ClassVar = "evidently:metric:MARKMetric" def key(self): return "mar" diff --git a/src/evidently/metrics/recsys/mrr.py b/src/evidently/metrics/recsys/mrr.py index 53cd05f9d2..d1ead52895 100644 --- a/src/evidently/metrics/recsys/mrr.py +++ b/src/evidently/metrics/recsys/mrr.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Optional import pandas as pd @@ -13,13 +14,12 @@ class MRRKMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:MRRKMetricResult" - field_tags = { - "k": {IncludeTags.Parameter}, - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:MRRKMetricResult" + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + } k: int current: pd.Series @@ -27,8 +27,7 @@ class Config: class MRRKMetric(Metric[MRRKMetricResult]): - class Config: - type_alias = "evidently:metric:MRRKMetric" + __type_alias__: ClassVar = "evidently:metric:MRRKMetric" k: int min_rel_score: Optional[int] diff --git a/src/evidently/metrics/recsys/ndcg_k.py b/src/evidently/metrics/recsys/ndcg_k.py index 20b9b254c8..0823564580 100644 --- a/src/evidently/metrics/recsys/ndcg_k.py +++ b/src/evidently/metrics/recsys/ndcg_k.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Optional import numpy as np @@ -13,8 +14,7 @@ class NDCGKMetric(Metric[TopKMetricResult]): - class Config: - type_alias = "evidently:metric:NDCGKMetric" + __type_alias__: ClassVar = "evidently:metric:NDCGKMetric" k: int min_rel_score: Optional[int] diff --git a/src/evidently/metrics/recsys/novelty.py b/src/evidently/metrics/recsys/novelty.py index 666678b799..39cc5c9895 100644 --- a/src/evidently/metrics/recsys/novelty.py +++ b/src/evidently/metrics/recsys/novelty.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -26,15 +27,14 @@ class NoveltyMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:NoveltyMetricResult" - field_tags = { - "k": {IncludeTags.Parameter}, - "current_value": {IncludeTags.Current}, - "current_distr": {IncludeTags.Current}, - "reference_value": {IncludeTags.Reference}, - "reference_distr": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:NoveltyMetricResult" + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "current_value": {IncludeTags.Current}, + "current_distr": {IncludeTags.Current}, + "reference_value": {IncludeTags.Reference}, + "reference_distr": {IncludeTags.Reference}, + } k: int current_value: float @@ -44,8 +44,7 @@ class Config: class NoveltyMetric(Metric[NoveltyMetricResult]): - class Config: - type_alias = "evidently:metric:NoveltyMetric" + __type_alias__: ClassVar = "evidently:metric:NoveltyMetric" """Mean Inverse User Frequency""" diff --git a/src/evidently/metrics/recsys/pairwise_distance.py b/src/evidently/metrics/recsys/pairwise_distance.py index 1866c56082..1e131e6991 100644 --- a/src/evidently/metrics/recsys/pairwise_distance.py +++ b/src/evidently/metrics/recsys/pairwise_distance.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Union @@ -19,18 +20,16 @@ class PairwiseDistanceResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:PairwiseDistanceResult" - pd_include = False - field_tags = {"dist_matrix": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:PairwiseDistanceResult" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = {"dist_matrix": {IncludeTags.Extra}} dist_matrix: np.ndarray name_dict: Dict[Union[int, str], int] class PairwiseDistance(Metric[PairwiseDistanceResult]): - class Config: - type_alias = "evidently:metric:PairwiseDistance" + __type_alias__: ClassVar = "evidently:metric:PairwiseDistance" k: int item_features: List[str] diff --git a/src/evidently/metrics/recsys/personalisation.py b/src/evidently/metrics/recsys/personalisation.py index 3c6b2dc56e..bf56869629 100644 --- a/src/evidently/metrics/recsys/personalisation.py +++ b/src/evidently/metrics/recsys/personalisation.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -25,17 +26,15 @@ class PersonalizationMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:PersonalizationMetricResult" - pd_include = False - - field_tags = { - "k": {IncludeTags.Parameter}, - "current_value": {IncludeTags.Current}, - "current_table": {IncludeTags.Current, IncludeTags.Extra}, - "reference_value": {IncludeTags.Reference}, - "reference_table": {IncludeTags.Reference, IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:PersonalizationMetricResult" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "current_value": {IncludeTags.Current}, + "current_table": {IncludeTags.Current, IncludeTags.Extra}, + "reference_value": {IncludeTags.Reference}, + "reference_table": {IncludeTags.Reference, IncludeTags.Extra}, + } k: int current_value: float @@ -45,8 +44,7 @@ class Config: class PersonalizationMetric(Metric[PersonalizationMetricResult]): - class Config: - type_alias = "evidently:metric:PersonalizationMetric" + __type_alias__: ClassVar = "evidently:metric:PersonalizationMetric" """Mean Inter List""" diff --git a/src/evidently/metrics/recsys/popularity_bias.py b/src/evidently/metrics/recsys/popularity_bias.py index 07698438cb..0023308ee2 100644 --- a/src/evidently/metrics/recsys/popularity_bias.py +++ b/src/evidently/metrics/recsys/popularity_bias.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -26,20 +27,19 @@ class PopularityBiasResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:PopularityBiasResult" - field_tags = { - "k": {IncludeTags.Parameter}, - "normalize_arp": {IncludeTags.Parameter}, - "current_apr": {IncludeTags.Current}, - "current_coverage": {IncludeTags.Current}, - "current_gini": {IncludeTags.Current}, - "current_distr": {IncludeTags.Current}, - "reference_apr": {IncludeTags.Reference}, - "reference_coverage": {IncludeTags.Reference}, - "reference_gini": {IncludeTags.Reference}, - "reference_distr": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:PopularityBiasResult" + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "normalize_arp": {IncludeTags.Parameter}, + "current_apr": {IncludeTags.Current}, + "current_coverage": {IncludeTags.Current}, + "current_gini": {IncludeTags.Current}, + "current_distr": {IncludeTags.Current}, + "reference_apr": {IncludeTags.Reference}, + "reference_coverage": {IncludeTags.Reference}, + "reference_gini": {IncludeTags.Reference}, + "reference_distr": {IncludeTags.Reference}, + } k: int normalize_arp: bool @@ -54,8 +54,7 @@ class Config: class PopularityBias(Metric[PopularityBiasResult]): - class Config: - type_alias = "evidently:metric:PopularityBias" + __type_alias__: ClassVar = "evidently:metric:PopularityBias" """ Average Recommendation Popularity diff --git a/src/evidently/metrics/recsys/precision_recall_k.py b/src/evidently/metrics/recsys/precision_recall_k.py index e40802ee4d..24b1ee6cc4 100644 --- a/src/evidently/metrics/recsys/precision_recall_k.py +++ b/src/evidently/metrics/recsys/precision_recall_k.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -17,18 +18,16 @@ class PrecisionRecallCalculationResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:PrecisionRecallCalculationResult" - pd_include = False - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:PrecisionRecallCalculationResult" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: Dict[str, list] reference: Optional[Dict[str, list]] = None class PrecisionRecallCalculation(Metric[PrecisionRecallCalculationResult]): - class Config: - type_alias = "evidently:metric:PrecisionRecallCalculation" + __type_alias__: ClassVar = "evidently:metric:PrecisionRecallCalculation" max_k: int min_rel_score: Optional[int] diff --git a/src/evidently/metrics/recsys/precision_top_k.py b/src/evidently/metrics/recsys/precision_top_k.py index 701db255b5..1c70aeac6d 100644 --- a/src/evidently/metrics/recsys/precision_top_k.py +++ b/src/evidently/metrics/recsys/precision_top_k.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.metrics.recsys.base_top_k import TopKMetric from evidently.metrics.recsys.base_top_k import TopKMetricRenderer from evidently.renderers.base_renderer import default_renderer class PrecisionTopKMetric(TopKMetric): - class Config: - type_alias = "evidently:metric:PrecisionTopKMetric" + __type_alias__: ClassVar = "evidently:metric:PrecisionTopKMetric" def key(self): return "precision" diff --git a/src/evidently/metrics/recsys/rec_examples.py b/src/evidently/metrics/recsys/rec_examples.py index 96c9739d16..07520c07d6 100644 --- a/src/evidently/metrics/recsys/rec_examples.py +++ b/src/evidently/metrics/recsys/rec_examples.py @@ -1,4 +1,5 @@ from functools import reduce +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -26,16 +27,15 @@ class RecCasesTableResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RecCasesTableResults" - pd_include = False - field_tags = { - "user_ids": {IncludeTags.Extra}, - "current": {IncludeTags.Current, IncludeTags.Extra}, - "reference": {IncludeTags.Reference}, - "current_train": {IncludeTags.Current, IncludeTags.Extra}, - "reference_train": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:RecCasesTableResults" + __pd_include__: ClassVar = False + __field_tags__: ClassVar = { + "user_ids": {IncludeTags.Extra}, + "current": {IncludeTags.Current, IncludeTags.Extra}, + "reference": {IncludeTags.Reference}, + "current_train": {IncludeTags.Current, IncludeTags.Extra}, + "reference_train": {IncludeTags.Reference}, + } user_ids: List[str] current: Dict[str, pd.DataFrame] @@ -45,8 +45,7 @@ class Config: class RecCasesTable(Metric[RecCasesTableResults]): - class Config: - type_alias = "evidently:metric:RecCasesTable" + __type_alias__: ClassVar = "evidently:metric:RecCasesTable" user_ids: Optional[List[Union[int, str]]] display_features: Optional[List[str]] diff --git a/src/evidently/metrics/recsys/recall_top_k.py b/src/evidently/metrics/recsys/recall_top_k.py index eb8fb685ca..3889b11172 100644 --- a/src/evidently/metrics/recsys/recall_top_k.py +++ b/src/evidently/metrics/recsys/recall_top_k.py @@ -1,11 +1,12 @@ +from typing import ClassVar + from evidently.metrics.recsys.base_top_k import TopKMetric from evidently.metrics.recsys.base_top_k import TopKMetricRenderer from evidently.renderers.base_renderer import default_renderer class RecallTopKMetric(TopKMetric): - class Config: - type_alias = "evidently:metric:RecallTopKMetric" + __type_alias__: ClassVar = "evidently:metric:RecallTopKMetric" def key(self): return "recall" diff --git a/src/evidently/metrics/recsys/scores_distribution.py b/src/evidently/metrics/recsys/scores_distribution.py index 66a1188216..50d1123ba1 100644 --- a/src/evidently/metrics/recsys/scores_distribution.py +++ b/src/evidently/metrics/recsys/scores_distribution.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Tuple @@ -27,17 +28,16 @@ class ScoreDistributionResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:ScoreDistributionResult" - field_tags = { - "k": {IncludeTags.Parameter}, - "current_top_k_distr": {IncludeTags.Current}, - "current_other_distr": {IncludeTags.Current}, - "current_entropy": {IncludeTags.Current}, - "reference_top_k_distr": {IncludeTags.Reference}, - "reference_other_distr": {IncludeTags.Reference}, - "reference_entropy": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:ScoreDistributionResult" + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "current_top_k_distr": {IncludeTags.Current}, + "current_other_distr": {IncludeTags.Current}, + "current_entropy": {IncludeTags.Current}, + "reference_top_k_distr": {IncludeTags.Reference}, + "reference_other_distr": {IncludeTags.Reference}, + "reference_entropy": {IncludeTags.Reference}, + } k: int current_top_k_distr: Distribution @@ -49,8 +49,7 @@ class Config: class ScoreDistribution(Metric[ScoreDistributionResult]): - class Config: - type_alias = "evidently:metric:ScoreDistribution" + __type_alias__: ClassVar = "evidently:metric:ScoreDistribution" k: int diff --git a/src/evidently/metrics/recsys/serendipity.py b/src/evidently/metrics/recsys/serendipity.py index f655849904..83b2d6e7cf 100644 --- a/src/evidently/metrics/recsys/serendipity.py +++ b/src/evidently/metrics/recsys/serendipity.py @@ -1,4 +1,5 @@ from itertools import product +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -28,15 +29,14 @@ class SerendipityMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:SerendipityMetricResult" - field_tags = { - "k": {IncludeTags.Parameter}, - "current_value": {IncludeTags.Current}, - "current_distr": {IncludeTags.Current}, - "reference_value": {IncludeTags.Reference}, - "reference_distr": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:SerendipityMetricResult" + __field_tags__: ClassVar = { + "k": {IncludeTags.Parameter}, + "current_value": {IncludeTags.Current}, + "current_distr": {IncludeTags.Current}, + "reference_value": {IncludeTags.Reference}, + "reference_distr": {IncludeTags.Reference}, + } k: int current_value: float @@ -46,8 +46,7 @@ class Config: class SerendipityMetric(Metric[SerendipityMetricResult]): - class Config: - type_alias = "evidently:metric:SerendipityMetric" + __type_alias__: ClassVar = "evidently:metric:SerendipityMetric" """unusualness * relevance""" diff --git a/src/evidently/metrics/recsys/train_stats.py b/src/evidently/metrics/recsys/train_stats.py index 7dcb35b01d..972c1d1bc0 100644 --- a/src/evidently/metrics/recsys/train_stats.py +++ b/src/evidently/metrics/recsys/train_stats.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -14,14 +15,13 @@ class TrainStatsResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:TrainStatsResult" - field_tags = { - "current": {IncludeTags.Current}, - "current_n_users": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "reference_n_users": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:TrainStatsResult" + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "current_n_users": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "reference_n_users": {IncludeTags.Reference}, + } current: pd.Series current_n_users: int @@ -30,8 +30,7 @@ class Config: class TrainStats(Metric[TrainStatsResult]): - class Config: - type_alias = "evidently:metric:TrainStats" + __type_alias__: ClassVar = "evidently:metric:TrainStats" """Calculates the number of times each item has been rated in the training set""" diff --git a/src/evidently/metrics/recsys/user_bias.py b/src/evidently/metrics/recsys/user_bias.py index 9e66477e27..ac9a400323 100644 --- a/src/evidently/metrics/recsys/user_bias.py +++ b/src/evidently/metrics/recsys/user_bias.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -19,15 +20,14 @@ class UserBiasMetricResult(MetricResult): - class Config: - type_alias = "evidently:metric_result:UserBiasMetricResult" - field_tags = { - "column_name": {IncludeTags.Parameter}, - "current_train_distr": {IncludeTags.Current}, - "current_distr": {IncludeTags.Current}, - "reference_train_distr": {IncludeTags.Reference}, - "reference_distr": {IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:UserBiasMetricResult" + __field_tags__: ClassVar = { + "column_name": {IncludeTags.Parameter}, + "current_train_distr": {IncludeTags.Current}, + "current_distr": {IncludeTags.Current}, + "reference_train_distr": {IncludeTags.Reference}, + "reference_distr": {IncludeTags.Reference}, + } column_name: str current_train_distr: Distribution @@ -37,8 +37,7 @@ class Config: class UserBiasMetric(Metric[UserBiasMetricResult]): - class Config: - type_alias = "evidently:metric:UserBiasMetric" + __type_alias__: ClassVar = "evidently:metric:UserBiasMetric" column_name: str diff --git a/src/evidently/metrics/regression_performance/abs_perc_error_in_time.py b/src/evidently/metrics/regression_performance/abs_perc_error_in_time.py index 117f09bc99..821d2e94ce 100644 --- a/src/evidently/metrics/regression_performance/abs_perc_error_in_time.py +++ b/src/evidently/metrics/regression_performance/abs_perc_error_in_time.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -24,8 +25,7 @@ class RegressionAbsPercentageErrorPlot(UsesRawDataMixin, Metric[ColumnScatterResult]): - class Config: - type_alias = "evidently:metric:RegressionAbsPercentageErrorPlot" + __type_alias__: ClassVar = "evidently:metric:RegressionAbsPercentageErrorPlot" def __init__(self, options: AnyOptions = None): super().__init__(options=options) diff --git a/src/evidently/metrics/regression_performance/error_bias_table.py b/src/evidently/metrics/regression_performance/error_bias_table.py index 1472af241f..dadd1cdfc8 100644 --- a/src/evidently/metrics/regression_performance/error_bias_table.py +++ b/src/evidently/metrics/regression_performance/error_bias_table.py @@ -35,28 +35,26 @@ class RegressionErrorBiasTableResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionErrorBiasTableResults" - dict_exclude_fields = {"current_plot_data", "reference_plot_data"} - pd_exclude_fields = { - "current_plot_data", - "reference_plot_data", - "num_feature_names", - "cat_feature_names", - "error_bias", - "columns", - } - - field_tags = { - "current_plot_data": {IncludeTags.Current, IncludeTags.Render}, - "reference_plot_data": {IncludeTags.Reference, IncludeTags.Render}, - "target_name": {IncludeTags.Parameter}, - "prediction_name": {IncludeTags.Parameter}, - "num_feature_names": {IncludeTags.Parameter}, - "cat_feature_names": {IncludeTags.Parameter}, - "columns": {IncludeTags.Parameter}, - "error_bias": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:RegressionErrorBiasTableResults" + __dict_exclude_fields__: ClassVar = {"current_plot_data", "reference_plot_data"} + __pd_exclude_fields__: ClassVar = { + "current_plot_data", + "reference_plot_data", + "num_feature_names", + "cat_feature_names", + "error_bias", + "columns", + } + __field_tags__: ClassVar = { + "current_plot_data": {IncludeTags.Current, IncludeTags.Render}, + "reference_plot_data": {IncludeTags.Reference, IncludeTags.Render}, + "target_name": {IncludeTags.Parameter}, + "prediction_name": {IncludeTags.Parameter}, + "num_feature_names": {IncludeTags.Parameter}, + "cat_feature_names": {IncludeTags.Parameter}, + "columns": {IncludeTags.Parameter}, + "error_bias": {IncludeTags.Extra}, + } top_error: float current_plot_data: pd.DataFrame @@ -71,8 +69,7 @@ class Config: class RegressionErrorBiasTable(UsesRawDataMixin, Metric[RegressionErrorBiasTableResults]): # by default, we get 5% values for the error bias calculations - class Config: - type_alias = "evidently:metric:RegressionErrorBiasTable" + __type_alias__: ClassVar = "evidently:metric:RegressionErrorBiasTable" TOP_ERROR_DEFAULT: ClassVar[float] = 0.05 TOP_ERROR_MIN: ClassVar[float] = 0 diff --git a/src/evidently/metrics/regression_performance/error_distribution.py b/src/evidently/metrics/regression_performance/error_distribution.py index dea248c614..84069e12fe 100644 --- a/src/evidently/metrics/regression_performance/error_distribution.py +++ b/src/evidently/metrics/regression_performance/error_distribution.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -19,20 +20,17 @@ class RegressionErrorDistributionResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionErrorDistributionResults" - dict_exclude_fields = {"current_bins", "reference_bins"} - pd_exclude_fields = {"current_bins", "reference_bins"} - - field_tags = {"current_bins": {IncludeTags.Current}, "reference_bins": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:RegressionErrorDistributionResults" + __dict_exclude_fields__: ClassVar = {"current_bins", "reference_bins"} + __pd_exclude_fields__: ClassVar = {"current_bins", "reference_bins"} + __field_tags__: ClassVar = {"current_bins": {IncludeTags.Current}, "reference_bins": {IncludeTags.Reference}} current_bins: HistogramData reference_bins: Optional[HistogramData] class RegressionErrorDistribution(Metric[RegressionErrorDistributionResults]): - class Config: - type_alias = "evidently:metric:RegressionErrorDistribution" + __type_alias__: ClassVar = "evidently:metric:RegressionErrorDistribution" def calculate(self, data: InputData) -> RegressionErrorDistributionResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/regression_performance/error_in_time.py b/src/evidently/metrics/regression_performance/error_in_time.py index 50f5dc325e..23c24b510d 100644 --- a/src/evidently/metrics/regression_performance/error_in_time.py +++ b/src/evidently/metrics/regression_performance/error_in_time.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -23,8 +24,7 @@ class RegressionErrorPlot(UsesRawDataMixin, Metric[ColumnScatterResult]): - class Config: - type_alias = "evidently:metric:RegressionErrorPlot" + __type_alias__: ClassVar = "evidently:metric:RegressionErrorPlot" def __init__(self, options: AnyOptions = None): super().__init__(options=options) diff --git a/src/evidently/metrics/regression_performance/error_normality.py b/src/evidently/metrics/regression_performance/error_normality.py index 199086461a..de2f144dbb 100644 --- a/src/evidently/metrics/regression_performance/error_normality.py +++ b/src/evidently/metrics/regression_performance/error_normality.py @@ -1,5 +1,6 @@ import json from typing import Any +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -24,17 +25,20 @@ class RegressionErrorNormalityResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionErrorNormalityResults" - dict_exclude_fields = {"current_plot", "current_theoretical", "reference_plot", "reference_theoretical"} - pd_exclude_fields = {"current_plot", "current_theoretical", "reference_plot", "reference_theoretical"} - - field_tags = { - "current_plot": {IncludeTags.Render, IncludeTags.Current}, - "current_theoretical": {IncludeTags.Extra, IncludeTags.Current}, - "reference_plot": {IncludeTags.Render, IncludeTags.Reference}, - "reference_theoretical": {IncludeTags.Extra, IncludeTags.Reference}, - } + __type_alias__: ClassVar = "evidently:metric_result:RegressionErrorNormalityResults" + __dict_exclude_fields__: ClassVar = { + "current_plot", + "current_theoretical", + "reference_plot", + "reference_theoretical", + } + __pd_exclude_fields__: ClassVar = {"current_plot", "current_theoretical", "reference_plot", "reference_theoretical"} + __field_tags__: ClassVar = { + "current_plot": {IncludeTags.Render, IncludeTags.Current}, + "current_theoretical": {IncludeTags.Extra, IncludeTags.Current}, + "reference_plot": {IncludeTags.Render, IncludeTags.Reference}, + "reference_theoretical": {IncludeTags.Extra, IncludeTags.Reference}, + } current_plot: pd.DataFrame current_theoretical: pd.DataFrame @@ -43,8 +47,7 @@ class Config: class RegressionErrorNormality(UsesRawDataMixin, Metric[RegressionErrorNormalityResults]): - class Config: - type_alias = "evidently:metric:RegressionErrorNormality" + __type_alias__: ClassVar = "evidently:metric:RegressionErrorNormality" def __init__(self, options: AnyOptions = None): super().__init__(options=options) diff --git a/src/evidently/metrics/regression_performance/objects.py b/src/evidently/metrics/regression_performance/objects.py index 0764dd8559..72b9950056 100644 --- a/src/evidently/metrics/regression_performance/objects.py +++ b/src/evidently/metrics/regression_performance/objects.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -12,8 +13,7 @@ class PredActualScatter(MetricResult): - class Config: - type_alias = "evidently:metric_result:PredActualScatter" + __type_alias__: ClassVar = "evidently:metric_result:PredActualScatter" predicted: ScatterData actual: ScatterData @@ -34,8 +34,7 @@ def scatter_as_dict(scatter: Optional[PredActualScatter]) -> Optional[Dict[str, class RegressionScatter(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionScatter" + __type_alias__: ClassVar = "evidently:metric_result:RegressionScatter" underestimation: PredActualScatter majority: PredActualScatter @@ -43,9 +42,8 @@ class Config: class IntervalSeries(MetricResult): - class Config: - type_alias = "evidently:metric_result:IntervalSeries" - underscore_attrs_are_private = True + __type_alias__: ClassVar = "evidently:metric_result:IntervalSeries" + __underscore_attrs_are_private__: ClassVar = True bins: List[float] values: List[float] @@ -75,10 +73,9 @@ def __mul__(self, other: float): class RegressionMetricScatter(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionMetricScatter" - smart_union = True - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:RegressionMetricScatter" + __smart_union__: ClassVar = True + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: IntervalSeries reference: Optional[IntervalSeries] = None @@ -90,8 +87,7 @@ def __mul__(self, other: float): class RegressionMetricsScatter(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionMetricsScatter" + __type_alias__: ClassVar = "evidently:metric_result:RegressionMetricsScatter" r2_score: RegressionMetricScatter rmse: RegressionMetricScatter diff --git a/src/evidently/metrics/regression_performance/predicted_and_actual_in_time.py b/src/evidently/metrics/regression_performance/predicted_and_actual_in_time.py index 03679aacd4..38277340ba 100644 --- a/src/evidently/metrics/regression_performance/predicted_and_actual_in_time.py +++ b/src/evidently/metrics/regression_performance/predicted_and_actual_in_time.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -22,8 +23,7 @@ class RegressionPredictedVsActualPlot(UsesRawDataMixin, Metric[ColumnScatterResult]): - class Config: - type_alias = "evidently:metric:RegressionPredictedVsActualPlot" + __type_alias__: ClassVar = "evidently:metric:RegressionPredictedVsActualPlot" def __init__(self, options: AnyOptions = None): super().__init__(options=options) diff --git a/src/evidently/metrics/regression_performance/predicted_vs_actual.py b/src/evidently/metrics/regression_performance/predicted_vs_actual.py index c11b959e63..c43f28859a 100644 --- a/src/evidently/metrics/regression_performance/predicted_vs_actual.py +++ b/src/evidently/metrics/regression_performance/predicted_vs_actual.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional from typing import Union @@ -28,20 +29,18 @@ class AggPredActualScatter(MetricResult): - class Config: - type_alias = "evidently:metric_result:AggPredActualScatter" - dict_include = False - tags = {IncludeTags.Render} + __type_alias__: ClassVar = "evidently:metric_result:AggPredActualScatter" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} data: Optional[ContourData] class RegressionPredictedVsActualScatterResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionPredictedVsActualScatterResults" - dict_include = False - tags = {IncludeTags.Render} - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:RegressionPredictedVsActualScatterResults" + __dict_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: Union[PredActualScatter, AggPredActualScatter] reference: Optional[Union[PredActualScatter, AggPredActualScatter]] @@ -52,8 +51,7 @@ class Config: class RegressionPredictedVsActualScatter(UsesRawDataMixin, Metric[RegressionPredictedVsActualScatterResults]): - class Config: - type_alias = "evidently:metric:RegressionPredictedVsActualScatter" + __type_alias__: ClassVar = "evidently:metric:RegressionPredictedVsActualScatter" def __init__(self, options: AnyOptions = None): super().__init__(options=options) diff --git a/src/evidently/metrics/regression_performance/regression_dummy_metric.py b/src/evidently/metrics/regression_performance/regression_dummy_metric.py index 209f7497c8..9f329857ca 100644 --- a/src/evidently/metrics/regression_performance/regression_dummy_metric.py +++ b/src/evidently/metrics/regression_performance/regression_dummy_metric.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import List from typing import Optional @@ -21,8 +22,7 @@ class RegressionDummyMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionDummyMetricResults" + __type_alias__: ClassVar = "evidently:metric_result:RegressionDummyMetricResults" rmse_default: float mean_abs_error_default: float @@ -39,8 +39,7 @@ class Config: class RegressionDummyMetric(Metric[RegressionDummyMetricResults]): - class Config: - type_alias = "evidently:metric:RegressionDummyMetric" + __type_alias__: ClassVar = "evidently:metric:RegressionDummyMetric" _quality_metric: RegressionQualityMetric diff --git a/src/evidently/metrics/regression_performance/regression_performance_metrics.py b/src/evidently/metrics/regression_performance/regression_performance_metrics.py index c36a1e66f0..9cf97344a2 100644 --- a/src/evidently/metrics/regression_performance/regression_performance_metrics.py +++ b/src/evidently/metrics/regression_performance/regression_performance_metrics.py @@ -1,3 +1,4 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -31,10 +32,9 @@ class RegressionMetrics(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionMetrics" - pd_exclude_fields = {"underperformance"} - field_tags = {"underperformance": {IncludeTags.Extra}} + __type_alias__: ClassVar = "evidently:metric_result:RegressionMetrics" + __pd_exclude_fields__: ClassVar = {"underperformance"} + __field_tags__: ClassVar = {"underperformance": {IncludeTags.Extra}} r2_score: float rmse: float @@ -46,25 +46,30 @@ class Config: class RegressionPerformanceMetricsResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionPerformanceMetricsResults" - dict_exclude_fields = {"hist_for_plot", "vals_for_plots", "me_hist_for_plot"} - pd_exclude_fields = {"hist_for_plot", "vals_for_plots", "me_hist_for_plot", "error_bias", "error_normality"} - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "rmse_default": {IncludeTags.Extra}, - "me_default_sigma": {IncludeTags.Extra}, - "mean_abs_error_default": {IncludeTags.Extra}, - "mean_abs_perc_error_default": {IncludeTags.Extra}, - "abs_error_max_default": {IncludeTags.Extra}, - "error_std": {IncludeTags.Extra}, - "abs_error_std": {IncludeTags.Extra}, - "abs_perc_error_std": {IncludeTags.Extra}, - "error_normality": {IncludeTags.Extra}, - "vals_for_plots": {IncludeTags.Render}, - "error_bias": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:RegressionPerformanceMetricsResults" + __dict_exclude_fields__: ClassVar = {"hist_for_plot", "vals_for_plots", "me_hist_for_plot"} + __pd_exclude_fields__: ClassVar = { + "hist_for_plot", + "vals_for_plots", + "me_hist_for_plot", + "error_bias", + "error_normality", + } + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "rmse_default": {IncludeTags.Extra}, + "me_default_sigma": {IncludeTags.Extra}, + "mean_abs_error_default": {IncludeTags.Extra}, + "mean_abs_perc_error_default": {IncludeTags.Extra}, + "abs_error_max_default": {IncludeTags.Extra}, + "error_std": {IncludeTags.Extra}, + "abs_error_std": {IncludeTags.Extra}, + "abs_perc_error_std": {IncludeTags.Extra}, + "error_normality": {IncludeTags.Extra}, + "vals_for_plots": {IncludeTags.Render}, + "error_bias": {IncludeTags.Extra}, + } columns: DatasetColumns @@ -88,8 +93,7 @@ class Config: class RegressionPerformanceMetrics(Metric[RegressionPerformanceMetricsResults]): - class Config: - type_alias = "evidently:metric:RegressionPerformanceMetrics" + __type_alias__: ClassVar = "evidently:metric:RegressionPerformanceMetrics" def get_parameters(self) -> tuple: return () diff --git a/src/evidently/metrics/regression_performance/regression_quality.py b/src/evidently/metrics/regression_performance/regression_quality.py index 89d3182968..8da60e5916 100644 --- a/src/evidently/metrics/regression_performance/regression_quality.py +++ b/src/evidently/metrics/regression_performance/regression_quality.py @@ -1,7 +1,7 @@ +from typing import ClassVar from typing import Dict from typing import List from typing import Optional -from typing import Set import numpy as np from sklearn.metrics import mean_absolute_error @@ -33,9 +33,7 @@ class MoreRegressionMetrics(RegressionMetrics): - class Config: - type_alias = "evidently:metric_result:MoreRegressionMetrics" - field_tags: Dict[str, Set[IncludeTags]] = {"underperformance": set()} + __type_alias__: ClassVar = "evidently:metric_result:MoreRegressionMetrics" error_std: float abs_error_std: float @@ -43,22 +41,27 @@ class Config: class RegressionQualityMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionQualityMetricResults" - dict_exclude_fields = {"hist_for_plot", "vals_for_plots", "me_hist_for_plot"} - pd_exclude_fields = {"hist_for_plot", "vals_for_plots", "me_hist_for_plot", "error_normality", "error_bias"} - field_tags = { - "current": {IncludeTags.Current}, - "reference": {IncludeTags.Reference}, - "rmse_default": {IncludeTags.Extra}, - "me_default_sigma": {IncludeTags.Extra}, - "mean_abs_error_default": {IncludeTags.Extra}, - "mean_abs_perc_error_default": {IncludeTags.Extra}, - "abs_error_max_default": {IncludeTags.Extra}, - "error_normality": {IncludeTags.Extra}, - "vals_for_plots": {IncludeTags.Render}, - "error_bias": {IncludeTags.Extra}, - } + __type_alias__: ClassVar = "evidently:metric_result:RegressionQualityMetricResults" + __dict_exclude_fields__: ClassVar = {"hist_for_plot", "vals_for_plots", "me_hist_for_plot"} + __pd_exclude_fields__: ClassVar = { + "hist_for_plot", + "vals_for_plots", + "me_hist_for_plot", + "error_normality", + "error_bias", + } + __field_tags__: ClassVar = { + "current": {IncludeTags.Current}, + "reference": {IncludeTags.Reference}, + "rmse_default": {IncludeTags.Extra}, + "me_default_sigma": {IncludeTags.Extra}, + "mean_abs_error_default": {IncludeTags.Extra}, + "mean_abs_perc_error_default": {IncludeTags.Extra}, + "abs_error_max_default": {IncludeTags.Extra}, + "error_normality": {IncludeTags.Extra}, + "vals_for_plots": {IncludeTags.Render}, + "error_bias": {IncludeTags.Extra}, + } columns: DatasetColumns current: MoreRegressionMetrics @@ -76,8 +79,7 @@ class Config: class RegressionQualityMetric(Metric[RegressionQualityMetricResults]): - class Config: - type_alias = "evidently:metric:RegressionQualityMetric" + __type_alias__: ClassVar = "evidently:metric:RegressionQualityMetric" def calculate(self, data: InputData) -> RegressionQualityMetricResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/metrics/regression_performance/top_error.py b/src/evidently/metrics/regression_performance/top_error.py index cfeeae05d7..a5f422eb10 100644 --- a/src/evidently/metrics/regression_performance/top_error.py +++ b/src/evidently/metrics/regression_performance/top_error.py @@ -1,4 +1,5 @@ import json +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -30,28 +31,25 @@ class TopData(MetricResult): - class Config: - type_alias = "evidently:metric_result:TopData" + __type_alias__: ClassVar = "evidently:metric_result:TopData" mean_err_per_group: Dict[str, Dict[str, float]] scatter: RegressionScatter class AggTopData(MetricResult): - class Config: - type_alias = "evidently:metric_result:AggTopData" + __type_alias__: ClassVar = "evidently:metric_result:AggTopData" mean_err_per_group: Dict[str, Dict[str, float]] contour: Dict[str, ContourData] class RegressionTopErrorMetricResults(MetricResult): - class Config: - type_alias = "evidently:metric_result:RegressionTopErrorMetricResults" - dict_include = False - pd_include = False - tags = {IncludeTags.Render} - field_tags = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} + __type_alias__: ClassVar = "evidently:metric_result:RegressionTopErrorMetricResults" + __dict_include__: ClassVar = False + __pd_include__: ClassVar = False + __tags__: ClassVar = {IncludeTags.Render} + __field_tags__: ClassVar = {"current": {IncludeTags.Current}, "reference": {IncludeTags.Reference}} current: Union[TopData, AggTopData] reference: Optional[Union[TopData, AggTopData]] @@ -62,8 +60,7 @@ class Config: class RegressionTopErrorMetric(UsesRawDataMixin, Metric[RegressionTopErrorMetricResults]): - class Config: - type_alias = "evidently:metric:RegressionTopErrorMetric" + __type_alias__: ClassVar = "evidently:metric:RegressionTopErrorMetric" def calculate(self, data: InputData) -> RegressionTopErrorMetricResults: dataset_columns = process_columns(data.current_data, data.column_mapping) diff --git a/src/evidently/pydantic_utils.py b/src/evidently/pydantic_utils.py index 6bf7fcfa7f..8ab46fc5e0 100644 --- a/src/evidently/pydantic_utils.py +++ b/src/evidently/pydantic_utils.py @@ -81,8 +81,7 @@ def __new__(mcs, name, bases, namespace, **kwargs): class FrozenBaseModel(BaseModel, metaclass=FrozenBaseMeta): - class Config: - underscore_attrs_are_private = True + __underscore_attrs_are_private__: ClassVar = True _init_values: Optional[Dict] @@ -335,10 +334,9 @@ def get_value_fingerprint(value: Any) -> FingerprintPart: class EvidentlyBaseModel(FrozenBaseModel, PolymorphicModel): - class Config: - type_alias = "evidently:base:EvidentlyBaseModel" - alias_required = True - is_base_type = True + __type_alias__: ClassVar = "evidently:base:EvidentlyBaseModel" + __alias_required__: ClassVar = True + __is_base_type__: ClassVar = True def get_fingerprint(self) -> Fingerprint: return hashlib.md5( @@ -364,8 +362,7 @@ def update(self: EBM, **kwargs) -> EBM: @autoregister class WithTestAndMetricDependencies(EvidentlyBaseModel): - class Config: - type_alias = "evidently:test:WithTestAndMetricDependencies" + __type_alias__: ClassVar = "evidently:test:WithTestAndMetricDependencies" def __evidently_dependencies__(self): from evidently.base_metric import Metric @@ -418,8 +415,7 @@ class FieldTags(Enum): class FieldInfo(EnumValueMixin): - class Config: - frozen = True + __frozen__: ClassVar = True path: str tags: FrozenSet[FieldTags] diff --git a/src/evidently/test_preset/classification_binary.py b/src/evidently/test_preset/classification_binary.py index d08a974d8a..35fc5ecb3a 100644 --- a/src/evidently/test_preset/classification_binary.py +++ b/src/evidently/test_preset/classification_binary.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -16,8 +17,7 @@ class BinaryClassificationTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:BinaryClassificationTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:BinaryClassificationTestPreset" """ Binary Classification Tests. diff --git a/src/evidently/test_preset/classification_binary_topk.py b/src/evidently/test_preset/classification_binary_topk.py index 0576ef02ac..67ec83d2aa 100644 --- a/src/evidently/test_preset/classification_binary_topk.py +++ b/src/evidently/test_preset/classification_binary_topk.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -17,8 +18,7 @@ class BinaryClassificationTopKTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:BinaryClassificationTopKTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:BinaryClassificationTopKTestPreset" """ Binary Classification Tests for Top K threshold. diff --git a/src/evidently/test_preset/classification_multiclass.py b/src/evidently/test_preset/classification_multiclass.py index 55fecde560..c330493426 100644 --- a/src/evidently/test_preset/classification_multiclass.py +++ b/src/evidently/test_preset/classification_multiclass.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -18,8 +19,7 @@ class MulticlassClassificationTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:MulticlassClassificationTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:MulticlassClassificationTestPreset" """ Multiclass Classification tests. diff --git a/src/evidently/test_preset/data_drift.py b/src/evidently/test_preset/data_drift.py index 29373e9166..4c56491800 100644 --- a/src/evidently/test_preset/data_drift.py +++ b/src/evidently/test_preset/data_drift.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -20,8 +21,7 @@ class DataDriftTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:DataDriftTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:DataDriftTestPreset" """ Data Drift tests. diff --git a/src/evidently/test_preset/data_quality.py b/src/evidently/test_preset/data_quality.py index b289934377..3a0987d4ee 100644 --- a/src/evidently/test_preset/data_quality.py +++ b/src/evidently/test_preset/data_quality.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -14,8 +15,7 @@ class DataQualityTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:DataQualityTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:DataQualityTestPreset" """ Data Quality tests. diff --git a/src/evidently/test_preset/data_stability.py b/src/evidently/test_preset/data_stability.py index e5074df86b..e72fa9b1fc 100644 --- a/src/evidently/test_preset/data_stability.py +++ b/src/evidently/test_preset/data_stability.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -16,8 +17,7 @@ class DataStabilityTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:DataStabilityTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:DataStabilityTestPreset" """ Data Stability tests. diff --git a/src/evidently/test_preset/no_target_performance.py b/src/evidently/test_preset/no_target_performance.py index 96bccd0fc8..360c448cec 100644 --- a/src/evidently/test_preset/no_target_performance.py +++ b/src/evidently/test_preset/no_target_performance.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -24,8 +25,7 @@ class NoTargetPerformanceTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:NoTargetPerformanceTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:NoTargetPerformanceTestPreset" """ No Target Performance tests. diff --git a/src/evidently/test_preset/recsys.py b/src/evidently/test_preset/recsys.py index cf595f2b76..dd7508c434 100644 --- a/src/evidently/test_preset/recsys.py +++ b/src/evidently/test_preset/recsys.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -14,8 +15,7 @@ class RecsysTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:RecsysTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:RecsysTestPreset" """ Recsys performance tests. diff --git a/src/evidently/test_preset/regression.py b/src/evidently/test_preset/regression.py index 6c68179297..28f5b5466e 100644 --- a/src/evidently/test_preset/regression.py +++ b/src/evidently/test_preset/regression.py @@ -1,4 +1,5 @@ from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -13,8 +14,7 @@ class RegressionTestPreset(TestPreset): - class Config: - type_alias = "evidently:test_preset:RegressionTestPreset" + __type_alias__: ClassVar = "evidently:test_preset:RegressionTestPreset" """ Regression performance tests. diff --git a/src/evidently/test_preset/test_preset.py b/src/evidently/test_preset/test_preset.py index 4afa282c5c..1b0cb264c1 100644 --- a/src/evidently/test_preset/test_preset.py +++ b/src/evidently/test_preset/test_preset.py @@ -1,5 +1,6 @@ import abc from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -14,8 +15,7 @@ class TestPreset(BasePreset): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True @abc.abstractmethod def generate_tests( diff --git a/src/evidently/tests/base_test.py b/src/evidently/tests/base_test.py index bc9f10d556..def425ce24 100644 --- a/src/evidently/tests/base_test.py +++ b/src/evidently/tests/base_test.py @@ -96,16 +96,14 @@ class TestStatus(Enum): class TestParameters(EvidentlyBaseModel, BaseResult): # type: ignore[misc] # pydantic Config - class Config: - type_alias = "evidently:test_parameters:TestParameters" - field_tags = {"type": {IncludeTags.TypeField}} - is_base_type = True + __type_alias__: ClassVar = "evidently:test_parameters:TestParameters" + __field_tags__: ClassVar = {"type": {IncludeTags.TypeField}} + __is_base_type__: ClassVar = True class TestResult(EnumValueMixin, MetricResult): # todo: create common base class # short name/title from the test class - class Config: - type_alias = "evidently:metric_result:TestResult" + __type_alias__: ClassVar = "evidently:metric_result:TestResult" name: str # what was checked, what threshold (current value 13 is not ok with condition less than 5) @@ -144,8 +142,7 @@ def is_passed(self): class Test(WithTestAndMetricDependencies): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True """ all fields in test class with type that is subclass of Metric would be used as dependencies of test. @@ -196,10 +193,9 @@ class TestValueCondition(ExcludeNoneMixin): An object of the class stores specified conditions and can be used for checking a value by them. """ - class Config: - arbitrary_types_allowed = True - use_enum_values = True - smart_union = True + __arbitrary_types_allowed__: ClassVar = True + __use_enum_values__: ClassVar = True + __smart_union__: ClassVar = True eq: Optional[NumericApprox] = None gt: Optional[NumericApprox] = None @@ -279,8 +275,7 @@ def __str__(self) -> str: class ConditionTestParameters(TestParameters): - class Config: - type_alias = "evidently:test_parameters:ConditionTestParameters" + __type_alias__: ClassVar = "evidently:test_parameters:ConditionTestParameters" condition: TestValueCondition @@ -290,11 +285,10 @@ class BaseConditionsTest(Test, TestValueCondition, ABC): Base class for all tests with a condition """ - class Config: - arbitrary_types_allowed = True - use_enum_values = True - smart_union = True - underscore_attrs_are_private = True + __arbitrary_types_allowed__: ClassVar = True + __use_enum_values__: ClassVar = True + __smart_union__: ClassVar = True + __underscore_attrs_are_private__: ClassVar = True # condition: TestValueCondition @@ -313,15 +307,13 @@ def condition(self) -> TestValueCondition: class CheckValueParameters(ConditionTestParameters): - class Config: - type_alias = "evidently:test_parameters:CheckValueParameters" + __type_alias__: ClassVar = "evidently:test_parameters:CheckValueParameters" value: Optional[Numeric] class ColumnCheckValueParameters(CheckValueParameters): - class Config: - type_alias = "evidently:test_parameters:ColumnCheckValueParameters" + __type_alias__: ClassVar = "evidently:test_parameters:ColumnCheckValueParameters" column_name: str diff --git a/src/evidently/tests/classification_performance_tests.py b/src/evidently/tests/classification_performance_tests.py index 0dd981cf63..c0a0cb9bcd 100644 --- a/src/evidently/tests/classification_performance_tests.py +++ b/src/evidently/tests/classification_performance_tests.py @@ -148,8 +148,7 @@ def conf_matrix(self): class TestAccuracyScore(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestAccuracyScore" + __type_alias__: ClassVar = "evidently:test:TestAccuracyScore" name = "Accuracy Score" @@ -172,8 +171,7 @@ def render_html(self, obj: TestAccuracyScore) -> TestHtmlInfo: class TestPrecisionScore(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestPrecisionScore" + __type_alias__: ClassVar = "evidently:test:TestPrecisionScore" name = "Precision Score" @@ -196,8 +194,7 @@ def render_html(self, obj: TestPrecisionScore) -> TestHtmlInfo: class TestF1Score(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestF1Score" + __type_alias__: ClassVar = "evidently:test:TestF1Score" name: ClassVar = "F1 Score" @@ -220,8 +217,7 @@ def render_html(self, obj: TestF1Score) -> TestHtmlInfo: class TestRecallScore(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestRecallScore" + __type_alias__: ClassVar = "evidently:test:TestRecallScore" name = "Recall Score" @@ -244,8 +240,7 @@ def render_html(self, obj: TestRecallScore) -> TestHtmlInfo: class TestRocAuc(SimpleClassificationTest): - class Config: - type_alias = "evidently:test:TestRocAuc" + __type_alias__: ClassVar = "evidently:test:TestRocAuc" name: ClassVar = "ROC AUC Score" _roc_curve: ClassificationRocCurve @@ -306,8 +301,7 @@ def render_html(self, obj: TestRocAuc) -> TestHtmlInfo: class TestLogLoss(SimpleClassificationTest): - class Config: - type_alias = "evidently:test:TestLogLoss" + __type_alias__: ClassVar = "evidently:test:TestLogLoss" condition_arg = "lt" name = "Logarithmic Loss" @@ -344,8 +338,7 @@ def render_html(self, obj: TestLogLoss) -> TestHtmlInfo: class TestTPR(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestTPR" + __type_alias__: ClassVar = "evidently:test:TestTPR" name = "True Positive Rate" @@ -383,8 +376,7 @@ def render_html(self, obj: TestF1Score) -> TestHtmlInfo: class TestTNR(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestTNR" + __type_alias__: ClassVar = "evidently:test:TestTNR" name = "True Negative Rate" @@ -422,8 +414,7 @@ def render_html(self, obj: TestF1Score) -> TestHtmlInfo: class TestFPR(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestFPR" + __type_alias__: ClassVar = "evidently:test:TestFPR" condition_arg: ClassVar = "lt" name = "False Positive Rate" @@ -462,8 +453,7 @@ def render_html(self, obj: TestF1Score) -> TestHtmlInfo: class TestFNR(SimpleClassificationTestTopK): - class Config: - type_alias = "evidently:test:TestFNR" + __type_alias__: ClassVar = "evidently:test:TestFNR" condition_arg: ClassVar = "lt" name = "False Negative Rate" @@ -502,8 +492,7 @@ def render_html(self, obj: TestF1Score) -> TestHtmlInfo: class ByClassParameters(CheckValueParameters): - class Config: - type_alias = "evidently:test_parameters:ByClassParameters" + __type_alias__: ClassVar = "evidently:test_parameters:ByClassParameters" label: Label @@ -601,8 +590,7 @@ def get_parameters(self) -> ByClassParameters: class TestPrecisionByClass(ByClassClassificationTest): - class Config: - type_alias = "evidently:test:TestPrecisionByClass" + __type_alias__: ClassVar = "evidently:test:TestPrecisionByClass" name: ClassVar[str] = "Precision Score by Class" @@ -628,8 +616,7 @@ def render_html(self, obj: TestPrecisionByClass) -> TestHtmlInfo: class TestRecallByClass(ByClassClassificationTest): - class Config: - type_alias = "evidently:test:TestRecallByClass" + __type_alias__: ClassVar = "evidently:test:TestRecallByClass" name: ClassVar[str] = "Recall Score by Class" @@ -655,8 +642,7 @@ def render_html(self, obj: TestRecallByClass) -> TestHtmlInfo: class TestF1ByClass(ByClassClassificationTest): - class Config: - type_alias = "evidently:test:TestF1ByClass" + __type_alias__: ClassVar = "evidently:test:TestF1ByClass" name: ClassVar[str] = "F1 Score by Class" diff --git a/src/evidently/tests/custom_test.py b/src/evidently/tests/custom_test.py index e531d89401..5a251d0a37 100644 --- a/src/evidently/tests/custom_test.py +++ b/src/evidently/tests/custom_test.py @@ -17,8 +17,7 @@ class CustomValueTest(BaseCheckValueTest): - class Config: - type_alias = "evidently:test:CustomValueTest" + __type_alias__: ClassVar = "evidently:test:CustomValueTest" name: ClassVar = "Custom Value test" group = CUSTOM_GROUP.id diff --git a/src/evidently/tests/data_drift_tests.py b/src/evidently/tests/data_drift_tests.py index 485e1dba5d..5089de05a8 100644 --- a/src/evidently/tests/data_drift_tests.py +++ b/src/evidently/tests/data_drift_tests.py @@ -48,8 +48,7 @@ class ColumnDriftParameter(ExcludeNoneMixin, TestParameters): # type: ignore[misc] # pydantic Config - class Config: - type_alias = "evidently:test_parameters:ColumnDriftParameter" + __type_alias__: ClassVar = "evidently:test_parameters:ColumnDriftParameter" stattest: str score: float @@ -70,8 +69,7 @@ def from_metric(cls, data: ColumnDataDriftMetrics, column_name: str = None): class ColumnsDriftParameters(ConditionTestParameters): # todo: rename to columns? - class Config: - type_alias = "evidently:test_parameters:ColumnsDriftParameters" + __type_alias__: ClassVar = "evidently:test_parameters:ColumnsDriftParameters" features: Dict[str, ColumnDriftParameter] @@ -185,8 +183,7 @@ def check(self): class TestNumberOfDriftedColumns(BaseDataDriftMetricsTest): - class Config: - type_alias = "evidently:test:TestNumberOfDriftedColumns" + __type_alias__: ClassVar = "evidently:test:TestNumberOfDriftedColumns" name: ClassVar = "Number of Drifted Features" @@ -208,8 +205,7 @@ def get_description(self, value: Numeric) -> str: class TestShareOfDriftedColumns(BaseDataDriftMetricsTest): - class Config: - type_alias = "evidently:test:TestShareOfDriftedColumns" + __type_alias__: ClassVar = "evidently:test:TestShareOfDriftedColumns" name: ClassVar = "Share of Drifted Columns" @@ -232,8 +228,7 @@ def get_description(self, value: Numeric) -> str: class TestColumnDrift(Test): - class Config: - type_alias = "evidently:test:TestColumnDrift" + __type_alias__: ClassVar = "evidently:test:TestColumnDrift" name: ClassVar = "Drift per Column" group: ClassVar = DATA_DRIFT_GROUP.id @@ -619,8 +614,7 @@ def render_html(self, obj: TestColumnDrift) -> TestHtmlInfo: class TestEmbeddingsDrift(Test): - class Config: - type_alias = "evidently:test:TestEmbeddingsDrift" + __type_alias__: ClassVar = "evidently:test:TestEmbeddingsDrift" name: ClassVar = "Drift for embeddings" group: ClassVar = DATA_DRIFT_GROUP.id diff --git a/src/evidently/tests/data_integrity_tests.py b/src/evidently/tests/data_integrity_tests.py index 8c2e503528..c872d7b8f8 100644 --- a/src/evidently/tests/data_integrity_tests.py +++ b/src/evidently/tests/data_integrity_tests.py @@ -76,8 +76,7 @@ def __init__( class TestNumberOfColumns(BaseIntegrityValueTest): - class Config: - type_alias = "evidently:test:TestNumberOfColumns" + __type_alias__: ClassVar = "evidently:test:TestNumberOfColumns" """Number of all columns in the data, including utility columns (id/index, datetime, target, predictions)""" @@ -114,8 +113,7 @@ def render_html(self, obj: TestNumberOfColumns) -> TestHtmlInfo: class TestNumberOfRows(BaseIntegrityValueTest): - class Config: - type_alias = "evidently:test:TestNumberOfRows" + __type_alias__: ClassVar = "evidently:test:TestNumberOfRows" """Number of rows in the data""" @@ -246,8 +244,7 @@ def get_table_with_number_of_missing_values_by_one_missing_value( class TestNumberOfDifferentMissingValues(BaseIntegrityMissingValuesValuesTest): - class Config: - type_alias = "evidently:test:TestNumberOfDifferentMissingValues" + __type_alias__: ClassVar = "evidently:test:TestNumberOfDifferentMissingValues" """Check a number of different encoded missing values.""" @@ -292,8 +289,7 @@ def render_html(self, obj: TestNumberOfDifferentMissingValues) -> TestHtmlInfo: class TestNumberOfMissingValues(BaseIntegrityMissingValuesValuesTest): - class Config: - type_alias = "evidently:test:TestNumberOfMissingValues" + __type_alias__: ClassVar = "evidently:test:TestNumberOfMissingValues" """Check a number of missing values.""" @@ -331,8 +327,7 @@ def render_html(self, obj: TestNumberOfMissingValues) -> TestHtmlInfo: class TestShareOfMissingValues(BaseIntegrityMissingValuesValuesTest): - class Config: - type_alias = "evidently:test:TestShareOfMissingValues" + __type_alias__: ClassVar = "evidently:test:TestShareOfMissingValues" """Check a share of missing values.""" @@ -360,8 +355,7 @@ def render_html(self, obj: TestNumberOfMissingValues) -> TestHtmlInfo: class TestNumberOfColumnsWithMissingValues(BaseIntegrityMissingValuesValuesTest): - class Config: - type_alias = "evidently:test:TestNumberOfColumnsWithMissingValues" + __type_alias__: ClassVar = "evidently:test:TestNumberOfColumnsWithMissingValues" """Check a number of columns with a missing value.""" @@ -393,8 +387,7 @@ def render_html(self, obj: TestNumberOfMissingValues) -> TestHtmlInfo: class TestShareOfColumnsWithMissingValues(BaseIntegrityMissingValuesValuesTest): - class Config: - type_alias = "evidently:test:TestShareOfColumnsWithMissingValues" + __type_alias__: ClassVar = "evidently:test:TestShareOfColumnsWithMissingValues" """Check a share of columns with a missing value.""" @@ -427,8 +420,7 @@ def render_html(self, obj: TestNumberOfMissingValues) -> TestHtmlInfo: class TestNumberOfRowsWithMissingValues(BaseIntegrityMissingValuesValuesTest): - class Config: - type_alias = "evidently:test:TestNumberOfRowsWithMissingValues" + __type_alias__: ClassVar = "evidently:test:TestNumberOfRowsWithMissingValues" """Check a number of rows with a missing value.""" @@ -453,8 +445,7 @@ def get_description(self, value: Numeric) -> str: class TestShareOfRowsWithMissingValues(BaseIntegrityMissingValuesValuesTest): - class Config: - type_alias = "evidently:test:TestShareOfRowsWithMissingValues" + __type_alias__: ClassVar = "evidently:test:TestShareOfRowsWithMissingValues" """Check a share of rows with a missing value.""" @@ -515,8 +506,7 @@ def __init__( class TestColumnNumberOfDifferentMissingValues(BaseIntegrityColumnMissingValuesTest): - class Config: - type_alias = "evidently:test:TestColumnNumberOfDifferentMissingValues" + __type_alias__: ClassVar = "evidently:test:TestColumnNumberOfDifferentMissingValues" """Check a number of differently encoded missing values in one column.""" @@ -568,8 +558,7 @@ def render_html(self, obj: TestColumnNumberOfDifferentMissingValues) -> TestHtml class TestColumnNumberOfMissingValues(BaseIntegrityColumnMissingValuesTest): - class Config: - type_alias = "evidently:test:TestColumnNumberOfMissingValues" + __type_alias__: ClassVar = "evidently:test:TestColumnNumberOfMissingValues" """Check a number of missing values in one column.""" @@ -596,8 +585,7 @@ def get_description(self, value: Numeric) -> str: class TestColumnShareOfMissingValues(BaseIntegrityColumnMissingValuesTest): - class Config: - type_alias = "evidently:test:TestColumnShareOfMissingValues" + __type_alias__: ClassVar = "evidently:test:TestColumnShareOfMissingValues" """Check a share of missing values in one column.""" @@ -649,8 +637,7 @@ def generate(self, data_definition: DataDefinition) -> List[TestColumnShareOfMis class TestNumberOfConstantColumns(BaseIntegrityValueTest): - class Config: - type_alias = "evidently:test:TestNumberOfConstantColumns" + __type_alias__: ClassVar = "evidently:test:TestNumberOfConstantColumns" """Number of columns contained only one unique value""" @@ -689,8 +676,7 @@ def render_html(self, obj: TestNumberOfConstantColumns) -> TestHtmlInfo: class TestNumberOfEmptyRows(BaseIntegrityValueTest): - class Config: - type_alias = "evidently:test:TestNumberOfEmptyRows" + __type_alias__: ClassVar = "evidently:test:TestNumberOfEmptyRows" """Number of rows contained all NAN values""" @@ -714,8 +700,7 @@ def get_description(self, value: Numeric) -> str: class TestNumberOfEmptyColumns(BaseIntegrityValueTest): - class Config: - type_alias = "evidently:test:TestNumberOfEmptyColumns" + __type_alias__: ClassVar = "evidently:test:TestNumberOfEmptyColumns" """Number of columns contained all NAN values""" @@ -753,8 +738,7 @@ def render_html(self, obj: TestNumberOfEmptyColumns) -> TestHtmlInfo: class TestNumberOfDuplicatedRows(BaseIntegrityValueTest): - class Config: - type_alias = "evidently:test:TestNumberOfDuplicatedRows" + __type_alias__: ClassVar = "evidently:test:TestNumberOfDuplicatedRows" """How many rows have duplicates in the dataset""" @@ -778,8 +762,7 @@ def get_description(self, value: Numeric) -> str: class TestNumberOfDuplicatedColumns(BaseIntegrityValueTest): - class Config: - type_alias = "evidently:test:TestNumberOfDuplicatedColumns" + __type_alias__: ClassVar = "evidently:test:TestNumberOfDuplicatedColumns" """How many columns have duplicates in the dataset""" @@ -856,8 +839,7 @@ def groups(self) -> Dict[str, str]: class TestColumnAllConstantValues(BaseIntegrityOneColumnTest): - class Config: - type_alias = "evidently:test:TestColumnAllConstantValues" + __type_alias__: ClassVar = "evidently:test:TestColumnAllConstantValues" """Test that there is only one unique value in a column""" @@ -902,8 +884,7 @@ def render_html(self, obj: TestColumnAllConstantValues) -> TestHtmlInfo: class TestColumnAllUniqueValues(BaseIntegrityOneColumnTest): - class Config: - type_alias = "evidently:test:TestColumnAllUniqueValues" + __type_alias__: ClassVar = "evidently:test:TestColumnAllUniqueValues" """Test that there is only uniques values in a column""" @@ -948,8 +929,7 @@ def render_html(self, obj: TestColumnAllUniqueValues) -> TestHtmlInfo: class ColumnTypeParameter(TestParameters): - class Config: - type_alias = "evidently:test_parameters:ColumnTypeParameter" + __type_alias__: ClassVar = "evidently:test_parameters:ColumnTypeParameter" actual_type: str column_name: str @@ -957,15 +937,13 @@ class Config: class ColumnTypesParameter(TestParameters): - class Config: - type_alias = "evidently:test_parameters:ColumnTypesParameter" + __type_alias__: ClassVar = "evidently:test_parameters:ColumnTypesParameter" columns: List[ColumnTypeParameter] class TestColumnsType(Test): - class Config: - type_alias = "evidently:test:TestColumnsType" + __type_alias__: ClassVar = "evidently:test:TestColumnsType" """This test compares columns type against the specified ones or a reference dataframe""" diff --git a/src/evidently/tests/data_quality_tests.py b/src/evidently/tests/data_quality_tests.py index 7b39feb5e6..b743f1d929 100644 --- a/src/evidently/tests/data_quality_tests.py +++ b/src/evidently/tests/data_quality_tests.py @@ -94,8 +94,7 @@ def __init__( class TestConflictTarget(Test): - class Config: - type_alias = "evidently:test:TestConflictTarget" + __type_alias__: ClassVar = "evidently:test:TestConflictTarget" group: ClassVar = DATA_QUALITY_GROUP.id name: ClassVar = "Test number of conflicts in target" @@ -131,8 +130,7 @@ def groups(self) -> Dict[str, str]: class TestConflictPrediction(Test): - class Config: - type_alias = "evidently:test:TestConflictPrediction" + __type_alias__: ClassVar = "evidently:test:TestConflictPrediction" group: ClassVar = DATA_QUALITY_GROUP.id name: ClassVar = "Test number of conflicts in prediction" @@ -201,8 +199,7 @@ def __init__( class TestTargetPredictionCorrelation(BaseDataQualityCorrelationsMetricsValueTest): - class Config: - type_alias = "evidently:test:TestTargetPredictionCorrelation" + __type_alias__: ClassVar = "evidently:test:TestTargetPredictionCorrelation" name: ClassVar = "Correlation between Target and Prediction" @@ -230,8 +227,7 @@ def get_description(self, value: Numeric) -> str: class TestHighlyCorrelatedColumns(BaseDataQualityCorrelationsMetricsValueTest): - class Config: - type_alias = "evidently:test:TestHighlyCorrelatedColumns" + __type_alias__: ClassVar = "evidently:test:TestHighlyCorrelatedColumns" name: ClassVar = "Highly Correlated Columns" @@ -271,8 +267,7 @@ def render_html(self, obj: TestHighlyCorrelatedColumns) -> TestHtmlInfo: class TestTargetFeaturesCorrelations(BaseDataQualityCorrelationsMetricsValueTest): - class Config: - type_alias = "evidently:test:TestTargetFeaturesCorrelations" + __type_alias__: ClassVar = "evidently:test:TestTargetFeaturesCorrelations" name: ClassVar = "Correlation between Target and Features" @@ -299,8 +294,7 @@ def get_description(self, value: Numeric) -> str: class TestPredictionFeaturesCorrelations(BaseDataQualityCorrelationsMetricsValueTest): - class Config: - type_alias = "evidently:test:TestPredictionFeaturesCorrelations" + __type_alias__: ClassVar = "evidently:test:TestPredictionFeaturesCorrelations" name: ClassVar = "Correlation between Prediction and Features" @@ -347,8 +341,7 @@ def render_html(self, obj: TestTargetFeaturesCorrelations) -> TestHtmlInfo: class TestCorrelationChanges(BaseDataQualityCorrelationsMetricsValueTest): - class Config: - type_alias = "evidently:test:TestCorrelationChanges" + __type_alias__: ClassVar = "evidently:test:TestCorrelationChanges" group: ClassVar = DATA_QUALITY_GROUP.id name: ClassVar = "Change in Correlation" @@ -488,8 +481,7 @@ def get_stat(self, current: NumericCharacteristics): class TestColumnValueMin(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestColumnValueMin" + __type_alias__: ClassVar = "evidently:test:TestColumnValueMin" name: ClassVar = "Min Value" @@ -516,8 +508,7 @@ def get_description(self, value: Numeric) -> str: class TestColumnValueMax(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestColumnValueMax" + __type_alias__: ClassVar = "evidently:test:TestColumnValueMax" name: ClassVar = "Max Value" @@ -546,8 +537,7 @@ def get_description(self, value: Numeric) -> str: class TestColumnValueMean(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestColumnValueMean" + __type_alias__: ClassVar = "evidently:test:TestColumnValueMean" name: ClassVar = "Mean Value" @@ -572,8 +562,7 @@ def get_description(self, value: Numeric) -> str: class TestColumnValueMedian(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestColumnValueMedian" + __type_alias__: ClassVar = "evidently:test:TestColumnValueMedian" name: ClassVar = "Median Value" @@ -645,8 +634,7 @@ def _feature_render_html(self, obj: BaseFeatureDataQualityMetricsTest): class TestColumnValueStd(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestColumnValueStd" + __type_alias__: ClassVar = "evidently:test:TestColumnValueStd" name: ClassVar = "Standard Deviation (SD)" @@ -692,8 +680,7 @@ def render_html(self, obj: BaseFeatureDataQualityMetricsTest) -> TestHtmlInfo: class TestNumberOfUniqueValues(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestNumberOfUniqueValues" + __type_alias__: ClassVar = "evidently:test:TestNumberOfUniqueValues" name: ClassVar = "Number of Unique Values" @@ -739,8 +726,7 @@ def render_html(self, obj: TestNumberOfUniqueValues) -> TestHtmlInfo: class TestUniqueValuesShare(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestUniqueValuesShare" + __type_alias__: ClassVar = "evidently:test:TestUniqueValuesShare" name: ClassVar = "Share of Unique Values" @@ -793,8 +779,7 @@ def render_html(self, obj: TestUniqueValuesShare) -> TestHtmlInfo: class TestMostCommonValueShare(BaseFeatureDataQualityMetricsTest): - class Config: - type_alias = "evidently:test:TestMostCommonValueShare" + __type_alias__: ClassVar = "evidently:test:TestMostCommonValueShare" name: ClassVar = "Share of the Most Common Value" @@ -888,8 +873,7 @@ def generate(self, data_definition: DataDefinition) -> List[TestMostCommonValueS class MeanInNSigmasParameter(TestParameters): - class Config: - type_alias = "evidently:test_parameters:MeanInNSigmasParameter" + __type_alias__: ClassVar = "evidently:test_parameters:MeanInNSigmasParameter" column_name: str current_mean: float @@ -899,8 +883,7 @@ class Config: class TestMeanInNSigmas(Test): - class Config: - type_alias = "evidently:test:TestMeanInNSigmas" + __type_alias__: ClassVar = "evidently:test:TestMeanInNSigmas" group: ClassVar = DATA_QUALITY_GROUP.id name: ClassVar = "Mean Value Stability" @@ -1053,8 +1036,7 @@ def generate(self, data_definition: DataDefinition) -> List[TestMeanInNSigmas]: class TestValueRange(Test): - class Config: - type_alias = "evidently:test:TestValueRange" + __type_alias__: ClassVar = "evidently:test:TestValueRange" group: ClassVar = DATA_QUALITY_GROUP.id name: ClassVar = "Value Range" @@ -1184,8 +1166,7 @@ def metric(self): class TestNumberOfOutRangeValues(BaseDataQualityValueRangeMetricsTest): - class Config: - type_alias = "evidently:test:TestNumberOfOutRangeValues" + __type_alias__: ClassVar = "evidently:test:TestNumberOfOutRangeValues" name: ClassVar = "Number of Out-of-Range Values " @@ -1200,16 +1181,14 @@ def get_description(self, value: Numeric) -> str: class ShareOfOutRangeParameters(CheckValueParameters): - class Config: - type_alias = "evidently:test_parameters:ShareOfOutRangeParameters" + __type_alias__: ClassVar = "evidently:test_parameters:ShareOfOutRangeParameters" left: Optional[float] right: Optional[float] class TestShareOfOutRangeValues(BaseDataQualityValueRangeMetricsTest): - class Config: - type_alias = "evidently:test:TestShareOfOutRangeValues" + __type_alias__: ClassVar = "evidently:test:TestShareOfOutRangeValues" name: ClassVar = "Share of Out-of-Range Values" @@ -1292,8 +1271,7 @@ def generate(self, data_definition: DataDefinition) -> List[TestShareOfOutRangeV class ColumnValueListParameters(TestParameters): - class Config: - type_alias = "evidently:test_parameters:ColumnValueListParameters" + __type_alias__: ClassVar = "evidently:test_parameters:ColumnValueListParameters" value: Numeric column_name: str @@ -1301,8 +1279,7 @@ class Config: class TestValueList(Test): - class Config: - type_alias = "evidently:test:TestValueList" + __type_alias__: ClassVar = "evidently:test:TestValueList" group: ClassVar = DATA_QUALITY_GROUP.id name: ClassVar = "Out-of-List Values" @@ -1396,8 +1373,7 @@ def get_condition(self) -> TestValueCondition: class TestNumberOfOutListValues(BaseDataQualityValueListMetricsTest): - class Config: - type_alias = "evidently:test:TestNumberOfOutListValues" + __type_alias__: ClassVar = "evidently:test:TestNumberOfOutListValues" name: ClassVar = "Number Out-of-List Values" alias: ClassVar = "number_value_list" @@ -1414,15 +1390,13 @@ def get_description(self, value: Numeric) -> str: class ValueListParameters(CheckValueParameters): # todo: typing - class Config: - type_alias = "evidently:test_parameters:ValueListParameters" + __type_alias__: ClassVar = "evidently:test_parameters:ValueListParameters" values: Optional[List[Any]] = None class TestShareOfOutListValues(BaseDataQualityValueListMetricsTest): - class Config: - type_alias = "evidently:test:TestShareOfOutListValues" + __type_alias__: ClassVar = "evidently:test:TestShareOfOutListValues" name: ClassVar = "Share of Out-of-List Values" alias: ClassVar = "share_value_list" @@ -1470,8 +1444,7 @@ def generate(self, data_definition: DataDefinition) -> List[TestShareOfOutListVa class TestColumnQuantile(BaseCheckValueTest): - class Config: - type_alias = "evidently:test:TestColumnQuantile" + __type_alias__: ClassVar = "evidently:test:TestColumnQuantile" group: ClassVar = DATA_QUALITY_GROUP.id name: ClassVar = "Quantile Value" @@ -1652,8 +1625,7 @@ def get_condition(self) -> TestValueCondition: class TestCategoryShare(BaseDataQualityCategoryMetricsTest): - class Config: - type_alias = "evidently:test:TestCategoryShare" + __type_alias__: ClassVar = "evidently:test:TestCategoryShare" name: ClassVar = "Share of category" alias: ClassVar = "share_category" @@ -1679,8 +1651,7 @@ def get_parameters(self) -> CheckValueParameters: class TestCategoryCount(BaseDataQualityCategoryMetricsTest): - class Config: - type_alias = "evidently:test:TestCategoryCount" + __type_alias__: ClassVar = "evidently:test:TestCategoryCount" name: ClassVar = "Count of category" alias: ClassVar = "count_category" diff --git a/src/evidently/tests/recsys_tests.py b/src/evidently/tests/recsys_tests.py index 02c2568e21..da6621b329 100644 --- a/src/evidently/tests/recsys_tests.py +++ b/src/evidently/tests/recsys_tests.py @@ -134,8 +134,7 @@ def render_html(self, obj: BaseTopkRecsysTest) -> TestHtmlInfo: class TestPrecisionTopK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestPrecisionTopK" + __type_alias__: ClassVar = "evidently:test:TestPrecisionTopK" name: ClassVar = "Precision (top-k)" header: str = "Precision" @@ -150,8 +149,7 @@ class TestPrecisionTopKRenderer(BaseTopkRecsysRenderer): class TestRecallTopK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestRecallTopK" + __type_alias__: ClassVar = "evidently:test:TestRecallTopK" name: ClassVar = "Recall (top-k)" header: str = "Recall" @@ -166,8 +164,7 @@ class TestRecallTopKRenderer(BaseTopkRecsysRenderer): class TestFBetaTopK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestFBetaTopK" + __type_alias__: ClassVar = "evidently:test:TestFBetaTopK" name: ClassVar = "F_beta (top-k)" header: str = "F_beta" @@ -182,8 +179,7 @@ class TestFBetaTopKRenderer(BaseTopkRecsysRenderer): class TestMAPK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestMAPK" + __type_alias__: ClassVar = "evidently:test:TestMAPK" name: ClassVar = "MAP (top-k)" header: str = "MAP" @@ -198,8 +194,7 @@ class TestMAPKRenderer(BaseTopkRecsysRenderer): class TestMARK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestMARK" + __type_alias__: ClassVar = "evidently:test:TestMARK" name: ClassVar = "MAR (top-k)" header: str = "MAR" @@ -214,8 +209,7 @@ class TestMARKRenderer(BaseTopkRecsysRenderer): class TestNDCGK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestNDCGK" + __type_alias__: ClassVar = "evidently:test:TestNDCGK" name: ClassVar = "NDCG (top-k)" header: str = "NDCG" @@ -230,8 +224,7 @@ class TestNDCGKRenderer(BaseTopkRecsysRenderer): class TestHitRateK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestHitRateK" + __type_alias__: ClassVar = "evidently:test:TestHitRateK" name: ClassVar = "Hit Rate (top-k)" header: str = "Hit Rate" @@ -246,8 +239,7 @@ class TestHitRateKRenderer(BaseTopkRecsysRenderer): class TestMRRK(BaseTopkRecsysTest): - class Config: - type_alias = "evidently:test:TestMRRK" + __type_alias__: ClassVar = "evidently:test:TestMRRK" name: ClassVar = "MRR (top-k)" header: str = "MRR" @@ -359,8 +351,7 @@ def render_html(self, obj: BaseNotRankRecsysTest) -> TestHtmlInfo: class TestNovelty(BaseNotRankRecsysTest[NoveltyMetric]): - class Config: - type_alias = "evidently:test:TestNovelty" + __type_alias__: ClassVar = "evidently:test:TestNovelty" name: ClassVar = "Novelty (top-k)" header: str = "Novelty" @@ -375,8 +366,7 @@ class TestNoveltyRenderer(BaseNotRankRecsysTestRenderer): class TestDiversity(BaseNotRankRecsysTest[DiversityMetric]): - class Config: - type_alias = "evidently:test:TestDiversity" + __type_alias__: ClassVar = "evidently:test:TestDiversity" name: ClassVar = "Diversity (top-k)" header: str = "Diversity" @@ -391,8 +381,7 @@ class TestDiversityRenderer(BaseNotRankRecsysTestRenderer): class TestSerendipity(BaseNotRankRecsysTest[SerendipityMetric]): - class Config: - type_alias = "evidently:test:TestSerendipity" + __type_alias__: ClassVar = "evidently:test:TestSerendipity" name: ClassVar = "Serendipity (top-k)" header: str = "Serendipity" @@ -407,8 +396,7 @@ class TestSerendipityRenderer(BaseNotRankRecsysTestRenderer): class TestPersonalization(BaseNotRankRecsysTest[PersonalizationMetric]): - class Config: - type_alias = "evidently:test:TestPersonalization" + __type_alias__: ClassVar = "evidently:test:TestPersonalization" name: ClassVar = "Personalization (top-k)" header: str = "Personalization" @@ -453,8 +441,7 @@ def render_html(self, obj: BaseNotRankRecsysTest) -> TestHtmlInfo: class TestARP(BaseCheckValueTest): - class Config: - type_alias = "evidently:test:TestARP" + __type_alias__: ClassVar = "evidently:test:TestARP" group: ClassVar = RECSYS_GROUP.id name: ClassVar = "ARP (top-k)" @@ -512,8 +499,7 @@ def metric(self): class TestGiniIndex(BaseCheckValueTest): - class Config: - type_alias = "evidently:test:TestGiniIndex" + __type_alias__: ClassVar = "evidently:test:TestGiniIndex" group: ClassVar = RECSYS_GROUP.id name: ClassVar = "Gini Index (top-k)" @@ -568,8 +554,7 @@ def metric(self): class TestCoverage(BaseCheckValueTest): - class Config: - type_alias = "evidently:test:TestCoverage" + __type_alias__: ClassVar = "evidently:test:TestCoverage" group: ClassVar = RECSYS_GROUP.id name: ClassVar = "Coverage (top-k)" @@ -649,8 +634,7 @@ def render_html(self, obj: Union[TestARP, TestGiniIndex, TestCoverage]) -> TestH class TestScoreEntropy(BaseCheckValueTest): - class Config: - type_alias = "evidently:test:TestScoreEntropy" + __type_alias__: ClassVar = "evidently:test:TestScoreEntropy" group: ClassVar = RECSYS_GROUP.id name: ClassVar = "Score Entropy (top-k)" diff --git a/src/evidently/tests/regression_performance_tests.py b/src/evidently/tests/regression_performance_tests.py index 7791a82503..c0a6d99e61 100644 --- a/src/evidently/tests/regression_performance_tests.py +++ b/src/evidently/tests/regression_performance_tests.py @@ -65,8 +65,7 @@ def dummy_metric(self): class TestValueMAE(BaseRegressionPerformanceMetricsTest): - class Config: - type_alias = "evidently:test:TestValueMAE" + __type_alias__: ClassVar = "evidently:test:TestValueMAE" name: ClassVar = "Mean Absolute Error (MAE)" @@ -104,8 +103,7 @@ def render_html(self, obj: TestValueMAE) -> TestHtmlInfo: class TestValueMAPE(BaseRegressionPerformanceMetricsTest): - class Config: - type_alias = "evidently:test:TestValueMAPE" + __type_alias__: ClassVar = "evidently:test:TestValueMAPE" name: ClassVar = "Mean Absolute Percentage Error (MAPE)" @@ -145,8 +143,7 @@ def render_html(self, obj: TestValueMAPE) -> TestHtmlInfo: class TestValueRMSE(BaseRegressionPerformanceMetricsTest): - class Config: - type_alias = "evidently:test:TestValueRMSE" + __type_alias__: ClassVar = "evidently:test:TestValueRMSE" name: ClassVar = "Root Mean Square Error (RMSE)" @@ -184,8 +181,7 @@ def render_html(self, obj: TestValueRMSE) -> TestHtmlInfo: class TestValueMeanError(BaseRegressionPerformanceMetricsTest): - class Config: - type_alias = "evidently:test:TestValueMeanError" + __type_alias__: ClassVar = "evidently:test:TestValueMeanError" name: ClassVar = "Mean Error (ME)" @@ -230,8 +226,7 @@ def render_html(self, obj: TestValueMeanError) -> TestHtmlInfo: class TestValueAbsMaxError(BaseRegressionPerformanceMetricsTest): - class Config: - type_alias = "evidently:test:TestValueAbsMaxError" + __type_alias__: ClassVar = "evidently:test:TestValueAbsMaxError" name: ClassVar = "Max Absolute Error" @@ -265,8 +260,7 @@ def render_html(self, obj: TestValueAbsMaxError) -> TestHtmlInfo: class TestValueR2Score(BaseRegressionPerformanceMetricsTest): - class Config: - type_alias = "evidently:test:TestValueR2Score" + __type_alias__: ClassVar = "evidently:test:TestValueR2Score" name: ClassVar = "R2 Score" diff --git a/src/evidently/ui/api/models.py b/src/evidently/ui/api/models.py index f9f6b84427..168a6bcac0 100644 --- a/src/evidently/ui/api/models.py +++ b/src/evidently/ui/api/models.py @@ -1,6 +1,7 @@ import dataclasses import datetime from dataclasses import dataclass +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -33,8 +34,7 @@ class EvidentlyAPIModel(BaseModel): # todo: migrate all models to this base - class Config: - extra = Extra.forbid + __extra__: ClassVar = Extra.forbid class MetricModel(BaseModel): diff --git a/src/evidently/ui/base.py b/src/evidently/ui/base.py index 29911bb144..e3d1f99cfa 100644 --- a/src/evidently/ui/base.py +++ b/src/evidently/ui/base.py @@ -162,8 +162,7 @@ def _default_dashboard(): class Project(Entity): entity_type: ClassVar[EntityType] = EntityType.Project - class Config: - underscore_attrs_are_private = True + __underscore_attrs_are_private__: ClassVar = True id: ProjectID = Field(default_factory=new_id) name: str diff --git a/src/evidently/ui/components/base.py b/src/evidently/ui/components/base.py index 854decf81f..667a6bd251 100644 --- a/src/evidently/ui/components/base.py +++ b/src/evidently/ui/components/base.py @@ -64,10 +64,9 @@ class Component(PolymorphicModel, ABC): def get_requirements(self) -> List[Type["Component"]]: return self.__require__ - class Config: - extra = Extra.forbid - alias_required = False - is_base_type = True + __extra__: ClassVar = Extra.forbid + __alias_required__: ClassVar = False + __is_base_type__: ClassVar = True def __init_subclass__(cls): super().__init_subclass__() diff --git a/src/evidently/ui/components/local_storage.py b/src/evidently/ui/components/local_storage.py index 166e679c20..c64416a36c 100644 --- a/src/evidently/ui/components/local_storage.py +++ b/src/evidently/ui/components/local_storage.py @@ -16,8 +16,7 @@ class FSSpecBlobComponent(BlobStorageComponent): - class Config: - type_alias = "fsspec" + __type_alias__: ClassVar = "fsspec" path: str @@ -26,8 +25,7 @@ def dependency_factory(self) -> Callable[..., BlobStorage]: class JsonMetadataComponent(MetadataStorageComponent): - class Config: - type_alias = "json_file" + __type_alias__: ClassVar = "json_file" path: str @@ -39,8 +37,7 @@ async def json_meta(local_state: Optional[LocalState] = None): class InmemoryDataComponent(DataStorageComponent): - class Config: - type_alias = "inmemory" + __type_alias__: ClassVar = "inmemory" path: str diff --git a/src/evidently/ui/components/security.py b/src/evidently/ui/components/security.py index cf0bc6d764..03c3d05f57 100644 --- a/src/evidently/ui/components/security.py +++ b/src/evidently/ui/components/security.py @@ -27,8 +27,7 @@ class SecurityComponent(Component, ABC): add_security_middleware: ClassVar[bool] = True - class Config: - is_base_type = True + __is_base_type__: ClassVar = True def get_security(self) -> SecurityService: raise NotImplementedError @@ -87,8 +86,7 @@ def get_dependencies(self, ctx: ComponentContext) -> Dict[str, Provide]: class NoSecurityComponent(SimpleSecurity): - class Config: - type_alias = "none" + __type_alias__: ClassVar = "none" dummy_user_id: UserID = uuid6.UUID(int=1, version=7) dummy_org_id: OrgID = uuid6.UUID(int=2, version=7) @@ -100,8 +98,7 @@ def get_security(self) -> SecurityService: class TokenSecurityComponent(SimpleSecurity): - class Config: - type_alias = "token" + __type_alias__: ClassVar = "token" token: SecretStr diff --git a/src/evidently/ui/components/storage.py b/src/evidently/ui/components/storage.py index f0fccbafc9..d00157e41e 100644 --- a/src/evidently/ui/components/storage.py +++ b/src/evidently/ui/components/storage.py @@ -14,8 +14,7 @@ class StorageComponent(FactoryComponent[ProjectManager], ABC): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True dependency_name: ClassVar = "project_manager" use_cache: ClassVar[bool] = True @@ -31,8 +30,7 @@ def dependency_factory(self) -> Callable[..., ProjectManager]: class MetadataStorageComponent(FactoryComponent[ProjectMetadataStorage], ABC): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True __section__: ClassVar = "metadata" dependency_name: ClassVar = "project_metadata" @@ -41,8 +39,7 @@ class Config: class DataStorageComponent(FactoryComponent[DataStorage], ABC): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True __section__: ClassVar = "data" @@ -52,8 +49,7 @@ class Config: class BlobStorageComponent(FactoryComponent[BlobStorage], ABC): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True __section__: ClassVar = "blob" diff --git a/src/evidently/ui/dashboards/base.py b/src/evidently/ui/dashboards/base.py index 26e5df9eb3..6d93016897 100644 --- a/src/evidently/ui/dashboards/base.py +++ b/src/evidently/ui/dashboards/base.py @@ -4,6 +4,7 @@ from functools import wraps from typing import TYPE_CHECKING from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -133,9 +134,8 @@ async def inner(self: "DashboardPanel", *args, **kwargs) -> BaseWidgetInfo: class DashboardPanel(EnumValueMixin, PolymorphicModel): - class Config: - type_alias = "evidently:dashboard_panel:DashboardPanel" - is_base_type = True + __type_alias__: ClassVar = "evidently:dashboard_panel:DashboardPanel" + __is_base_type__: ClassVar = True id: PanelID = Field(default_factory=new_id) title: str diff --git a/src/evidently/ui/dashboards/reports.py b/src/evidently/ui/dashboards/reports.py index 6f1b0049ab..3d159b0c67 100644 --- a/src/evidently/ui/dashboards/reports.py +++ b/src/evidently/ui/dashboards/reports.py @@ -2,6 +2,7 @@ from collections import defaultdict from typing import TYPE_CHECKING from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -40,8 +41,7 @@ @autoregister class DashboardPanelPlot(DashboardPanel): - class Config: - type_alias = "evidently:dashboard_panel:DashboardPanelPlot" + __type_alias__: ClassVar = "evidently:dashboard_panel:DashboardPanelPlot" values: List[PanelValue] plot_type: PlotType @@ -102,8 +102,7 @@ def plot_type_cls(self): @autoregister class DashboardPanelCounter(DashboardPanel): - class Config: - type_alias = "evidently:dashboard_panel:DashboardPanelCounter" + __type_alias__: ClassVar = "evidently:dashboard_panel:DashboardPanelCounter" agg: CounterAgg value: Optional[PanelValue] = None @@ -148,8 +147,7 @@ def _get_counter_value(self, points: Dict[Metric, List[PointInfo]]) -> float: @autoregister class DashboardPanelDistribution(DashboardPanel): - class Config: - type_alias = "evidently:dashboard_panel:DashboardPanelDistribution" + __type_alias__: ClassVar = "evidently:dashboard_panel:DashboardPanelDistribution" value: PanelValue barmode: HistBarMode = HistBarMode.STACK diff --git a/src/evidently/ui/dashboards/test_suites.py b/src/evidently/ui/dashboards/test_suites.py index 54ca88ad57..78faef42cf 100644 --- a/src/evidently/ui/dashboards/test_suites.py +++ b/src/evidently/ui/dashboards/test_suites.py @@ -4,6 +4,7 @@ import warnings from collections import Counter from typing import Any +from typing import ClassVar from typing import Dict from typing import List from typing import Optional @@ -89,8 +90,7 @@ def get(self, test_suite: TestSuite) -> Dict[Test, TestInfo]: @autoregister class DashboardPanelTestSuite(DashboardPanel): - class Config: - type_alias = "evidently:dashboard_panel:DashboardPanelTestSuite" + __type_alias__: ClassVar = "evidently:dashboard_panel:DashboardPanelTestSuite" test_filters: List[TestFilter] = [] filter: ReportFilter = ReportFilter(metadata_values={}, tag_values=[], include_test_suites=True) @@ -198,8 +198,7 @@ def to_period(time_agg: Optional[str], timestamp: datetime.datetime) -> datetime @autoregister class DashboardPanelTestSuiteCounter(DashboardPanel): - class Config: - type_alias = "evidently:dashboard_panel:DashboardPanelTestSuiteCounter" + __type_alias__: ClassVar = "evidently:dashboard_panel:DashboardPanelTestSuiteCounter" agg: CounterAgg = CounterAgg.NONE filter: ReportFilter = ReportFilter(metadata_values={}, tag_values=[], include_test_suites=True) diff --git a/src/evidently/utils/llm/prompts.py b/src/evidently/utils/llm/prompts.py index c185f76818..22a5458c59 100644 --- a/src/evidently/utils/llm/prompts.py +++ b/src/evidently/utils/llm/prompts.py @@ -29,8 +29,7 @@ class PromptBlock(EvidentlyBaseModel): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True def render(self): # ))) @@ -70,8 +69,7 @@ def anchored(self, start: str = "__start__", end: str = "__end__"): class Anchor(PromptBlock): - class Config: - type_alias = "evidently:prompt_block:Anchor" + __type_alias__: ClassVar = "evidently:prompt_block:Anchor" start: str block: PromptBlock @@ -82,8 +80,7 @@ def _render(self) -> str: class SimpleBlock(PromptBlock): - class Config: - type_alias = "evidently:prompt_block:SimpleBlock" + __type_alias__: ClassVar = "evidently:prompt_block:SimpleBlock" value: str @@ -98,8 +95,7 @@ def parse_response(self, response: str) -> TResult: class NoopOutputFormat(OutputFormatBlock[str]): - class Config: - type_alias = "evidently:prompt_block:NoopOutputFormat" + __type_alias__: ClassVar = "evidently:prompt_block:NoopOutputFormat" def _render(self) -> str: return "" @@ -128,8 +124,7 @@ def find_largest_json(text): class JsonOutputFormatBlock(OutputFormatBlock[Dict[str, Any]]): - class Config: - type_alias = "evidently:prompt_block:JsonOutputFormatBlock" + __type_alias__: ClassVar = "evidently:prompt_block:JsonOutputFormatBlock" fields: Dict[str, Union[Tuple[str, str], str]] search_for_substring: bool = True @@ -160,8 +155,7 @@ def parse_response(self, response: str) -> Dict[str, Any]: class StringListFormatBlock(OutputFormatBlock[List[str]]): - class Config: - type_alias = "evidently:prompt_block:StringListFormatBlock" + __type_alias__: ClassVar = "evidently:prompt_block:StringListFormatBlock" of_what: str @@ -174,8 +168,7 @@ def parse_response(self, response: str) -> List[str]: class StringFormatBlock(OutputFormatBlock[str]): - class Config: - type_alias = "evidently:prompt_block:StringFormatBlock" + __type_alias__: ClassVar = "evidently:prompt_block:StringFormatBlock" what: str @@ -228,8 +221,7 @@ def _get_genric_arg(cls: Type): class PromptTemplate(EvidentlyBaseModel): - class Config: - is_base_type = True + __is_base_type__: ClassVar = True # __run_func__ : ClassVar[Callable] @abstractmethod @@ -281,8 +273,7 @@ def get_messages(self, values, template: Optional[str] = None) -> List[LLMMessag class BlockPromptTemplate(PromptTemplate): - class Config: - type_alias = "evidently:prompt_template:BlockPromptTemplate" + __type_alias__: ClassVar = "evidently:prompt_template:BlockPromptTemplate" blocks: ClassVar[List[AnyBlock]] diff --git a/src/evidently/utils/llm/wrapper.py b/src/evidently/utils/llm/wrapper.py index 5e0b1129bf..66333a9448 100644 --- a/src/evidently/utils/llm/wrapper.py +++ b/src/evidently/utils/llm/wrapper.py @@ -288,8 +288,7 @@ def get_llm_wrapper(provider: LLMProvider, model: LLMModel, options: Options) -> class LLMOptions(Option): __provider_name__: ClassVar[str] - class Config: - extra = "forbid" + __extra__: ClassVar = "forbid" api_key: Optional[SecretStr] = None # rpm_limit: int = 500 diff --git a/src/evidently/utils/types.py b/src/evidently/utils/types.py index d49cceedcb..44723b261f 100644 --- a/src/evidently/utils/types.py +++ b/src/evidently/utils/types.py @@ -18,8 +18,7 @@ class ApproxValue(FrozenBaseModel, ExcludeNoneMixin): """Class for approximate scalar value calculations""" - class Config: - smart_union = True + __smart_union__: ClassVar = True DEFAULT_RELATIVE: ClassVar = 1e-6 DEFAULT_ABSOLUTE: ClassVar = 1e-12