acryl-datahub 1.3.0.1rc9__py3-none-any.whl → 1.3.1.1__py3-none-any.whl

datahub/ingestion/source/grafana/models.py

@@ -79,18 +79,29 @@ class Dashboard(_GrafanaBaseModel):
         for panel_data in panels_data:
             if panel_data.get("type") == "row" and "panels" in panel_data:
                 panels.extend(
-                    Panel.parse_obj(p)
+                    Panel.model_validate(p)
                     for p in panel_data["panels"]
                     if p.get("type") != "row"
                 )
             elif panel_data.get("type") != "row":
-                panels.append(Panel.parse_obj(panel_data))
+                panels.append(Panel.model_validate(panel_data))
         return panels
 
     @classmethod
-    def parse_obj(cls, data: Dict[str, Any]) -> "Dashboard":
+    def model_validate(
+        cls,
+        obj: Any,
+        *,
+        strict: Optional[bool] = None,
+        from_attributes: Optional[bool] = None,
+        context: Optional[Any] = None,
+        by_alias: Optional[bool] = None,
+        by_name: Optional[bool] = None,
+    ) -> "Dashboard":
         """Custom parsing to handle nested panel extraction."""
-        dashboard_data = data.get("dashboard", {})
+        # Handle both direct dashboard data and nested structure with 'dashboard' key
+        dashboard_data = obj.get("dashboard", obj)
+
         _panel_data = dashboard_data.get("panels", [])
         panels = []
         try:
@@ -113,7 +124,14 @@ class Dashboard(_GrafanaBaseModel):
         if "refresh" in dashboard_dict and isinstance(dashboard_dict["refresh"], bool):
             dashboard_dict["refresh"] = str(dashboard_dict["refresh"])
 
-        return super().parse_obj(dashboard_dict)
+        return super().model_validate(
+            dashboard_dict,
+            strict=strict,
+            from_attributes=from_attributes,
+            context=context,
+            by_alias=by_alias,
+            by_name=by_name,
+        )
 
 
 class Folder(_GrafanaBaseModel):

datahub/ingestion/source/hex/api.py

@@ -4,7 +4,7 @@ from datetime import datetime, timezone
 from typing import Any, Dict, Generator, List, Optional, Union
 
 import requests
-from pydantic import BaseModel, Field, ValidationError, validator
+from pydantic import BaseModel, Field, ValidationError, field_validator
 from requests.adapters import HTTPAdapter
 from typing_extensions import assert_never
 from urllib3.util.retry import Retry
@@ -50,7 +50,8 @@ class HexApiProjectAnalytics(BaseModel):
         default=None, alias="publishedResultsUpdatedAt"
     )
 
-    @validator("last_viewed_at", "published_results_updated_at", pre=True)
+    @field_validator("last_viewed_at", "published_results_updated_at", mode="before")
+    @classmethod
     def parse_datetime(cls, value):
         if value is None:
             return None
@@ -167,14 +168,15 @@ class HexApiProjectApiResource(BaseModel):
     class Config:
         extra = "ignore"  # Allow extra fields in the JSON
 
-    @validator(
+    @field_validator(
         "created_at",
         "last_edited_at",
         "last_published_at",
         "archived_at",
         "trashed_at",
-        pre=True,
+        mode="before",
     )
+    @classmethod
     def parse_datetime(cls, value):
         if value is None:
             return None
@@ -292,7 +294,7 @@ class HexApi:
             )
             response.raise_for_status()
 
-            api_response = HexApiProjectsListResponse.parse_obj(response.json())
+            api_response = HexApiProjectsListResponse.model_validate(response.json())
             logger.info(f"Fetched {len(api_response.values)} items")
             params["after"] = (
                 api_response.pagination.after if api_response.pagination else None

datahub/ingestion/source/hex/hex.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, Iterable, List, Optional
 
-from pydantic import Field, SecretStr, root_validator
+from pydantic import Field, SecretStr, model_validator
 from typing_extensions import assert_never
 
 from datahub.configuration.common import AllowDenyPattern
@@ -120,7 +120,8 @@ class HexSourceConfig(
         description="Number of items to fetch per DataHub API call.",
     )
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def validate_lineage_times(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         # In-place update of the input dict would cause state contamination. This was discovered through test failures
         # in test_hex.py where the same dict is reused.
@@ -238,7 +239,7 @@ class HexSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: Dict[str, Any], ctx: PipelineContext) -> "HexSource":
-        config = HexSourceConfig.parse_obj(config_dict)
+        config = HexSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/iceberg/iceberg.py

@@ -161,7 +161,7 @@ class IcebergSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: Dict, ctx: PipelineContext) -> "IcebergSource":
-        config = IcebergSourceConfig.parse_obj(config_dict)
+        config = IcebergSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/iceberg/iceberg_common.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 from typing import Any, Dict, Optional
 
 from humanfriendly import format_timespan
-from pydantic import Field, validator
+from pydantic import Field, field_validator
 from pyiceberg.catalog import Catalog, load_catalog
 from pyiceberg.catalog.rest import RestCatalog
 from requests.adapters import HTTPAdapter
@@ -108,7 +108,8 @@ class IcebergSourceConfig(StatefulIngestionConfigBase, DatasetSourceConfigMixin)
         default=1, description="How many threads will be processing tables"
     )
 
-    @validator("catalog", pre=True, always=True)
+    @field_validator("catalog", mode="before")
+    @classmethod
     def handle_deprecated_catalog_format(cls, value):
         # Once support for deprecated format is dropped, we can remove this validator.
         if (
@@ -131,7 +132,8 @@ class IcebergSourceConfig(StatefulIngestionConfigBase, DatasetSourceConfigMixin)
         # In case the input is already the new format or is invalid
         return value
 
-    @validator("catalog")
+    @field_validator("catalog", mode="after")
+    @classmethod
     def validate_catalog_size(cls, value):
         if len(value) != 1:
             raise ValueError("The catalog must contain exactly one entry.")

datahub/ingestion/source/identity/azure_ad.py

@@ -254,7 +254,7 @@ class AzureADSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = AzureADConfig.parse_obj(config_dict)
+        config = AzureADConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def __init__(self, config: AzureADConfig, ctx: PipelineContext):

datahub/ingestion/source/identity/okta.py

@@ -11,7 +11,7 @@ import nest_asyncio
 from okta.client import Client as OktaClient
 from okta.exceptions import OktaAPIException
 from okta.models import Group, GroupProfile, User, UserProfile, UserStatus
-from pydantic import validator
+from pydantic import model_validator
 from pydantic.fields import Field
 
 from datahub.emitter.mcp import MetadataChangeProposalWrapper
@@ -157,21 +157,21 @@ class OktaConfig(StatefulIngestionConfigBase):
     mask_group_id: bool = True
     mask_user_id: bool = True
 
-    @validator("okta_users_search")
-    def okta_users_one_of_filter_or_search(cls, v, values):
-        if v and values["okta_users_filter"]:
+    @model_validator(mode="after")
+    def okta_users_one_of_filter_or_search(self) -> "OktaConfig":
+        if self.okta_users_search and self.okta_users_filter:
             raise ValueError(
                 "Only one of okta_users_filter or okta_users_search can be set"
             )
-        return v
+        return self
 
-    @validator("okta_groups_search")
-    def okta_groups_one_of_filter_or_search(cls, v, values):
-        if v and values["okta_groups_filter"]:
+    @model_validator(mode="after")
+    def okta_groups_one_of_filter_or_search(self) -> "OktaConfig":
+        if self.okta_groups_search and self.okta_groups_filter:
             raise ValueError(
                 "Only one of okta_groups_filter or okta_groups_search can be set"
             )
-        return v
+        return self
 
 
 @dataclass
@@ -288,7 +288,7 @@ class OktaSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = OktaConfig.parse_obj(config_dict)
+        config = OktaConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def __init__(self, config: OktaConfig, ctx: PipelineContext):

datahub/ingestion/source/kafka/kafka.py

@@ -267,7 +267,7 @@ class KafkaSource(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict: Dict, ctx: PipelineContext) -> "KafkaSource":
-        config: KafkaSourceConfig = KafkaSourceConfig.parse_obj(config_dict)
+        config: KafkaSourceConfig = KafkaSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/ldap.py

@@ -242,7 +242,7 @@ class LDAPSource(StatefulIngestionSourceBase):
     @classmethod
     def create(cls, config_dict: Dict[str, Any], ctx: PipelineContext) -> "LDAPSource":
         """Factory method."""
-        config = LDAPSourceConfig.parse_obj(config_dict)
+        config = LDAPSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/looker/looker_common.py

@@ -28,7 +28,7 @@ from looker_sdk.sdk.api40.models import (
     User,
     WriteQuery,
 )
-from pydantic import validator
+from pydantic import field_validator
 
 import datahub.emitter.mce_builder as builder
 from datahub.api.entities.platformresource.platform_resource import (
@@ -202,8 +202,9 @@ class LookerViewId:
             folder_path=os.path.dirname(self.file_path),
         )
 
-    @validator("view_name")
-    def remove_quotes(cls, v):
+    @field_validator("view_name", mode="after")
+    @classmethod
+    def remove_quotes(cls, v: str) -> str:
         # Sanitize the name.
         v = v.replace('"', "").replace("`", "")
         return v
@@ -931,8 +932,9 @@ class LookerExplore:
     source_file: Optional[str] = None
     tags: List[str] = dataclasses_field(default_factory=list)
 
-    @validator("name")
-    def remove_quotes(cls, v):
+    @field_validator("name", mode="after")
+    @classmethod
+    def remove_quotes(cls, v: str) -> str:
         # Sanitize the name.
         v = v.replace('"', "").replace("`", "")
         return v

datahub/ingestion/source/looker/looker_config.py

@@ -1,11 +1,11 @@
 import dataclasses
 import os
 import re
-from typing import Any, ClassVar, Dict, List, Optional, Tuple, Union, cast
+from typing import Any, ClassVar, Dict, List, Optional, Tuple, Union
 
 import pydantic
 from looker_sdk.sdk.api40.models import DBConnection
-from pydantic import Field, model_validator, validator
+from pydantic import Field, field_validator, model_validator
 
 from datahub.configuration import ConfigModel
 from datahub.configuration.common import (
@@ -198,17 +198,20 @@ class LookerConnectionDefinition(ConfigModel):
         "the top level Looker configuration",
     )
 
-    @validator("platform_env")
+    @field_validator("platform_env", mode="after")
+    @classmethod
     def platform_env_must_be_one_of(cls, v: Optional[str]) -> Optional[str]:
         if v is not None:
             return EnvConfigMixin.env_must_be_one_of(v)
         return v
 
-    @validator("platform", "default_db", "default_schema")
-    def lower_everything(cls, v):
+    @field_validator("platform", "default_db", "default_schema", mode="after")
+    @classmethod
+    def lower_everything(cls, v: Optional[str]) -> Optional[str]:
         """We lower case all strings passed in to avoid casing issues later"""
         if v is not None:
             return v.lower()
+        return v
 
     @classmethod
     def from_looker_connection(
@@ -326,22 +329,20 @@ class LookerDashboardSourceConfig(
         "Dashboards will only be ingested if they're allowed by both this config and dashboard_pattern.",
     )
 
-    @validator("external_base_url", pre=True, always=True)
+    @model_validator(mode="before")
+    @classmethod
     def external_url_defaults_to_api_config_base_url(
-        cls, v: Optional[str], *, values: Dict[str, Any], **kwargs: Dict[str, Any]
-    ) -> Optional[str]:
-        return v or values.get("base_url")
-
-    @validator("extract_independent_looks", always=True)
-    def stateful_ingestion_should_be_enabled(
-        cls, v: Optional[bool], *, values: Dict[str, Any], **kwargs: Dict[str, Any]
-    ) -> Optional[bool]:
-        stateful_ingestion: StatefulStaleMetadataRemovalConfig = cast(
-            StatefulStaleMetadataRemovalConfig, values.get("stateful_ingestion")
-        )
-        if v is True and (
-            stateful_ingestion is None or stateful_ingestion.enabled is False
+        cls, values: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        if "external_base_url" not in values or values["external_base_url"] is None:
+            values["external_base_url"] = values.get("base_url")
+        return values
+
+    @model_validator(mode="after")
+    def stateful_ingestion_should_be_enabled(self):
+        if self.extract_independent_looks is True and (
+            self.stateful_ingestion is None or self.stateful_ingestion.enabled is False
         ):
             raise ValueError("stateful_ingestion.enabled should be set to true")
 
-        return v
+        return self

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]]: