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

datahub/ingestion/source/sigma/data_classes.py

@@ -2,7 +2,7 @@ from copy import deepcopy
 from datetime import datetime
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, root_validator
+from pydantic import BaseModel, model_validator
 
 from datahub.emitter.mcp_builder import ContainerKey
 
@@ -22,7 +22,8 @@ class Workspace(BaseModel):
     createdAt: datetime
     updatedAt: datetime
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def update_values(cls, values: Dict) -> Dict:
         # Create a copy to avoid modifying the input dictionary, preventing state contamination in tests
         values = deepcopy(values)

datahub/ingestion/source/sigma/sigma.py

@@ -150,7 +150,7 @@ class SigmaSource(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = SigmaSourceConfig.parse_obj(config_dict)
+        config = SigmaSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def _gen_workbook_key(self, workbook_id: str) -> WorkbookKey:

datahub/ingestion/source/sigma/sigma_api.py

@@ -108,7 +108,7 @@ class SigmaAPI:
                 self.report.non_accessible_workspaces_count += 1
                 return None
             response.raise_for_status()
-            workspace = Workspace.parse_obj(response.json())
+            workspace = Workspace.model_validate(response.json())
             self.workspaces[workspace.workspaceId] = workspace
             return workspace
         except Exception as e:
@@ -127,7 +127,7 @@ class SigmaAPI:
                 response_dict = response.json()
                 for workspace_dict in response_dict[Constant.ENTRIES]:
                     self.workspaces[workspace_dict[Constant.WORKSPACEID]] = (
-                        Workspace.parse_obj(workspace_dict)
+                        Workspace.model_validate(workspace_dict)
                     )
                 if response_dict[Constant.NEXTPAGE]:
                     url = f"{workspace_url}&page={response_dict[Constant.NEXTPAGE]}"
@@ -197,7 +197,7 @@ class SigmaAPI:
                 response.raise_for_status()
                 response_dict = response.json()
                 for file_dict in response_dict[Constant.ENTRIES]:
-                    file = File.parse_obj(file_dict)
+                    file = File.model_validate(file_dict)
                     file.workspaceId = self.get_workspace_id_from_file_path(
                         file.parentId, file.path
                     )
@@ -225,7 +225,7 @@ class SigmaAPI:
                 response.raise_for_status()
                 response_dict = response.json()
                 for dataset_dict in response_dict[Constant.ENTRIES]:
-                    dataset = SigmaDataset.parse_obj(dataset_dict)
+                    dataset = SigmaDataset.model_validate(dataset_dict)
 
                     if dataset.datasetId not in dataset_files_metadata:
                         self.report.datasets.dropped(
@@ -354,7 +354,7 @@ class SigmaAPI:
                 element_dict[Constant.URL] = (
                     f"{workbook.url}?:nodeId={element_dict[Constant.ELEMENTID]}&:fullScreen=true"
                 )
-                element = Element.parse_obj(element_dict)
+                element = Element.model_validate(element_dict)
                 if (
                     self.config.extract_lineage
                     and self.config.workbook_lineage_pattern.allowed(workbook.name)
@@ -379,7 +379,7 @@ class SigmaAPI:
             )
             response.raise_for_status()
             for page_dict in response.json()[Constant.ENTRIES]:
-                page = Page.parse_obj(page_dict)
+                page = Page.model_validate(page_dict)
                 page.elements = self.get_page_elements(workbook, page)
                 pages.append(page)
             return pages
@@ -400,7 +400,7 @@ class SigmaAPI:
                 response.raise_for_status()
                 response_dict = response.json()
                 for workbook_dict in response_dict[Constant.ENTRIES]:
-                    workbook = Workbook.parse_obj(workbook_dict)
+                    workbook = Workbook.model_validate(workbook_dict)
 
                     if workbook.workbookId not in workbook_files_metadata:
                         # Due to a bug in the Sigma API, it seems like the /files endpoint does not

datahub/ingestion/source/slack/slack.py

@@ -260,7 +260,7 @@ class SlackSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = SlackSourceConfig.parse_obj(config_dict)
+        config = SlackSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_slack_client(self) -> WebClient:

datahub/ingestion/source/snaplogic/snaplogic.py

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

datahub/ingestion/source/snowflake/snowflake_assertion.py

@@ -91,7 +91,7 @@ class SnowflakeAssertionsHandler:
         self, result_row: dict, discovered_datasets: List[str]
     ) -> Optional[MetadataChangeProposalWrapper]:
         try:
-            result = DataQualityMonitoringResult.parse_obj(result_row)
+            result = DataQualityMonitoringResult.model_validate(result_row)
             assertion_guid = result.METRIC_NAME.split("__")[-1].lower()
             status = bool(result.VALUE)  # 1 if PASS, 0 if FAIL
             assertee = self.identifiers.get_dataset_identifier(

datahub/ingestion/source/snowflake/snowflake_config.py

@@ -5,7 +5,7 @@ from enum import Enum
 from typing import Dict, List, Optional, Set
 
 import pydantic
-from pydantic import Field, root_validator, validator
+from pydantic import Field, ValidationInfo, field_validator, model_validator
 
 from datahub.configuration.common import AllowDenyPattern, ConfigModel, HiddenFromDocs
 from datahub.configuration.pattern_utils import UUID_REGEX
@@ -122,10 +122,10 @@ class SnowflakeFilterConfig(SQLFilterConfig):
         description="Whether `schema_pattern` is matched against fully qualified schema name `<catalog>.<schema>`.",
     )
 
-    @root_validator(pre=False, skip_on_failure=True)
-    def validate_legacy_schema_pattern(cls, values: Dict) -> Dict:
-        schema_pattern: Optional[AllowDenyPattern] = values.get("schema_pattern")
-        match_fully_qualified_names = values.get("match_fully_qualified_names")
+    @model_validator(mode="after")
+    def validate_legacy_schema_pattern(self) -> "SnowflakeFilterConfig":
+        schema_pattern: Optional[AllowDenyPattern] = self.schema_pattern
+        match_fully_qualified_names = self.match_fully_qualified_names
 
         if (
             schema_pattern is not None
@@ -145,7 +145,7 @@ class SnowflakeFilterConfig(SQLFilterConfig):
             assert isinstance(schema_pattern, AllowDenyPattern)
             schema_pattern.deny.append(r".*INFORMATION_SCHEMA$")
 
-        return values
+        return self
 
 
 class SnowflakeIdentifierConfig(
@@ -391,7 +391,8 @@ class SnowflakeV2Config(
         "This may be required in the case of _eg_ temporary tables being created in a different database than the ones in the database_name patterns.",
     )
 
-    @validator("convert_urns_to_lowercase")
+    @field_validator("convert_urns_to_lowercase", mode="after")
+    @classmethod
     def validate_convert_urns_to_lowercase(cls, v):
         if not v:
             add_global_warning(
@@ -400,30 +401,31 @@ class SnowflakeV2Config(
 
         return v
 
-    @validator("include_column_lineage")
-    def validate_include_column_lineage(cls, v, values):
-        if not values.get("include_table_lineage") and v:
+    @field_validator("include_column_lineage", mode="after")
+    @classmethod
+    def validate_include_column_lineage(cls, v, info):
+        if not info.data.get("include_table_lineage") and v:
             raise ValueError(
                 "include_table_lineage must be True for include_column_lineage to be set."
             )
         return v
 
-    @root_validator(pre=False, skip_on_failure=True)
-    def validate_unsupported_configs(cls, values: Dict) -> Dict:
-        value = values.get("include_read_operational_stats")
-        if value is not None and value:
+    @model_validator(mode="after")
+    def validate_unsupported_configs(self) -> "SnowflakeV2Config":
+        if (
+            hasattr(self, "include_read_operational_stats")
+            and self.include_read_operational_stats
+        ):
             raise ValueError(
                 "include_read_operational_stats is not supported. Set `include_read_operational_stats` to False.",
             )
 
-        include_technical_schema = values.get("include_technical_schema")
-        include_profiles = (
-            values.get("profiling") is not None and values["profiling"].enabled
-        )
+        include_technical_schema = self.include_technical_schema
+        include_profiles = self.profiling is not None and self.profiling.enabled
         delete_detection_enabled = (
-            values.get("stateful_ingestion") is not None
-            and values["stateful_ingestion"].enabled
-            and values["stateful_ingestion"].remove_stale_metadata
+            self.stateful_ingestion is not None
+            and self.stateful_ingestion.enabled
+            and self.stateful_ingestion.remove_stale_metadata
         )
 
         # TODO: Allow profiling irrespective of basic schema extraction,
@@ -435,13 +437,14 @@ class SnowflakeV2Config(
                 "Cannot perform Deletion Detection or Profiling without extracting snowflake technical schema. Set `include_technical_schema` to True or disable Deletion Detection and Profiling."
             )
 
-        return values
+        return self
 
-    @validator("shares")
+    @field_validator("shares", mode="after")
+    @classmethod
     def validate_shares(
-        cls, shares: Optional[Dict[str, SnowflakeShareConfig]], values: Dict
+        cls, shares: Optional[Dict[str, SnowflakeShareConfig]], info: ValidationInfo
     ) -> Optional[Dict[str, SnowflakeShareConfig]]:
-        current_platform_instance = values.get("platform_instance")
+        current_platform_instance = info.data.get("platform_instance")
 
         if shares:
             # Check: platform_instance should be present
@@ -479,11 +482,12 @@ class SnowflakeV2Config(
 
         return shares
 
-    @root_validator(pre=False, skip_on_failure=True)
-    def validate_queries_v2_stateful_ingestion(cls, values: Dict) -> Dict:
-        if values.get("use_queries_v2"):
-            if values.get("enable_stateful_lineage_ingestion") or values.get(
-                "enable_stateful_usage_ingestion"
+    @model_validator(mode="after")
+    def validate_queries_v2_stateful_ingestion(self) -> "SnowflakeV2Config":
+        if self.use_queries_v2:
+            if (
+                self.enable_stateful_lineage_ingestion
+                or self.enable_stateful_usage_ingestion
             ):
                 logger.warning(
                     "enable_stateful_lineage_ingestion and enable_stateful_usage_ingestion are deprecated "
@@ -491,7 +495,7 @@ class SnowflakeV2Config(
                     "For queries v2, use enable_stateful_time_window instead to enable stateful ingestion "
                     "for the unified time window extraction (lineage + usage + operations + queries)."
                 )
-        return values
+        return self
 
     def outbounds(self) -> Dict[str, Set[DatabaseId]]:
         """

datahub/ingestion/source/snowflake/snowflake_connection.py

@@ -6,6 +6,7 @@ import pydantic
 import snowflake.connector
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import serialization
+from pydantic import field_validator, model_validator
 from snowflake.connector import SnowflakeConnection as NativeSnowflakeConnection
 from snowflake.connector.cursor import DictCursor
 from snowflake.connector.network import (
@@ -125,26 +126,28 @@ class SnowflakeConnectionConfig(ConfigModel):
 
     rename_host_port_to_account_id = pydantic_renamed_field("host_port", "account_id")  # type: ignore[pydantic-field]
 
-    @pydantic.validator("account_id")
-    def validate_account_id(cls, account_id: str, values: Dict) -> str:
+    @field_validator("account_id", mode="after")
+    @classmethod
+    def validate_account_id(cls, account_id: str, info: pydantic.ValidationInfo) -> str:
         account_id = remove_protocol(account_id)
         account_id = remove_trailing_slashes(account_id)
         # Get the domain from config, fallback to default
-        domain = values.get("snowflake_domain", DEFAULT_SNOWFLAKE_DOMAIN)
+        domain = info.data.get("snowflake_domain", DEFAULT_SNOWFLAKE_DOMAIN)
         snowflake_host_suffix = f".{domain}"
         account_id = remove_suffix(account_id, snowflake_host_suffix)
         return account_id
 
-    @pydantic.validator("authentication_type", always=True)
-    def authenticator_type_is_valid(cls, v, values):
+    @field_validator("authentication_type", mode="before")
+    @classmethod
+    def authenticator_type_is_valid(cls, v: Any, info: pydantic.ValidationInfo) -> Any:
         if v not in _VALID_AUTH_TYPES:
             raise ValueError(
                 f"unsupported authenticator type '{v}' was provided,"
                 f" use one of {list(_VALID_AUTH_TYPES.keys())}"
             )
         if (
-            values.get("private_key") is not None
-            or values.get("private_key_path") is not None
+            info.data.get("private_key") is not None
+            or info.data.get("private_key_path") is not None
         ) and v != "KEY_PAIR_AUTHENTICATOR":
             raise ValueError(
                 f"Either `private_key` and `private_key_path` is set but `authentication_type` is {v}. "
@@ -153,21 +156,22 @@ class SnowflakeConnectionConfig(ConfigModel):
         if v == "KEY_PAIR_AUTHENTICATOR":
             # If we are using key pair auth, we need the private key path and password to be set
             if (
-                values.get("private_key") is None
-                and values.get("private_key_path") is None
+                info.data.get("private_key") is None
+                and info.data.get("private_key_path") is None
             ):
                 raise ValueError(
                     f"Both `private_key` and `private_key_path` are none. "
                     f"At least one should be set when using {v} authentication"
                 )
         elif v == "OAUTH_AUTHENTICATOR":
-            cls._check_oauth_config(values.get("oauth_config"))
+            cls._check_oauth_config(info.data.get("oauth_config"))
         logger.info(f"using authenticator type '{v}'")
         return v
 
-    @pydantic.validator("token", always=True)
-    def validate_token_oauth_config(cls, v, values):
-        auth_type = values.get("authentication_type")
+    @field_validator("token", mode="before")
+    @classmethod
+    def validate_token_oauth_config(cls, v: Any, info: pydantic.ValidationInfo) -> Any:
+        auth_type = info.data.get("authentication_type")
         if auth_type == "OAUTH_AUTHENTICATOR_TOKEN":
             if not v:
                 raise ValueError("Token required for OAUTH_AUTHENTICATOR_TOKEN.")
@@ -177,6 +181,24 @@ class SnowflakeConnectionConfig(ConfigModel):
             )
         return v
 
+    @model_validator(mode="after")
+    def validate_authentication_config(self):
+        """Validate authentication configuration consistency."""
+        # Check token requirement for OAUTH_AUTHENTICATOR_TOKEN
+        if self.authentication_type == "OAUTH_AUTHENTICATOR_TOKEN":
+            if not self.token:
+                raise ValueError("Token required for OAUTH_AUTHENTICATOR_TOKEN.")
+
+        # Check private key authentication consistency
+        if self.private_key is not None or self.private_key_path is not None:
+            if self.authentication_type != "KEY_PAIR_AUTHENTICATOR":
+                raise ValueError(
+                    f"Either `private_key` and `private_key_path` is set but `authentication_type` is {self.authentication_type}. "
+                    f"Should be set to 'KEY_PAIR_AUTHENTICATOR' when using key pair authentication"
+                )
+
+        return self
+
     @staticmethod
     def _check_oauth_config(oauth_config: Optional[OAuthConfiguration]) -> None:
         if oauth_config is None:

datahub/ingestion/source/snowflake/snowflake_lineage_v2.py

@@ -14,7 +14,7 @@ from typing import (
     Type,
 )
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 
 from datahub.configuration.datetimes import parse_absolute_time
 from datahub.ingestion.api.closeable import Closeable
@@ -70,7 +70,7 @@ def pydantic_parse_json(field: str) -> "V1Validator":
             return json.loads(v)
         return v
 
-    return validator(field, pre=True, allow_reuse=True)(_parse_from_json)
+    return field_validator(field, mode="before")(_parse_from_json)
 
 
 class UpstreamColumnNode(BaseModel):
@@ -379,7 +379,7 @@ class SnowflakeLineageExtractor(SnowflakeCommonMixin, Closeable):
                 # To avoid that causing a pydantic error we are setting it to an empty list
                 # instead of a list with an empty object
                 db_row["QUERIES"] = "[]"
-            return UpstreamLineageEdge.parse_obj(db_row)
+            return UpstreamLineageEdge.model_validate(db_row)
         except Exception as e:
             self.report.num_upstream_lineage_edge_parsing_failed += 1
             upstream_tables = db_row.get("UPSTREAM_TABLES")

datahub/ingestion/source/snowflake/snowflake_queries.py

@@ -806,7 +806,7 @@ class SnowflakeQueriesSource(Source):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> Self:
-        config = SnowflakeQueriesSourceConfig.parse_obj(config_dict)
+        config = SnowflakeQueriesSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]:

datahub/ingestion/source/sql/athena.py

@@ -386,7 +386,7 @@ class AthenaSource(SQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = AthenaConfig.parse_obj(config_dict)
+        config = AthenaConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     # overwrite this method to allow to specify the usage of a custom dialect

datahub/ingestion/source/sql/clickhouse.py

@@ -10,6 +10,7 @@ import clickhouse_sqlalchemy.types as custom_types
 import pydantic
 from clickhouse_sqlalchemy.drivers import base
 from clickhouse_sqlalchemy.drivers.base import ClickHouseDialect
+from pydantic import model_validator
 from pydantic.fields import Field
 from sqlalchemy import create_engine, text
 from sqlalchemy.engine import reflection
@@ -175,7 +176,8 @@ class ClickHouseConfig(
         return str(url)
 
     # pre = True because we want to take some decision before pydantic initialize the configuration to default values
-    @pydantic.root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def projects_backward_compatibility(cls, values: Dict) -> Dict:
         secure = values.get("secure")
         protocol = values.get("protocol")
@@ -423,7 +425,7 @@ class ClickHouseSource(TwoTierSQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = ClickHouseConfig.parse_obj(config_dict)
+        config = ClickHouseConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunits_internal(self) -> Iterable[Union[MetadataWorkUnit, SqlWorkUnit]]:

datahub/ingestion/source/sql/cockroachdb.py

@@ -39,5 +39,5 @@ class CockroachDBSource(PostgresSource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = CockroachDBConfig.parse_obj(config_dict)
+        config = CockroachDBConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/source/sql/druid.py

@@ -77,5 +77,5 @@ class DruidSource(SQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = DruidConfig.parse_obj(config_dict)
+        config = DruidConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/source/sql/hana.py

@@ -36,5 +36,5 @@ class HanaSource(SQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict: Dict, ctx: PipelineContext) -> "HanaSource":
-        config = HanaConfig.parse_obj(config_dict)
+        config = HanaConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/source/sql/hive.py

@@ -6,7 +6,7 @@ from enum import Enum
 from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 from urllib.parse import urlparse
 
-from pydantic import validator
+from pydantic import field_validator
 from pydantic.fields import Field
 
 # This import verifies that the dependencies are available.
@@ -674,11 +674,13 @@ class HiveConfig(TwoTierSQLAlchemyConfig):
         description="Platform instance for the storage system",
     )
 
-    @validator("host_port")
-    def clean_host_port(cls, v):
+    @field_validator("host_port", mode="after")
+    @classmethod
+    def clean_host_port(cls, v: str) -> str:
         return config_clean.remove_protocol(v)
 
-    @validator("hive_storage_lineage_direction")
+    @field_validator("hive_storage_lineage_direction", mode="after")
+    @classmethod
     def _validate_direction(cls, v: str) -> str:
         """Validate the lineage direction."""
         if v.lower() not in ["upstream", "downstream"]:
@@ -725,7 +727,7 @@ class HiveSource(TwoTierSQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = HiveConfig.parse_obj(config_dict)
+        config = HiveConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]:

datahub/ingestion/source/sql/hive_metastore.py

@@ -351,7 +351,7 @@ class HiveMetastoreSource(SQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = HiveMetastore.parse_obj(config_dict)
+        config = HiveMetastore.model_validate(config_dict)
         return cls(config, ctx)
 
     def gen_database_containers(

datahub/ingestion/source/sql/mssql/source.py

@@ -3,8 +3,8 @@ import re
 import urllib.parse
 from typing import Any, Dict, Iterable, List, Optional, Tuple
 
-import pydantic
 import sqlalchemy.dialects.mssql
+from pydantic import ValidationInfo, field_validator
 from pydantic.fields import Field
 from sqlalchemy import create_engine, inspect
 from sqlalchemy.engine.base import Connection
@@ -140,11 +140,18 @@ class SQLServerConfig(BasicSQLAlchemyConfig):
         description="Indicates if the SQL Server instance is running on AWS RDS. When None (default), automatic detection will be attempted using server name analysis.",
     )
 
-    @pydantic.validator("uri_args")
-    def passwords_match(cls, v, values, **kwargs):
-        if values["use_odbc"] and not values["sqlalchemy_uri"] and "driver" not in v:
+    @field_validator("uri_args", mode="after")
+    @classmethod
+    def passwords_match(
+        cls, v: Dict[str, Any], info: ValidationInfo, **kwargs: Any
+    ) -> Dict[str, Any]:
+        if (
+            info.data["use_odbc"]
+            and not info.data["sqlalchemy_uri"]
+            and "driver" not in v
+        ):
             raise ValueError("uri_args must contain a 'driver' option")
-        elif not values["use_odbc"] and v:
+        elif not info.data["use_odbc"] and v:
             raise ValueError("uri_args is not supported when ODBC is disabled")
         return v
 
@@ -314,7 +321,7 @@ class SQLServerSource(SQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict: Dict, ctx: PipelineContext) -> "SQLServerSource":
-        config = SQLServerConfig.parse_obj(config_dict)
+        config = SQLServerConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     # override to get table descriptions

datahub/ingestion/source/sql/mysql.py

@@ -150,7 +150,7 @@ class MySQLSource(TwoTierSQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = MySQLConfig.parse_obj(config_dict)
+        config = MySQLConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def _setup_rds_iam_event_listener(

datahub/ingestion/source/sql/oracle.py

@@ -10,8 +10,8 @@ from typing import Any, Dict, Iterable, List, NoReturn, Optional, Tuple, Union,
 from unittest.mock import patch
 
 import oracledb
-import pydantic
 import sqlalchemy.engine
+from pydantic import ValidationInfo, field_validator
 from pydantic.fields import Field
 from sqlalchemy import event, sql
 from sqlalchemy.dialects.oracle.base import ischema_names
@@ -101,25 +101,32 @@ class OracleConfig(BasicSQLAlchemyConfig):
         "On Linux, this value is ignored, as ldconfig or LD_LIBRARY_PATH will define the location.",
     )
 
-    @pydantic.validator("service_name")
-    def check_service_name(cls, v, values):
-        if values.get("database") and v:
+    @field_validator("service_name", mode="after")
+    @classmethod
+    def check_service_name(
+        cls, v: Optional[str], info: ValidationInfo
+    ) -> Optional[str]:
+        if info.data.get("database") and v:
             raise ValueError(
                 "specify one of 'database' and 'service_name', but not both"
             )
         return v
 
-    @pydantic.validator("data_dictionary_mode")
-    def check_data_dictionary_mode(cls, value):
+    @field_validator("data_dictionary_mode", mode="after")
+    @classmethod
+    def check_data_dictionary_mode(cls, value: str) -> str:
         if value not in ("ALL", "DBA"):
             raise ValueError("Specify one of data dictionary views mode: 'ALL', 'DBA'.")
         return value
 
-    @pydantic.validator("thick_mode_lib_dir", always=True)
-    def check_thick_mode_lib_dir(cls, v, values):
+    @field_validator("thick_mode_lib_dir", mode="before")
+    @classmethod
+    def check_thick_mode_lib_dir(
+        cls, v: Optional[str], info: ValidationInfo
+    ) -> Optional[str]:
         if (
             v is None
-            and values.get("enable_thick_mode")
+            and info.data.get("enable_thick_mode")
             and (platform.system() == "Darwin" or platform.system() == "Windows")
         ):
             raise ValueError(
@@ -659,7 +666,7 @@ class OracleSource(SQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = OracleConfig.parse_obj(config_dict)
+        config = OracleConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_db_name(self, inspector: Inspector) -> str:

datahub/ingestion/source/sql/postgres.py

@@ -212,7 +212,7 @@ class PostgresSource(SQLAlchemySource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = PostgresConfig.parse_obj(config_dict)
+        config = PostgresConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def _setup_rds_iam_event_listener(
@@ -288,7 +288,7 @@ class PostgresSource(SQLAlchemySource):
                 return {}
 
             for row in results:
-                data.append(ViewLineageEntry.parse_obj(row))
+                data.append(ViewLineageEntry.model_validate(row))
 
         lineage_elements: Dict[Tuple[str, str], List[str]] = defaultdict(list)
         # Loop over the lineages in the JSON data.

datahub/ingestion/source/sql/presto.py

@@ -115,7 +115,7 @@ class PrestoSource(TrinoSource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = PrestoConfig.parse_obj(config_dict)
+        config = PrestoConfig.model_validate(config_dict)
         return cls(config, ctx)