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

datahub/ingestion/source/preset.py

@@ -2,7 +2,7 @@ import logging
 from typing import Dict, Optional
 
 import requests
-from pydantic import root_validator, validator
+from pydantic import field_validator, model_validator
 from pydantic.fields import Field
 
 from datahub.emitter.mce_builder import DEFAULT_ENV
@@ -55,16 +55,16 @@ class PresetConfig(SupersetConfig):
         description="Can be used to change mapping for database names in superset to what you have in datahub",
     )
 
-    @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) -> "PresetConfig":
+        if self.display_uri is None:
+            self.display_uri = self.connect_uri
+        return self
 
 
 @platform_name("Preset")

datahub/ingestion/source/pulsar.py

@@ -235,7 +235,7 @@ class PulsarSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = PulsarSourceConfig.parse_obj(config_dict)
+        config = PulsarSourceConfig.model_validate(config_dict)
 
         # Do not include each individual partition for partitioned topics,
         if config.exclude_individual_partitions:

datahub/ingestion/source/qlik_sense/data_classes.py

@@ -3,7 +3,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional, Type, Union
 
-from pydantic import BaseModel, ConfigDict, Field, root_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from datahub.emitter.mcp_builder import ContainerKey
 from datahub.ingestion.source.qlik_sense.config import QLIK_DATETIME_FORMAT, Constant
@@ -92,7 +92,8 @@ class Space(_QlikBaseModel):
     updatedAt: datetime
     ownerId: Optional[str] = None
 
-    @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)
@@ -121,7 +122,8 @@ class SchemaField(_QlikBaseModel):
     primaryKey: Optional[bool] = None
     nullable: Optional[bool] = None
 
-    @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)
@@ -138,7 +140,8 @@ class QlikDataset(Item):
     itemId: str
     datasetSchema: List[SchemaField]
 
-    @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)
@@ -174,7 +177,8 @@ class Chart(_QlikBaseModel):
     qDimension: List[AxisProperty]
     qMeasure: List[AxisProperty]
 
-    @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)
@@ -193,7 +197,8 @@ class Sheet(_QlikBaseModel):
     updatedAt: datetime
     charts: List[Chart] = []
 
-    @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)
@@ -220,7 +225,8 @@ class QlikTable(_QlikBaseModel):
     databaseName: Optional[str] = None
     schemaName: Optional[str] = None
 
-    @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)
@@ -239,7 +245,8 @@ class App(Item):
     sheets: List[Sheet] = []
     tables: List[QlikTable] = []
 
-    @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/qlik_sense/qlik_api.py

@@ -56,7 +56,7 @@ class QlikAPI:
                 response.raise_for_status()
                 response_dict = response.json()
                 for space_dict in response_dict[Constant.DATA]:
-                    space = Space.parse_obj(space_dict)
+                    space = Space.model_validate(space_dict)
                     spaces.append(space)
                     self.spaces[space.id] = space.name
                 if Constant.NEXT in response_dict[Constant.LINKS]:
@@ -64,7 +64,7 @@ class QlikAPI:
                 else:
                     break
             # Add personal space entity
-            spaces.append(Space.parse_obj(PERSONAL_SPACE_DICT))
+            spaces.append(Space.model_validate(PERSONAL_SPACE_DICT))
             self.spaces[PERSONAL_SPACE_DICT[Constant.ID]] = PERSONAL_SPACE_DICT[
                 Constant.NAME
             ]
@@ -78,7 +78,7 @@ class QlikAPI:
             response.raise_for_status()
             response_dict = response.json()
             response_dict[Constant.ITEMID] = item_id
-            return QlikDataset.parse_obj(response_dict)
+            return QlikDataset.model_validate(response_dict)
         except Exception as e:
             self._log_http_error(
                 message=f"Unable to fetch dataset with id {dataset_id}. Exception: {e}"
@@ -119,7 +119,7 @@ class QlikAPI:
                     f"Chart with id {chart_id} of sheet {sheet_id} does not have hypercube. q_layout: {q_layout}"
                 )
                 return None
-            return Chart.parse_obj(q_layout)
+            return Chart.model_validate(q_layout)
         except Exception as e:
             self._log_http_error(
                 message=f"Unable to fetch chart {chart_id} of sheet {sheet_id}. Exception: {e}"
@@ -140,7 +140,7 @@ class QlikAPI:
             if Constant.OWNERID not in sheet_dict[Constant.QMETA]:
                 # That means sheet is private sheet
                 return None
-            sheet = Sheet.parse_obj(sheet_dict[Constant.QMETA])
+            sheet = Sheet.model_validate(sheet_dict[Constant.QMETA])
             if Constant.QCHILDLIST not in sheet_dict:
                 logger.warning(
                     f"Sheet {sheet.title} with id {sheet_id} does not have any charts. sheet_dict: {sheet_dict}"
@@ -222,7 +222,7 @@ class QlikAPI:
                 return []
             response = websocket_connection.websocket_send_request(method="GetLayout")
             for table_dict in response[Constant.QLAYOUT][Constant.TABLES]:
-                tables.append(QlikTable.parse_obj(table_dict))
+                tables.append(QlikTable.model_validate(table_dict))
             websocket_connection.handle.pop()
             self._add_qri_of_tables(tables, app_id)
         except Exception as e:
@@ -270,7 +270,7 @@ class QlikAPI:
             response = websocket_connection.websocket_send_request(
                 method="GetAppLayout"
             )
-            app = App.parse_obj(response[Constant.QLAYOUT])
+            app = App.model_validate(response[Constant.QLAYOUT])
             app.sheets = self._get_app_sheets(websocket_connection, app_id)
             app.tables = self._get_app_used_tables(websocket_connection, app_id)
             websocket_connection.close_websocket()

datahub/ingestion/source/qlik_sense/qlik_sense.py

@@ -148,7 +148,7 @@ class QlikSenseSource(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = QlikSourceConfig.parse_obj(config_dict)
+        config = QlikSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def _gen_space_key(self, space_id: str) -> SpaceKey:

datahub/ingestion/source/redshift/config.py

@@ -3,7 +3,7 @@ from copy import deepcopy
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
-from pydantic import root_validator
+from pydantic import model_validator
 from pydantic.fields import Field
 
 from datahub.configuration import ConfigModel
@@ -182,7 +182,8 @@ class RedshiftConfig(
         description="Whether to skip EXTERNAL tables.",
     )
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def check_email_is_set_on_usage(cls, values):
         if values.get("include_usage_statistics"):
             assert "email_domain" in values and values["email_domain"], (
@@ -190,31 +191,28 @@ class RedshiftConfig(
             )
         return values
 
-    @root_validator(skip_on_failure=True)
-    def check_database_is_set(cls, values):
-        assert values.get("database"), "database must be set"
-        return values
-
-    @root_validator(skip_on_failure=True)
-    def backward_compatibility_configs_set(cls, values: Dict) -> Dict:
-        match_fully_qualified_names = values.get("match_fully_qualified_names")
-
-        schema_pattern: Optional[AllowDenyPattern] = values.get("schema_pattern")
+    @model_validator(mode="after")
+    def check_database_is_set(self) -> "RedshiftConfig":
+        assert self.database, "database must be set"
+        return self
 
+    @model_validator(mode="after")
+    def backward_compatibility_configs_set(self) -> "RedshiftConfig":
         if (
-            schema_pattern is not None
-            and schema_pattern != AllowDenyPattern.allow_all()
-            and match_fully_qualified_names is not None
-            and not match_fully_qualified_names
+            self.schema_pattern is not None
+            and self.schema_pattern != AllowDenyPattern.allow_all()
+            and self.match_fully_qualified_names is not None
+            and not self.match_fully_qualified_names
         ):
             logger.warning(
                 "Please update `schema_pattern` to match against fully qualified schema name `<database_name>.<schema_name>` and set config `match_fully_qualified_names : True`."
                 "Current default `match_fully_qualified_names: False` is only to maintain backward compatibility. "
                 "The config option `match_fully_qualified_names` will be deprecated in future and the default behavior will assume `match_fully_qualified_names: True`."
             )
-        return values
+        return self
 
-    @root_validator(skip_on_failure=True)
+    @model_validator(mode="before")
+    @classmethod
     def connection_config_compatibility_set(cls, values: Dict) -> Dict:
         # Create a copy to avoid modifying the input dictionary, preventing state contamination in tests
         values = deepcopy(values)
@@ -231,8 +229,8 @@ class RedshiftConfig(
         if "options" in values and "connect_args" in values["options"]:
             values["extra_client_options"] = values["options"]["connect_args"]
 
-        if values["extra_client_options"]:
-            if values["options"]:
+        if values.get("extra_client_options"):
+            if values.get("options"):
                 values["options"]["connect_args"] = values["extra_client_options"]
             else:
                 values["options"] = {"connect_args": values["extra_client_options"]}

datahub/ingestion/source/redshift/redshift.py

@@ -236,7 +236,7 @@ class RedshiftSource(StatefulIngestionSourceBase, TestableSource):
             RedshiftConfig.Config.extra = (
                 pydantic.Extra.allow
             )  # we are okay with extra fields during this stage
-            config = RedshiftConfig.parse_obj(config_dict)
+            config = RedshiftConfig.model_validate(config_dict)
             # source = RedshiftSource(config, report)
             connection: redshift_connector.Connection = (
                 RedshiftSource.get_redshift_connection(config)
@@ -316,7 +316,7 @@ class RedshiftSource(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = RedshiftConfig.parse_obj(config_dict)
+        config = RedshiftConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod

datahub/ingestion/source/redshift/usage.py

@@ -1,12 +1,12 @@
 import collections
 import logging
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Callable, Dict, Iterable, List, Optional, Tuple, Union
 
 import cachetools
-import pydantic.error_wrappers
 import redshift_connector
+from pydantic import ValidationError, field_validator
 from pydantic.fields import Field
 from pydantic.main import BaseModel
 
@@ -64,6 +64,26 @@ class RedshiftAccessEvent(BaseModel):
     starttime: datetime
     endtime: datetime
 
+    @field_validator("starttime", "endtime", mode="before")
+    @classmethod
+    def ensure_utc_datetime(cls, v):
+        """Ensure datetime fields are treated as UTC for consistency with Pydantic V1 behavior.
+
+        Pydantic V2 assumes local timezone for naive datetime strings, whereas Pydantic V1 assumed UTC.
+        This validator restores V1 behavior to maintain timestamp consistency.
+        """
+        if isinstance(v, str):
+            # Parse as naive datetime, then assume UTC (matching V1 behavior)
+            dt = datetime.fromisoformat(v)
+            if dt.tzinfo is None:
+                # Treat naive datetime as UTC (this was the V1 behavior)
+                dt = dt.replace(tzinfo=timezone.utc)
+            return dt
+        elif isinstance(v, datetime) and v.tzinfo is None:
+            # If we get a naive datetime object, assume UTC
+            return v.replace(tzinfo=timezone.utc)
+        return v
+
 
 class RedshiftUsageExtractor:
     """
@@ -291,7 +311,7 @@ class RedshiftUsageExtractor:
                             else None
                         ),
                     )
-                except pydantic.error_wrappers.ValidationError as e:
+                except ValidationError as e:
                     logging.warning(
                         f"Validation error on access event creation from row {row}. The error was: {e} Skipping ...."
                     )

datahub/ingestion/source/s3/config.py

@@ -1,7 +1,7 @@
 import logging
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Optional, Union
 
-import pydantic
+from pydantic import ValidationInfo, field_validator, model_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import AllowDenyPattern
@@ -12,7 +12,6 @@ from datahub.configuration.validate_field_deprecation import pydantic_field_depr
 from datahub.configuration.validate_field_rename import pydantic_renamed_field
 from datahub.ingestion.source.aws.aws_common import AwsConnectionConfig
 from datahub.ingestion.source.data_lake_common.config import PathSpecsConfigMixin
-from datahub.ingestion.source.data_lake_common.path_spec import PathSpec
 from datahub.ingestion.source.s3.datalake_profiler_config import DataLakeProfilerConfig
 from datahub.ingestion.source.state.stale_entity_removal_handler import (
     StatefulStaleMetadataRemovalConfig,
@@ -117,69 +116,91 @@ class DataLakeSourceConfig(
             self.profiling.operation_config
         )
 
-    @pydantic.validator("path_specs", always=True)
-    def check_path_specs_and_infer_platform(
-        cls, path_specs: List[PathSpec], values: Dict
-    ) -> List[PathSpec]:
+    @field_validator("path_specs", mode="before")
+    @classmethod
+    def check_path_specs(cls, path_specs: Any, info: ValidationInfo) -> Any:
         if len(path_specs) == 0:
             raise ValueError("path_specs must not be empty")
 
-        # Check that all path specs have the same platform.
-        guessed_platforms = {
-            "s3" if path_spec.is_s3 else "file" for path_spec in path_specs
-        }
-        if len(guessed_platforms) > 1:
-            raise ValueError(
-                f"Cannot have multiple platforms in path_specs: {guessed_platforms}"
-            )
-        guessed_platform = guessed_platforms.pop()
-
-        # Ensure s3 configs aren't used for file sources.
-        if guessed_platform != "s3" and (
-            values.get("use_s3_object_tags") or values.get("use_s3_bucket_tags")
-        ):
-            raise ValueError(
-                "Cannot grab s3 object/bucket tags when platform is not s3. Remove the flag or use s3."
-            )
-
-        # Infer platform if not specified.
-        if values.get("platform") and values["platform"] != guessed_platform:
-            raise ValueError(
-                f"All path_specs belong to {guessed_platform} platform, but platform is set to {values['platform']}"
-            )
-        else:
-            logger.debug(f'Setting config "platform": {guessed_platform}')
-            values["platform"] = guessed_platform
+        # Basic validation - path specs consistency and S3 config validation is now handled in model_validator
 
         return path_specs
 
-    @pydantic.validator("platform", always=True)
-    def platform_valid(cls, platform: Any, values: dict) -> str:
-        inferred_platform = values.get("platform")  # we may have inferred it above
-        platform = platform or inferred_platform
-        if not platform:
-            raise ValueError("platform must not be empty")
-
-        if platform != "s3" and values.get("use_s3_bucket_tags"):
-            raise ValueError(
-                "Cannot grab s3 bucket tags when platform is not s3. Remove the flag or ingest from s3."
-            )
-        if platform != "s3" and values.get("use_s3_object_tags"):
-            raise ValueError(
-                "Cannot grab s3 object tags when platform is not s3. Remove the flag or ingest from s3."
-            )
-        if platform != "s3" and values.get("use_s3_content_type"):
-            raise ValueError(
-                "Cannot grab s3 object content type when platform is not s3. Remove the flag or ingest from s3."
-            )
-
-        return platform
-
-    @pydantic.root_validator(skip_on_failure=True)
-    def ensure_profiling_pattern_is_passed_to_profiling(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        profiling: Optional[DataLakeProfilerConfig] = values.get("profiling")
+    @model_validator(mode="after")
+    def ensure_profiling_pattern_is_passed_to_profiling(self) -> "DataLakeSourceConfig":
+        profiling = self.profiling
         if profiling is not None and profiling.enabled:
-            profiling._allow_deny_patterns = values["profile_patterns"]
-        return values
+            profiling._allow_deny_patterns = self.profile_patterns
+        return self
+
+    @model_validator(mode="after")
+    def validate_platform_and_config_consistency(self) -> "DataLakeSourceConfig":
+        """Infer platform from path_specs and validate config consistency."""
+        # Track whether platform was explicitly provided
+        platform_was_explicit = bool(self.platform)
+
+        # Infer platform from path_specs if not explicitly set
+        if not self.platform and self.path_specs:
+            guessed_platforms = set()
+            for path_spec in self.path_specs:
+                if (
+                    hasattr(path_spec, "include")
+                    and path_spec.include
+                    and path_spec.include.startswith("s3://")
+                ):
+                    guessed_platforms.add("s3")
+                else:
+                    guessed_platforms.add("file")
+
+            # Ensure all path specs belong to the same platform
+            if len(guessed_platforms) > 1:
+                raise ValueError(
+                    f"Cannot have multiple platforms in path_specs: {guessed_platforms}"
+                )
+
+            if guessed_platforms:
+                guessed_platform = guessed_platforms.pop()
+                logger.debug(f"Inferred platform: {guessed_platform}")
+                self.platform = guessed_platform
+            else:
+                self.platform = "file"
+        elif not self.platform:
+            self.platform = "file"
+
+        # Validate platform consistency only when platform was inferred (not explicitly set)
+        # This allows sources like GCS to set platform="gcs" with s3:// URIs for correct container subtypes
+        if not platform_was_explicit and self.platform and self.path_specs:
+            expected_platforms = set()
+            for path_spec in self.path_specs:
+                if (
+                    hasattr(path_spec, "include")
+                    and path_spec.include
+                    and path_spec.include.startswith("s3://")
+                ):
+                    expected_platforms.add("s3")
+                else:
+                    expected_platforms.add("file")
+
+            if len(expected_platforms) == 1:
+                expected_platform = expected_platforms.pop()
+                if self.platform != expected_platform:
+                    raise ValueError(
+                        f"All path_specs belong to {expected_platform} platform, but platform was inferred as {self.platform}"
+                    )
+
+        # Validate S3-specific configurations
+        if self.platform != "s3":
+            if self.use_s3_bucket_tags:
+                raise ValueError(
+                    "Cannot grab s3 bucket tags when platform is not s3. Remove the flag or ingest from s3."
+                )
+            if self.use_s3_object_tags:
+                raise ValueError(
+                    "Cannot grab s3 object tags when platform is not s3. Remove the flag or ingest from s3."
+                )
+            if self.use_s3_content_type:
+                raise ValueError(
+                    "Cannot grab s3 object content type when platform is not s3. Remove the flag or ingest from s3."
+                )
+
+        return self

datahub/ingestion/source/s3/datalake_profiler_config.py

@@ -1,6 +1,7 @@
-from typing import Any, Dict, Optional
+from typing import Optional
 
 import pydantic
+from pydantic import model_validator
 from pydantic.fields import Field
 
 from datahub.configuration import ConfigModel
@@ -72,21 +73,18 @@ class DataLakeProfilerConfig(ConfigModel):
         description="Whether to profile for the sample values for all columns.",
     )
 
-    @pydantic.root_validator(skip_on_failure=True)
-    def ensure_field_level_settings_are_normalized(
-        cls: "DataLakeProfilerConfig", values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        max_num_fields_to_profile_key = "max_number_of_fields_to_profile"
-        max_num_fields_to_profile = values.get(max_num_fields_to_profile_key)
+    @model_validator(mode="after")
+    def ensure_field_level_settings_are_normalized(self) -> "DataLakeProfilerConfig":
+        max_num_fields_to_profile = self.max_number_of_fields_to_profile
 
         # Disable all field-level metrics.
-        if values.get("profile_table_level_only"):
-            for field_level_metric in cls.__fields__:
-                if field_level_metric.startswith("include_field_"):
-                    values.setdefault(field_level_metric, False)
+        if self.profile_table_level_only:
+            for field_name in self.__fields__:
+                if field_name.startswith("include_field_"):
+                    setattr(self, field_name, False)
 
             assert max_num_fields_to_profile is None, (
-                f"{max_num_fields_to_profile_key} should be set to None"
+                "max_number_of_fields_to_profile should be set to None"
             )
 
-        return values
+        return self

datahub/ingestion/source/s3/source.py

@@ -53,8 +53,11 @@ from datahub.ingestion.source.data_lake_common.data_lake_utils import (
 from datahub.ingestion.source.data_lake_common.object_store import (
     create_object_store_adapter,
 )
-from datahub.ingestion.source.data_lake_common.path_spec import FolderTraversalMethod
-from datahub.ingestion.source.s3.config import DataLakeSourceConfig, PathSpec
+from datahub.ingestion.source.data_lake_common.path_spec import (
+    FolderTraversalMethod,
+    PathSpec,
+)
+from datahub.ingestion.source.s3.config import DataLakeSourceConfig
 from datahub.ingestion.source.s3.report import DataLakeSourceReport
 from datahub.ingestion.source.schema_inference import avro, csv_tsv, json, parquet
 from datahub.ingestion.source.schema_inference.base import SchemaInferenceBase
@@ -261,7 +264,7 @@ class S3Source(StatefulIngestionSourceBase):
             )
 
         config_report = {
-            config_option: config.dict().get(config_option)
+            config_option: config.model_dump().get(config_option)
             for config_option in config_options_to_report
         }
         config_report = {
@@ -278,7 +281,7 @@ class S3Source(StatefulIngestionSourceBase):
             telemetry.telemetry_instance.ping(
                 "data_lake_profiling_config",
                 {
-                    config_flag: config.profiling.dict().get(config_flag)
+                    config_flag: config.profiling.model_dump().get(config_flag)
                     for config_flag in profiling_flags_to_report
                 },
             )
@@ -370,7 +373,7 @@ class S3Source(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = DataLakeSourceConfig.parse_obj(config_dict)
+        config = DataLakeSourceConfig.model_validate(config_dict)
 
         return cls(config, ctx)
 

datahub/ingestion/source/sac/sac.py

@@ -8,7 +8,7 @@ import pyodata
 import pyodata.v2.model
 import pyodata.v2.service
 from authlib.integrations.requests_client import OAuth2Session
-from pydantic import Field, SecretStr, validator
+from pydantic import Field, SecretStr, field_validator
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
@@ -159,7 +159,8 @@ class SACSourceConfig(
         description="Template for generating dataset urns of consumed queries, the placeholder {query} can be used within the template for inserting the name of the query",
     )
 
-    @validator("tenant_url", "token_url")
+    @field_validator("tenant_url", "token_url", mode="after")
+    @classmethod
     def remove_trailing_slash(cls, v):
         return config_clean.remove_trailing_slashes(v)
 
@@ -209,7 +210,7 @@ class SACSource(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "SACSource":
-        config = SACSourceConfig.parse_obj(config_dict)
+        config = SACSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod
@@ -217,7 +218,7 @@ class SACSource(StatefulIngestionSourceBase, TestableSource):
         test_report = TestConnectionReport()
 
         try:
-            config = SACSourceConfig.parse_obj(config_dict)
+            config = SACSourceConfig.model_validate(config_dict)
 
             # when creating the pyodata.Client, the metadata is automatically parsed and validated
             session, _ = SACSource.get_sac_connection(config)

datahub/ingestion/source/salesforce.py

@@ -7,7 +7,7 @@ from enum import Enum
 from typing import Any, Dict, Iterable, List, Literal, Optional, TypedDict
 
 import requests
-from pydantic import Field, validator
+from pydantic import Field, field_validator
 from simple_salesforce import Salesforce
 from simple_salesforce.exceptions import SalesforceAuthenticationFailed
 
@@ -172,7 +172,8 @@ class SalesforceConfig(
             self.profiling.operation_config
         )
 
-    @validator("instance_url")
+    @field_validator("instance_url", mode="after")
+    @classmethod
     def remove_trailing_slash(cls, v):
         return config_clean.remove_trailing_slashes(v)
 

datahub/ingestion/source/schema/json_schema.py

@@ -12,7 +12,7 @@ from urllib.parse import urlparse
 
 import jsonref
 import requests
-from pydantic import AnyHttpUrl, DirectoryPath, FilePath, validator
+from pydantic import AnyHttpUrl, DirectoryPath, FilePath, field_validator
 from pydantic.fields import Field
 
 import datahub.metadata.schema_classes as models
@@ -90,7 +90,7 @@ class JsonSchemaSourceConfig(StatefulIngestionConfigBase, DatasetSourceConfigMix
         description="Use this if URI-s need to be modified during reference resolution. Simple string match - replace capabilities are supported.",
     )
 
-    @validator("path")
+    @field_validator("path", mode="after")
     def download_http_url_to_temp_file(cls, v):
         if isinstance(v, AnyHttpUrl):
             try: