acryl-datahub 1.3.1__py3-none-any.whl → 1.3.1.1rc1__py3-none-any.whl

datahub/ingestion/source/looker/lookml_config.py

@@ -1,10 +1,11 @@
 import logging
+from copy import deepcopy
 from dataclasses import dataclass, field as dataclass_field
 from datetime import timedelta
 from typing import Any, Dict, Literal, Optional, Union
 
 import pydantic
-from pydantic import root_validator, validator
+from pydantic import model_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import AllowDenyPattern
@@ -210,75 +211,74 @@ class LookMLSourceConfig(
         "All if comments are evaluated to true for configured looker_environment value",
     )
 
-    @validator("connection_to_platform_map", pre=True)
-    def convert_string_to_connection_def(cls, conn_map):
-        # Previous version of config supported strings in connection map. This upconverts strings to ConnectionMap
-        for key in conn_map:
-            if isinstance(conn_map[key], str):
-                platform = conn_map[key]
-                if "." in platform:
-                    platform_db_split = conn_map[key].split(".")
-                    connection = LookerConnectionDefinition(
-                        platform=platform_db_split[0],
-                        default_db=platform_db_split[1],
-                        default_schema="",
-                    )
-                    conn_map[key] = connection
-                else:
-                    logger.warning(
-                        f"Connection map for {key} provides platform {platform} but does not provide a default "
-                        f"database name. This might result in failed resolution"
-                    )
-                    conn_map[key] = LookerConnectionDefinition(
-                        platform=platform, default_db="", default_schema=""
-                    )
-        return conn_map
+    @model_validator(mode="before")
+    @classmethod
+    def convert_string_to_connection_def(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        values = deepcopy(values)
+        conn_map = values.get("connection_to_platform_map")
+        if conn_map:
+            # Previous version of config supported strings in connection map. This upconverts strings to ConnectionMap
+            for key in conn_map:
+                if isinstance(conn_map[key], str):
+                    platform = conn_map[key]
+                    if "." in platform:
+                        platform_db_split = conn_map[key].split(".")
+                        connection = LookerConnectionDefinition(
+                            platform=platform_db_split[0],
+                            default_db=platform_db_split[1],
+                            default_schema="",
+                        )
+                        conn_map[key] = connection
+                    else:
+                        logger.warning(
+                            f"Connection map for {key} provides platform {platform} but does not provide a default "
+                            f"database name. This might result in failed resolution"
+                        )
+                        conn_map[key] = LookerConnectionDefinition(
+                            platform=platform, default_db="", default_schema=""
+                        )
+        return values
 
-    @root_validator(skip_on_failure=True)
-    def check_either_connection_map_or_connection_provided(cls, values):
+    @model_validator(mode="after")
+    def check_either_connection_map_or_connection_provided(self):
         """Validate that we must either have a connection map or an api credential"""
-        if not values.get("connection_to_platform_map", {}) and not values.get(
-            "api", {}
-        ):
+        if not (self.connection_to_platform_map or {}) and not (self.api):
             raise ValueError(
                 "Neither api not connection_to_platform_map config was found. LookML source requires either api "
                 "credentials for Looker or a map of connection names to platform identifiers to work correctly"
             )
-        return values
+        return self
 
-    @root_validator(skip_on_failure=True)
-    def check_either_project_name_or_api_provided(cls, values):
+    @model_validator(mode="after")
+    def check_either_project_name_or_api_provided(self):
         """Validate that we must either have a project name or an api credential to fetch project names"""
-        if not values.get("project_name") and not values.get("api"):
+        if not self.project_name and not self.api:
             raise ValueError(
                 "Neither project_name not an API credential was found. LookML source requires either api credentials "
                 "for Looker or a project_name to accurately name views and models."
             )
-        return values
+        return self
 
-    @root_validator(skip_on_failure=True)
-    def check_api_provided_for_view_lineage(cls, values):
+    @model_validator(mode="after")
+    def check_api_provided_for_view_lineage(self):
         """Validate that we must have an api credential to use Looker API for view's column lineage"""
-        if not values.get("api") and values.get("use_api_for_view_lineage"):
+        if not self.api and self.use_api_for_view_lineage:
             raise ValueError(
                 "API credential was not found. LookML source requires api credentials "
                 "for Looker to use Looker APIs for view's column lineage extraction."
                 "Set `use_api_for_view_lineage` to False to skip using Looker APIs."
             )
-        return values
+        return self
 
-    @validator("base_folder", always=True)
-    def check_base_folder_if_not_provided(
-        cls, v: Optional[pydantic.DirectoryPath], values: Dict[str, Any]
-    ) -> Optional[pydantic.DirectoryPath]:
-        if v is None:
-            git_info: Optional[GitInfo] = values.get("git_info")
-            if git_info:
-                if not git_info.deploy_key:
+    @model_validator(mode="after")
+    def check_base_folder_if_not_provided(self):
+        if self.base_folder is None:
+            if self.git_info:
+                if not self.git_info.deploy_key:
                     logger.warning(
                         "git_info is provided, but no SSH key is present. If the repo is not public, we'll fail to "
                         "clone it."
                     )
             else:
                 raise ValueError("Neither base_folder nor git_info has been provided.")
-        return v
+        return self

datahub/ingestion/source/metabase.py

@@ -9,7 +9,7 @@ from typing import Dict, Iterable, List, Optional, Tuple, Union
 import dateutil.parser as dp
 import pydantic
 import requests
-from pydantic import Field, root_validator, validator
+from pydantic import Field, field_validator, model_validator
 from requests.models import HTTPError
 
 import datahub.emitter.mce_builder as builder
@@ -115,16 +115,16 @@ class MetabaseConfig(
     )
     stateful_ingestion: Optional[StatefulStaleMetadataRemovalConfig] = None
 
-    @validator("connect_uri", "display_uri")
+    @field_validator("connect_uri", "display_uri", mode="after")
+    @classmethod
     def remove_trailing_slash(cls, v):
         return config_clean.remove_trailing_slashes(v)
 
-    @root_validator(skip_on_failure=True)
-    def default_display_uri_to_connect_uri(cls, values):
-        base = values.get("display_uri")
-        if base is None:
-            values["display_uri"] = values.get("connect_uri")
-        return values
+    @model_validator(mode="after")
+    def default_display_uri_to_connect_uri(self) -> "MetabaseConfig":
+        if self.display_uri is None:
+            self.display_uri = self.connect_uri
+        return self
 
 
 @dataclass

datahub/ingestion/source/metadata/business_glossary.py

@@ -563,7 +563,7 @@ class BusinessGlossaryFileSource(Source):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = BusinessGlossarySourceConfig.parse_obj(config_dict)
+        config = BusinessGlossarySourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     @classmethod
@@ -571,7 +571,7 @@ class BusinessGlossaryFileSource(Source):
         cls, file_name: Union[str, pathlib.Path]
     ) -> BusinessGlossaryConfig:
         config = load_config_file(file_name, resolve_env_vars=True)
-        glossary_cfg = BusinessGlossaryConfig.parse_obj(config)
+        glossary_cfg = BusinessGlossaryConfig.model_validate(config)
         return glossary_cfg
 
     def get_workunits_internal(

datahub/ingestion/source/metadata/lineage.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass, field
 from functools import partial
 from typing import Any, Dict, Iterable, List, Optional
 
-from pydantic import validator
+from pydantic import field_validator
 from pydantic.fields import Field
 
 import datahub.metadata.schema_classes as models
@@ -51,7 +51,8 @@ class EntityConfig(EnvConfigMixin):
     platform: str
     platform_instance: Optional[str] = None
 
-    @validator("type")
+    @field_validator("type", mode="after")
+    @classmethod
     def type_must_be_supported(cls, v: str) -> str:
         allowed_types = ["dataset"]
         if v not in allowed_types:
@@ -60,7 +61,8 @@ class EntityConfig(EnvConfigMixin):
             )
         return v
 
-    @validator("name")
+    @field_validator("name", mode="after")
+    @classmethod
     def validate_name(cls, v: str) -> str:
         if v.startswith("urn:li:"):
             raise ValueError(
@@ -77,7 +79,8 @@ class FineGrainedLineageConfig(ConfigModel):
     transformOperation: Optional[str]
     confidenceScore: Optional[float] = 1.0
 
-    @validator("upstreamType")
+    @field_validator("upstreamType", mode="after")
+    @classmethod
     def upstream_type_must_be_supported(cls, v: str) -> str:
         allowed_types = [
             FineGrainedLineageUpstreamTypeClass.FIELD_SET,
@@ -90,7 +93,8 @@ class FineGrainedLineageConfig(ConfigModel):
             )
         return v
 
-    @validator("downstreamType")
+    @field_validator("downstreamType", mode="after")
+    @classmethod
     def downstream_type_must_be_supported(cls, v: str) -> str:
         allowed_types = [
             FineGrainedLineageDownstreamTypeClass.FIELD_SET,
@@ -124,7 +128,8 @@ class LineageFileSourceConfig(ConfigModel):
 class LineageConfig(VersionedConfig):
     lineage: List[EntityNodeConfig]
 
-    @validator("version")
+    @field_validator("version", mode="after")
+    @classmethod
     def version_must_be_1(cls, v):
         if v != "1":
             raise ValueError("Only version 1 is supported")
@@ -148,13 +153,13 @@ class LineageFileSource(Source):
     def create(
         cls, config_dict: Dict[str, Any], ctx: PipelineContext
     ) -> "LineageFileSource":
-        config = LineageFileSourceConfig.parse_obj(config_dict)
+        config = LineageFileSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     @staticmethod
     def load_lineage_config(file_name: str) -> LineageConfig:
         config = load_config_file(file_name, resolve_env_vars=True)
-        lineage_config = LineageConfig.parse_obj(config)
+        lineage_config = LineageConfig.model_validate(config)
         return lineage_config
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/mlflow.py

@@ -892,5 +892,5 @@ class MLflowSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "MLflowSource":
-        config = MLflowConfig.parse_obj(config_dict)
+        config = MLflowConfig.model_validate(config_dict)
         return cls(ctx, config)

datahub/ingestion/source/mode.py

@@ -26,7 +26,7 @@ import sqlglot
 import tenacity
 import yaml
 from liquid import Template, Undefined
-from pydantic import Field, validator
+from pydantic import Field, field_validator
 from requests.adapters import HTTPAdapter, Retry
 from requests.exceptions import ConnectionError
 from requests.models import HTTPBasicAuth, HTTPError
@@ -218,11 +218,13 @@ class ModeConfig(
         default=False, description="Exclude archived reports"
     )
 
-    @validator("connect_uri")
+    @field_validator("connect_uri", mode="after")
+    @classmethod
     def remove_trailing_slash(cls, v):
         return config_clean.remove_trailing_slashes(v)
 
-    @validator("items_per_page")
+    @field_validator("items_per_page", mode="after")
+    @classmethod
     def validate_items_per_page(cls, v):
         if 1 <= v <= DEFAULT_API_ITEMS_PER_PAGE:
             return v
@@ -1824,7 +1826,7 @@ class ModeSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "ModeSource":
-        config: ModeConfig = ModeConfig.parse_obj(config_dict)
+        config: ModeConfig = ModeConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/mongodb.py

@@ -6,7 +6,7 @@ from typing import Dict, Iterable, List, Optional, Tuple, Type, Union, ValuesVie
 import bson.timestamp
 import pymongo.collection
 from packaging import version
-from pydantic import PositiveInt, validator
+from pydantic import PositiveInt, field_validator
 from pydantic.fields import Field
 from pymongo.mongo_client import MongoClient
 
@@ -138,7 +138,8 @@ class MongoDBConfig(
     # Custom Stateful Ingestion settings
     stateful_ingestion: Optional[StatefulStaleMetadataRemovalConfig] = None
 
-    @validator("maxDocumentSize")
+    @field_validator("maxDocumentSize", mode="after")
+    @classmethod
     def check_max_doc_size_filter_is_valid(cls, doc_size_filter_value):
         if doc_size_filter_value > 16793600:
             raise ValueError("maxDocumentSize must be a positive value <= 16793600.")
@@ -311,7 +312,7 @@ class MongoDBSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "MongoDBSource":
-        config = MongoDBConfig.parse_obj(config_dict)
+        config = MongoDBConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/neo4j/neo4j_source.py

@@ -78,7 +78,7 @@ class Neo4jSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: Dict, ctx: PipelineContext) -> "Neo4jSource":
-        config = Neo4jConfig.parse_obj(config_dict)
+        config = Neo4jConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def create_schema_field_tuple(

datahub/ingestion/source/nifi.py

@@ -13,7 +13,7 @@ import requests
 from cached_property import cached_property
 from dateutil import parser
 from packaging import version
-from pydantic import root_validator, validator
+from pydantic import field_validator, model_validator
 from pydantic.fields import Field
 from requests import Response
 from requests.adapters import HTTPAdapter
@@ -165,39 +165,33 @@ class NifiSourceConfig(StatefulIngestionConfigBase, EnvConfigMixin):
         " When disabled, re-states lineage on each run.",
     )
 
-    @root_validator(skip_on_failure=True)
-    def validate_auth_params(cls, values):
-        if values.get("auth") is NifiAuthType.CLIENT_CERT and not values.get(
-            "client_cert_file"
-        ):
+    @model_validator(mode="after")
+    def validate_auth_params(self) -> "NifiSourceConfig":
+        if self.auth is NifiAuthType.CLIENT_CERT and not self.client_cert_file:
             raise ValueError(
                 "Config `client_cert_file` is required for CLIENT_CERT auth"
             )
-        elif values.get("auth") in (
+        elif self.auth in (
             NifiAuthType.SINGLE_USER,
             NifiAuthType.BASIC_AUTH,
-        ) and (not values.get("username") or not values.get("password")):
+        ) and (not self.username or not self.password):
             raise ValueError(
-                f"Config `username` and `password` is required for {values.get('auth').value} auth"
+                f"Config `username` and `password` is required for {self.auth.value} auth"
             )
-        return values
-
-    @root_validator(skip_on_failure=True)
-    def validator_site_url_to_site_name(cls, values):
-        site_url_to_site_name = values.get("site_url_to_site_name")
-        site_url = values.get("site_url")
-        site_name = values.get("site_name")
+        return self
 
-        if site_url_to_site_name is None:
-            site_url_to_site_name = {}
-            values["site_url_to_site_name"] = site_url_to_site_name
+    @model_validator(mode="after")
+    def validator_site_url_to_site_name(self) -> "NifiSourceConfig":
+        if self.site_url_to_site_name is None:
+            self.site_url_to_site_name = {}
 
-        if site_url not in site_url_to_site_name:
-            site_url_to_site_name[site_url] = site_name
+        if self.site_url not in self.site_url_to_site_name:
+            self.site_url_to_site_name[self.site_url] = self.site_name
 
-        return values
+        return self
 
-    @validator("site_url")
+    @field_validator("site_url", mode="after")
+    @classmethod
     def validator_site_url(cls, site_url: str) -> str:
         assert site_url.startswith(("http://", "https://")), (
             "site_url must start with http:// or https://"

datahub/ingestion/source/openapi.py

@@ -4,7 +4,7 @@ import warnings
 from abc import ABC
 from typing import Dict, Iterable, List, Optional, Tuple
 
-from pydantic import validator
+from pydantic import model_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import ConfigModel
@@ -86,13 +86,11 @@ class OpenApiConfig(ConfigModel):
         default=True, description="Enable SSL certificate verification"
     )
 
-    @validator("bearer_token", always=True)
-    def ensure_only_one_token(
-        cls, bearer_token: Optional[str], values: Dict
-    ) -> Optional[str]:
-        if bearer_token is not None and values.get("token") is not None:
+    @model_validator(mode="after")
+    def ensure_only_one_token(self) -> "OpenApiConfig":
+        if self.bearer_token is not None and self.token is not None:
             raise ValueError("Unable to use 'token' and 'bearer_token' together.")
-        return bearer_token
+        return self
 
     def get_swagger(self) -> Dict:
         if self.get_token or self.token or self.bearer_token is not None:
@@ -463,5 +461,5 @@ class OpenApiSource(APISource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = OpenApiConfig.parse_obj(config_dict)
+        config = OpenApiConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/source/powerbi/config.py

@@ -4,7 +4,7 @@ from enum import Enum
 from typing import Dict, List, Literal, Optional, Union
 
 import pydantic
-from pydantic import root_validator, validator
+from pydantic import field_validator, model_validator
 
 import datahub.emitter.mce_builder as builder
 from datahub.configuration.common import AllowDenyPattern, ConfigModel, HiddenFromDocs
@@ -540,8 +540,8 @@ class PowerBiDashboardSourceConfig(
         description="timeout in seconds for Metadata Rest Api.",
     )
 
-    @root_validator(skip_on_failure=True)
-    def validate_extract_column_level_lineage(cls, values: Dict) -> Dict:
+    @model_validator(mode="after")
+    def validate_extract_column_level_lineage(self) -> "PowerBiDashboardSourceConfig":
         flags = [
             "native_query_parsing",
             "enable_advance_lineage_sql_construct",
@@ -549,26 +549,23 @@ class PowerBiDashboardSourceConfig(
             "extract_dataset_schema",
         ]
 
-        if (
-            "extract_column_level_lineage" in values
-            and values["extract_column_level_lineage"] is False
-        ):
+        if self.extract_column_level_lineage is False:
             # Flag is not set. skip validation
-            return values
+            return self
 
         logger.debug(f"Validating additional flags: {flags}")
 
         is_flag_enabled: bool = True
         for flag in flags:
-            if flag not in values or values[flag] is False:
+            if not getattr(self, flag, True):
                 is_flag_enabled = False
 
         if not is_flag_enabled:
             raise ValueError(f"Enable all these flags in recipe: {flags} ")
 
-        return values
+        return self
 
-    @validator("dataset_type_mapping")
+    @field_validator("dataset_type_mapping", mode="after")
     @classmethod
     def map_data_platform(cls, value):
         # For backward compatibility convert input PostgreSql to PostgreSQL
@@ -580,28 +577,32 @@ class PowerBiDashboardSourceConfig(
 
         return value
 
-    @root_validator(skip_on_failure=True)
-    def workspace_id_backward_compatibility(cls, values: Dict) -> Dict:
-        workspace_id = values.get("workspace_id")
-        workspace_id_pattern = values.get("workspace_id_pattern")
-
-        if workspace_id_pattern == AllowDenyPattern.allow_all() and workspace_id:
+    @model_validator(mode="after")
+    def workspace_id_backward_compatibility(self) -> "PowerBiDashboardSourceConfig":
+        if (
+            self.workspace_id_pattern == AllowDenyPattern.allow_all()
+            and self.workspace_id
+        ):
             logger.warning(
                 "workspace_id_pattern is not set but workspace_id is set, setting workspace_id as "
                 "workspace_id_pattern. workspace_id will be deprecated, please use workspace_id_pattern instead."
             )
-            values["workspace_id_pattern"] = AllowDenyPattern(
-                allow=[f"^{workspace_id}$"]
+            self.workspace_id_pattern = AllowDenyPattern(
+                allow=[f"^{self.workspace_id}$"]
             )
-        elif workspace_id_pattern != AllowDenyPattern.allow_all() and workspace_id:
+        elif (
+            self.workspace_id_pattern != AllowDenyPattern.allow_all()
+            and self.workspace_id
+        ):
             logger.warning(
                 "workspace_id will be ignored in favour of workspace_id_pattern. workspace_id will be deprecated, "
                 "please use workspace_id_pattern only."
             )
-            values.pop("workspace_id")
-        return values
+            self.workspace_id = None
+        return self
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def raise_error_for_dataset_type_mapping(cls, values: Dict) -> Dict:
         if (
             values.get("dataset_type_mapping") is not None
@@ -613,18 +614,18 @@ class PowerBiDashboardSourceConfig(
 
         return values
 
-    @root_validator(skip_on_failure=True)
-    def validate_extract_dataset_schema(cls, values: Dict) -> Dict:
-        if values.get("extract_dataset_schema") is False:
+    @model_validator(mode="after")
+    def validate_extract_dataset_schema(self) -> "PowerBiDashboardSourceConfig":
+        if self.extract_dataset_schema is False:
             add_global_warning(
                 "Please use `extract_dataset_schema: true`, otherwise dataset schema extraction will be skipped."
             )
-        return values
+        return self
 
-    @root_validator(skip_on_failure=True)
-    def validate_dsn_to_database_schema(cls, values: Dict) -> Dict:
-        if values.get("dsn_to_database_schema") is not None:
-            dsn_mapping = values.get("dsn_to_database_schema")
+    @model_validator(mode="after")
+    def validate_dsn_to_database_schema(self) -> "PowerBiDashboardSourceConfig":
+        if self.dsn_to_database_schema is not None:
+            dsn_mapping = self.dsn_to_database_schema
             if not isinstance(dsn_mapping, dict):
                 raise ValueError("dsn_to_database_schema must contain key-value pairs")
 
@@ -639,4 +640,4 @@ class PowerBiDashboardSourceConfig(
                         f"dsn_to_database_schema invalid mapping value: {value}"
                     )
 
-        return values
+        return self

datahub/ingestion/source/powerbi/dataplatform_instance_resolver.py

@@ -41,7 +41,7 @@ class ResolvePlatformInstanceFromDatasetTypeMapping(
         if isinstance(platform, PlatformDetail):
             return platform
 
-        return PlatformDetail.parse_obj({})
+        return PlatformDetail.model_validate({})
 
 
 class ResolvePlatformInstanceFromServerToPlatformInstance(
@@ -56,7 +56,7 @@ class ResolvePlatformInstanceFromServerToPlatformInstance(
             ]
             if data_platform_detail.data_platform_server
             in self.config.server_to_platform_instance
-            else PlatformDetail.parse_obj({})
+            else PlatformDetail.model_validate({})
         )
 
 

datahub/ingestion/source/powerbi/powerbi.py

@@ -1316,7 +1316,7 @@ class PowerBiDashboardSource(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = PowerBiDashboardSourceConfig.parse_obj(config_dict)
+        config = PowerBiDashboardSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_allowed_workspaces(self) -> List[powerbi_data_classes.Workspace]:

datahub/ingestion/source/powerbi_report_server/report_server.py

@@ -213,7 +213,7 @@ class PowerBiReportServerAPI:
 
             if response_dict.get("value"):
                 reports.extend(
-                    report_types_mapping[report_type].parse_obj(report)
+                    report_types_mapping[report_type].model_validate(report)
                     for report in response_dict.get("value")
                 )
 
@@ -517,7 +517,7 @@ class PowerBiReportServerDashboardSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = PowerBiReportServerDashboardSourceConfig.parse_obj(config_dict)
+        config = PowerBiReportServerDashboardSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/powerbi_report_server/report_server_domain.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, model_validator
 
 from datahub.ingestion.source.powerbi_report_server.constants import (
     RelationshipDirection,
@@ -30,11 +30,13 @@ class CatalogItem(BaseModel):
     has_data_sources: bool = Field(False, alias="HasDataSources")
     data_sources: Optional[List["DataSource"]] = Field(None, alias="DataSources")
 
-    @validator("display_name", always=True)
-    def validate_diplay_name(cls, value, values):
-        if values["created_by"]:
-            return values["created_by"].split("\\")[-1]
-        return ""
+    @model_validator(mode="after")
+    def validate_diplay_name(self):
+        if self.created_by:
+            self.display_name = self.created_by.split("\\")[-1]
+        else:
+            self.display_name = ""
+        return self
 
     def get_urn_part(self):
         return f"reports.{self.id}"