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

datahub/cli/migrate.py

@@ -318,13 +318,13 @@ def migrate_containers(
         try:
             newKey: Union[SchemaKey, DatabaseKey, ProjectIdKey, BigQueryDatasetKey]
             if subType == "Schema":
-                newKey = SchemaKey.parse_obj(customProperties)
+                newKey = SchemaKey.model_validate(customProperties)
             elif subType == "Database":
-                newKey = DatabaseKey.parse_obj(customProperties)
+                newKey = DatabaseKey.model_validate(customProperties)
             elif subType == "Project":
-                newKey = ProjectIdKey.parse_obj(customProperties)
+                newKey = ProjectIdKey.model_validate(customProperties)
             elif subType == "Dataset":
-                newKey = BigQueryDatasetKey.parse_obj(customProperties)
+                newKey = BigQueryDatasetKey.model_validate(customProperties)
             else:
                 log.warning(f"Invalid subtype {subType}. Skipping")
                 continue

datahub/cli/quickstart_versioning.py

@@ -80,7 +80,7 @@ class QuickstartVersionMappingConfig(BaseModel):
             path = os.path.expanduser(LOCAL_QUICKSTART_MAPPING_FILE)
             with open(path) as f:
                 config_raw = yaml.safe_load(f)
-            return cls.parse_obj(config_raw)
+            return cls.model_validate(config_raw)
 
         config_raw = None
         try:
@@ -110,7 +110,7 @@ class QuickstartVersionMappingConfig(BaseModel):
                 }
             )
 
-        config = cls.parse_obj(config_raw)
+        config = cls.model_validate(config_raw)
 
         # If stable is not defined in the config, we need to fetch the latest version from github.
         if config.quickstart_version_map.get("stable") is None:
@@ -177,7 +177,7 @@ def save_quickstart_config(
     path = os.path.expanduser(path)
     os.makedirs(os.path.dirname(path), exist_ok=True)
     with open(path, "w") as f:
-        yaml.dump(config.dict(), f)
+        yaml.dump(config.model_dump(), f)
     logger.info(f"Saved quickstart config to {path}.")
 
 

datahub/cli/specific/group_cli.py

@@ -42,7 +42,7 @@ def upsert(file: Path, override_editable: bool) -> None:
     with get_default_graph(ClientMode.CLI) as emitter:
         for group_config in group_configs:
             try:
-                datahub_group = CorpGroup.parse_obj(group_config)
+                datahub_group = CorpGroup.model_validate(group_config)
                 for mcp in datahub_group.generate_mcp(
                     generation_config=CorpGroupGenerationConfig(
                         override_editable=override_editable, datahub_graph=emitter

datahub/cli/specific/structuredproperties_cli.py

@@ -85,7 +85,7 @@ def list(details: bool, to_file: str) -> None:
             with open(file, "r") as fp:
                 existing_objects = yaml.load(fp)  # this is a list of dicts
                 existing_objects = [
-                    StructuredProperties.parse_obj(obj) for obj in existing_objects
+                    StructuredProperties.model_validate(obj) for obj in existing_objects
                 ]
                 objects = [obj for obj in objects]
                 # do a positional update of the existing objects

datahub/cli/specific/user_cli.py

@@ -42,7 +42,7 @@ def upsert(file: Path, override_editable: bool) -> None:
     with get_default_graph(ClientMode.CLI) as emitter:
         for user_config in user_configs:
             try:
-                datahub_user: CorpUser = CorpUser.parse_obj(user_config)
+                datahub_user: CorpUser = CorpUser.model_validate(user_config)
 
                 emitter.emit_all(
                     datahub_user.generate_mcp(

datahub/configuration/common.py

@@ -140,6 +140,18 @@ class ConfigModel(BaseModel):
 
     @classmethod
     def parse_obj_allow_extras(cls, obj: Any) -> Self:
+        """Parse an object while allowing extra fields.
+
+        'parse_obj' in Pydantic v1 is equivalent to 'model_validate' in Pydantic v2.
+        However, 'parse_obj_allow_extras' in v1 is not directly available in v2.
+
+        `model_validate(..., strict=False)` does not work because it still raises errors on extra fields;
+        strict=False only affects type coercion and validation strictness, not extra field handling.
+
+        This method temporarily modifies the model's configuration to allow extra fields
+
+        TODO: Do we really need to support this behaviour? Consider removing this method in future.
+        """
         if PYDANTIC_VERSION_2:
             try:
                 with unittest.mock.patch.dict(
@@ -148,12 +160,12 @@ class ConfigModel(BaseModel):
                     clear=False,
                 ):
                     cls.model_rebuild(force=True)  # type: ignore
-                    return cls.parse_obj(obj)
+                    return cls.model_validate(obj)
             finally:
                 cls.model_rebuild(force=True)  # type: ignore
         else:
             with unittest.mock.patch.object(cls.Config, "extra", pydantic.Extra.allow):
-                return cls.parse_obj(obj)
+                return cls.model_validate(obj)
 
 
 class PermissiveConfigModel(ConfigModel):

datahub/configuration/connection_resolver.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Type
 
-import pydantic
+from pydantic import model_validator
 
 from datahub.ingestion.api.global_context import get_graph_context
 
@@ -40,4 +40,4 @@ def auto_connection_resolver(
     # https://github.com/pydantic/pydantic/blob/v1.10.9/pydantic/main.py#L264
     # This hack ensures that multiple validators do not overwrite each other.
     _resolve_connection.__name__ = f"{_resolve_connection.__name__}_{connection_field}"
-    return pydantic.root_validator(pre=True, allow_reuse=True)(_resolve_connection)
+    return model_validator(mode="before")(_resolve_connection)

datahub/configuration/git.py

@@ -1,7 +1,14 @@
 import pathlib
+from copy import deepcopy
 from typing import Any, Dict, Optional, Union
 
-from pydantic import Field, FilePath, SecretStr, validator
+from pydantic import (
+    Field,
+    FilePath,
+    SecretStr,
+    field_validator,
+    model_validator,
+)
 
 from datahub.configuration.common import ConfigModel
 from datahub.configuration.validate_field_rename import pydantic_renamed_field
@@ -41,7 +48,8 @@ class GitReference(ConfigModel):
         transform=lambda url: _GITHUB_URL_TEMPLATE,
     )
 
-    @validator("repo", pre=True)
+    @field_validator("repo", mode="before")
+    @classmethod
     def simplify_repo_url(cls, repo: str) -> str:
         if repo.startswith("github.com/") or repo.startswith("gitlab.com"):
             repo = f"https://{repo}"
@@ -53,21 +61,22 @@ class GitReference(ConfigModel):
 
         return repo
 
-    @validator("url_template", always=True)
-    def infer_url_template(cls, url_template: Optional[str], values: dict) -> str:
-        if url_template is not None:
-            return url_template
+    @model_validator(mode="after")
+    def infer_url_template(self) -> "GitReference":
+        if self.url_template is not None:
+            return self
 
-        repo: str = values["repo"]
-        if repo.startswith(_GITHUB_PREFIX):
-            return _GITHUB_URL_TEMPLATE
-        elif repo.startswith(_GITLAB_PREFIX):
-            return _GITLAB_URL_TEMPLATE
+        if self.repo.startswith(_GITHUB_PREFIX):
+            self.url_template = _GITHUB_URL_TEMPLATE
+        elif self.repo.startswith(_GITLAB_PREFIX):
+            self.url_template = _GITLAB_URL_TEMPLATE
         else:
             raise ValueError(
                 "Unable to infer URL template from repo. Please set url_template manually."
             )
 
+        return self
+
     def get_url_for_file_path(self, file_path: str) -> str:
         assert self.url_template
         if self.url_subdir:
@@ -98,35 +107,43 @@ class GitInfo(GitReference):
 
     _fix_deploy_key_newlines = pydantic_multiline_string("deploy_key")
 
-    @validator("deploy_key", pre=True, always=True)
+    @model_validator(mode="before")
+    @classmethod
     def deploy_key_filled_from_deploy_key_file(
-        cls, v: Optional[SecretStr], values: Dict[str, Any]
-    ) -> Optional[SecretStr]:
-        if v is None:
+        cls, values: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        # In-place update of the input dict would cause state contamination.
+        # So a deepcopy is performed first.
+        values = deepcopy(values)
+
+        if values.get("deploy_key") is None:
             deploy_key_file = values.get("deploy_key_file")
             if deploy_key_file is not None:
                 with open(deploy_key_file) as fp:
                     deploy_key = SecretStr(fp.read())
-                    return deploy_key
-        return v
-
-    @validator("repo_ssh_locator", always=True)
-    def infer_repo_ssh_locator(
-        cls, repo_ssh_locator: Optional[str], values: dict
-    ) -> str:
-        if repo_ssh_locator is not None:
-            return repo_ssh_locator
-
-        repo: str = values["repo"]
-        if repo.startswith(_GITHUB_PREFIX):
-            return f"git@github.com:{repo[len(_GITHUB_PREFIX) :]}.git"
-        elif repo.startswith(_GITLAB_PREFIX):
-            return f"git@gitlab.com:{repo[len(_GITLAB_PREFIX) :]}.git"
+                    values["deploy_key"] = deploy_key
+        return values
+
+    @model_validator(mode="after")
+    def infer_repo_ssh_locator(self) -> "GitInfo":
+        if self.repo_ssh_locator is not None:
+            return self
+
+        if self.repo.startswith(_GITHUB_PREFIX):
+            self.repo_ssh_locator = (
+                f"git@github.com:{self.repo[len(_GITHUB_PREFIX) :]}.git"
+            )
+        elif self.repo.startswith(_GITLAB_PREFIX):
+            self.repo_ssh_locator = (
+                f"git@gitlab.com:{self.repo[len(_GITLAB_PREFIX) :]}.git"
+            )
         else:
             raise ValueError(
                 "Unable to infer repo_ssh_locator from repo. Please set repo_ssh_locator manually."
             )
 
+        return self
+
     @property
     def branch_for_clone(self) -> Optional[str]:
         # If branch was manually set, we should use it. Otherwise return None.

datahub/configuration/import_resolver.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Type, TypeVar, Union
 
-import pydantic
+from pydantic import field_validator
 
 from datahub.ingestion.api.registry import import_path
 
@@ -15,4 +15,4 @@ def _pydantic_resolver(cls: Type, v: Union[str, _T]) -> _T:
 
 
 def pydantic_resolve_key(field: str) -> "V1Validator":
-    return pydantic.validator(field, pre=True, allow_reuse=True)(_pydantic_resolver)
+    return field_validator(field, mode="before")(_pydantic_resolver)

datahub/configuration/kafka.py

@@ -1,4 +1,4 @@
-from pydantic import Field, validator
+from pydantic import Field, field_validator
 
 from datahub.configuration.common import ConfigModel, ConfigurationError
 from datahub.configuration.env_vars import (
@@ -42,7 +42,8 @@ class _KafkaConnectionConfig(ConfigModel):
         description="The request timeout used when interacting with the Kafka APIs.",
     )
 
-    @validator("bootstrap")
+    @field_validator("bootstrap", mode="after")
+    @classmethod
     def bootstrap_host_colon_port_comma(cls, val: str) -> str:
         for entry in val.split(","):
             validate_host_port(entry)
@@ -57,7 +58,7 @@ class KafkaConsumerConnectionConfig(_KafkaConnectionConfig):
         description="Extra consumer config serialized as JSON. These options will be passed into Kafka's DeserializingConsumer. See https://docs.confluent.io/platform/current/clients/confluent-kafka-python/html/index.html#deserializingconsumer and https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md .",
     )
 
-    @validator("consumer_config")
+    @field_validator("consumer_config", mode="after")
     @classmethod
     def resolve_callback(cls, value: dict) -> dict:
         if CallableConsumerConfig.is_callable_config(value):

datahub/configuration/time_window_config.py

@@ -1,10 +1,9 @@
 import enum
 from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List
+from typing import Any, List
 
 import humanfriendly
-import pydantic
-from pydantic.fields import Field
+from pydantic import Field, ValidationInfo, field_validator, model_validator
 
 from datahub.configuration.common import ConfigModel
 from datahub.configuration.datetimes import parse_absolute_time, parse_relative_timespan
@@ -52,45 +51,46 @@ class BaseTimeWindowConfig(ConfigModel):
         description="Earliest date of lineage/usage to consider. Default: Last full day in UTC (or hour, depending on `bucket_duration`). You can also specify relative time with respect to end_time such as '-7 days' Or '-7d'.",
     )  # type: ignore
 
-    @pydantic.validator("start_time", pre=True, always=True)
-    def default_start_time(
-        cls, v: Any, values: Dict[str, Any], **kwargs: Any
-    ) -> datetime:
-        if v is None:
-            return get_time_bucket(
-                values["end_time"]
-                - get_bucket_duration_delta(values["bucket_duration"]),
-                values["bucket_duration"],
-            )
-        elif isinstance(v, str):
+    @field_validator("start_time", mode="before")
+    @classmethod
+    def parse_start_time(cls, v: Any, info: ValidationInfo) -> Any:
+        if isinstance(v, str):
             # This is where start_time str is resolved to datetime
             try:
                 delta = parse_relative_timespan(v)
                 assert delta < timedelta(0), (
                     "Relative start time should start with minus sign (-) e.g. '-2 days'."
                 )
-                assert abs(delta) >= get_bucket_duration_delta(
-                    values["bucket_duration"]
-                ), (
+                bucket_duration = info.data.get("bucket_duration", BucketDuration.DAY)
+                assert abs(delta) >= get_bucket_duration_delta(bucket_duration), (
                     "Relative start time should be in terms of configured bucket duration. e.g '-2 days' or '-2 hours'."
                 )
 
-                # The end_time's default value is not yet populated, in which case
-                # we can just manually generate it here.
-                if "end_time" not in values:
-                    values["end_time"] = datetime.now(tz=timezone.utc)
+                # We need end_time, but it might not be set yet
+                # In that case, we'll use the default
+                end_time = info.data.get("end_time")
+                if end_time is None:
+                    end_time = datetime.now(tz=timezone.utc)
 
-                return get_time_bucket(
-                    values["end_time"] + delta, values["bucket_duration"]
-                )
+                return get_time_bucket(end_time + delta, bucket_duration)
             except humanfriendly.InvalidTimespan:
                 # We do not floor start_time to the bucket start time if absolute start time is specified.
                 # If user has specified absolute start time in recipe, it's most likely that he means it.
                 return parse_absolute_time(v)
-
         return v
 
-    @pydantic.validator("start_time", "end_time")
+    @model_validator(mode="after")
+    def default_start_time(self) -> "BaseTimeWindowConfig":
+        # Only calculate start_time if it was None (not provided by user)
+        if self.start_time is None:
+            self.start_time = get_time_bucket(
+                self.end_time - get_bucket_duration_delta(self.bucket_duration),
+                self.bucket_duration,
+            )
+        return self
+
+    @field_validator("start_time", "end_time", mode="after")
+    @classmethod
     def ensure_timestamps_in_utc(cls, v: datetime) -> datetime:
         if v.tzinfo is None:
             raise ValueError(

datahub/configuration/validate_field_deprecation.py

@@ -1,7 +1,7 @@
 import warnings
 from typing import TYPE_CHECKING, Any, Optional, Type
 
-import pydantic
+from pydantic import model_validator
 
 from datahub.configuration.common import ConfigurationWarning
 from datahub.utilities.global_warning_util import add_global_warning
@@ -34,4 +34,4 @@ def pydantic_field_deprecated(
     # https://github.com/pydantic/pydantic/blob/v1.10.9/pydantic/main.py#L264
     # This hack ensures that multiple field deprecated do not overwrite each other.
     _validate_deprecated.__name__ = f"{_validate_deprecated.__name__}_{field}"
-    return pydantic.root_validator(pre=True, allow_reuse=True)(_validate_deprecated)
+    return model_validator(mode="before")(_validate_deprecated)

datahub/configuration/validate_field_removal.py

@@ -1,7 +1,7 @@
 import warnings
 from typing import TYPE_CHECKING, Type
 
-import pydantic
+from pydantic import model_validator
 
 from datahub.configuration.common import ConfigurationWarning
 
@@ -31,4 +31,4 @@ def pydantic_removed_field(
     # https://github.com/pydantic/pydantic/blob/v1.10.9/pydantic/main.py#L264
     # This hack ensures that multiple field removals do not overwrite each other.
     _validate_field_removal.__name__ = f"{_validate_field_removal.__name__}_{field}"
-    return pydantic.root_validator(pre=True, allow_reuse=True)(_validate_field_removal)
+    return model_validator(mode="before")(_validate_field_removal)

datahub/configuration/validate_field_rename.py

@@ -1,7 +1,7 @@
 import warnings
 from typing import TYPE_CHECKING, Callable, Type, TypeVar
 
-import pydantic
+from pydantic import model_validator
 
 from datahub.configuration.common import ConfigurationWarning
 from datahub.utilities.global_warning_util import add_global_warning
@@ -52,4 +52,4 @@ def pydantic_renamed_field(
     # validator with pre=True gets all the values that were passed in.
     # Given that a renamed field doesn't show up in the fields list, we can't use
     # the field-level validator, even with a different field name.
-    return pydantic.root_validator(pre=True, allow_reuse=True)(_validate_field_rename)
+    return model_validator(mode="before")(_validate_field_rename)

datahub/configuration/validate_multiline_string.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, Optional, Type, Union
 
 import pydantic
+from pydantic import field_validator
 
 if TYPE_CHECKING:
     from pydantic.deprecated.class_validators import V1Validator
@@ -31,4 +32,4 @@ def pydantic_multiline_string(field: str) -> "V1Validator":
     # https://github.com/pydantic/pydantic/blob/v1.10.9/pydantic/main.py#L264
     # This hack ensures that multiple field deprecated do not overwrite each other.
     _validate_field.__name__ = f"{_validate_field.__name__}_{field}"
-    return pydantic.validator(field, pre=True, allow_reuse=True)(_validate_field)
+    return field_validator(field, mode="before")(_validate_field)

datahub/emitter/kafka_emitter.py

@@ -6,6 +6,7 @@ from confluent_kafka import SerializingProducer
 from confluent_kafka.schema_registry import SchemaRegistryClient
 from confluent_kafka.schema_registry.avro import AvroSerializer
 from confluent_kafka.serialization import SerializationContext, StringSerializer
+from pydantic import field_validator
 
 from datahub.configuration.common import ConfigModel
 from datahub.configuration.kafka import KafkaProducerConnectionConfig
@@ -49,7 +50,8 @@ class KafkaEmitterConfig(ConfigModel):
         },
     )
 
-    @pydantic.validator("topic_routes")
+    @field_validator("topic_routes", mode="after")
+    @classmethod
     def validate_topic_routes(cls, v: Dict[str, str]) -> Dict[str, str]:
         assert MCE_KEY in v, f"topic_routes must contain a route for {MCE_KEY}"
         assert MCP_KEY in v, f"topic_routes must contain a route for {MCP_KEY}"

datahub/emitter/rest_emitter.py

@@ -145,8 +145,7 @@ class EmitMode(ConfigEnum):
     ASYNC_WAIT = auto()
 
 
-_DEFAULT_EMIT_MODE = pydantic.parse_obj_as(
-    EmitMode,
+_DEFAULT_EMIT_MODE = pydantic.TypeAdapter(EmitMode).validate_python(
     get_emit_mode() or EmitMode.SYNC_PRIMARY,
 )
 
@@ -156,8 +155,7 @@ class RestSinkEndpoint(ConfigEnum):
     OPENAPI = auto()
 
 
-DEFAULT_REST_EMITTER_ENDPOINT = pydantic.parse_obj_as(
-    RestSinkEndpoint,
+DEFAULT_REST_EMITTER_ENDPOINT = pydantic.TypeAdapter(RestSinkEndpoint).validate_python(
     get_rest_emitter_default_endpoint() or RestSinkEndpoint.RESTLI,
 )
 

datahub/ingestion/api/decorators.py

@@ -17,7 +17,7 @@ def config_class(config_cls: Type) -> Callable[[Type], Type]:
     """Adds a get_config_class method to the decorated class"""
 
     def default_create(cls: Type, config_dict: Dict, ctx: PipelineContext) -> Type:
-        config = config_cls.parse_obj(config_dict)
+        config = config_cls.model_validate(config_dict)
         return cls(config=config, ctx=ctx)
 
     def wrapper(cls: Type) -> Type:

datahub/ingestion/api/report.py

@@ -65,7 +65,7 @@ class Report(SupportsAsObj):
         if isinstance(some_val, SupportsAsObj):
             return some_val.as_obj()
         elif isinstance(some_val, pydantic.BaseModel):
-            return Report.to_pure_python_obj(some_val.dict())
+            return Report.to_pure_python_obj(some_val.model_dump())
         elif dataclasses.is_dataclass(some_val) and not isinstance(some_val, type):
             # The `is_dataclass` function returns `True` for both instances and classes.
             # We need an extra check to ensure an instance was passed in.

datahub/ingestion/api/sink.py

@@ -123,7 +123,7 @@ class Sink(Generic[SinkConfig, SinkReportType], Closeable, metaclass=ABCMeta):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "Self":
-        return cls(ctx, cls.get_config_class().parse_obj(config_dict))
+        return cls(ctx, cls.get_config_class().model_validate(config_dict))
 
     def handle_work_unit_start(self, workunit: WorkUnit) -> None:
         """Called at the start of each new workunit.

datahub/ingestion/api/source.py

@@ -480,7 +480,7 @@ class Extractor(Generic[WorkUnitType, ExtractorConfig], Closeable, metaclass=ABC
         config_class = self.get_config_class()
 
         self.ctx = ctx
-        self.config = config_class.parse_obj(config_dict)
+        self.config = config_class.model_validate(config_dict)
 
     @abstractmethod
     def get_records(self, workunit: WorkUnitType) -> Iterable[RecordEnvelope]:

datahub/ingestion/glossary/datahub_classifier.py

@@ -3,7 +3,7 @@ from typing import Any, Dict, List, Optional
 from datahub_classify.helper_classes import ColumnInfo
 from datahub_classify.infotype_predictor import predict_infotypes
 from datahub_classify.reference_input import input1 as default_config
-from pydantic import validator
+from pydantic import field_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import ConfigModel
@@ -90,7 +90,7 @@ class InfoTypeConfig(ConfigModel):
 
 
 DEFAULT_CLASSIFIER_CONFIG = {
-    k: InfoTypeConfig.parse_obj(v) for k, v in default_config.items()
+    k: InfoTypeConfig.model_validate(v) for k, v in default_config.items()
 }
 
 
@@ -114,8 +114,11 @@ class DataHubClassifierConfig(ConfigModel):
         description="Minimum number of non-null column values required to process `values` prediction factor.",
     )
 
-    @validator("info_types_config")
-    def input_config_selectively_overrides_default_config(cls, info_types_config):
+    @field_validator("info_types_config", mode="after")
+    @classmethod
+    def input_config_selectively_overrides_default_config(
+        cls, info_types_config: Dict[str, Any]
+    ) -> Dict[str, Any]:
         for infotype, infotype_config in DEFAULT_CLASSIFIER_CONFIG.items():
             if infotype not in info_types_config:
                 # if config for some info type is not provided by user, use default config for that info type.
@@ -125,7 +128,7 @@ class DataHubClassifierConfig(ConfigModel):
                 # use default config for that prediction factor.
                 for factor, weight in (
                     info_types_config[infotype]
-                    .Prediction_Factors_and_Weights.dict()
+                    .Prediction_Factors_and_Weights.model_dump()
                     .items()
                 ):
                     if (
@@ -146,7 +149,7 @@ class DataHubClassifierConfig(ConfigModel):
             for (
                 factor,
                 weight,
-            ) in custom_infotype_config.Prediction_Factors_and_Weights.dict().items():
+            ) in custom_infotype_config.Prediction_Factors_and_Weights.model_dump().items():
                 if weight > 0:
                     assert getattr(custom_infotype_config, factor) is not None, (
                         f"Missing Configuration for Prediction Factor {factor} for Custom Info Type {custom_infotype}"
@@ -173,7 +176,7 @@ class DataHubClassifier(Classifier):
     def create(cls, config_dict: Optional[Dict[str, Any]]) -> "DataHubClassifier":
         # This could be replaced by parsing to particular class, if required
         if config_dict is not None:
-            config = DataHubClassifierConfig.parse_obj(config_dict)
+            config = DataHubClassifierConfig.model_validate(config_dict)
         else:
             config = DataHubClassifierConfig()
         return cls(config)
@@ -183,7 +186,7 @@ class DataHubClassifier(Classifier):
             column_infos=columns,
             confidence_level_threshold=self.config.confidence_level_threshold,
             global_config={
-                k: v.dict() for k, v in self.config.info_types_config.items()
+                k: v.model_dump() for k, v in self.config.info_types_config.items()
             },
             infotypes=self.config.info_types,
             minimum_values_threshold=self.config.minimum_values_threshold,

datahub/ingestion/graph/client.py

@@ -102,6 +102,7 @@ if TYPE_CHECKING:
     from datahub.sql_parsing.schema_resolver import (
         GraphQLSchemaMetadata,
         SchemaResolver,
+        SchemaResolverReport,
     )
     from datahub.sql_parsing.sqlglot_lineage import SqlParsingResult
 
@@ -1543,6 +1544,7 @@ class DataHubGraph(DatahubRestEmitter, EntityVersioningAPI):
         platform_instance: Optional[str],
         env: str,
         include_graph: bool = True,
+        report: Optional["SchemaResolverReport"] = None,
     ) -> "SchemaResolver":
         from datahub.sql_parsing.schema_resolver import SchemaResolver
 
@@ -1551,6 +1553,7 @@ class DataHubGraph(DatahubRestEmitter, EntityVersioningAPI):
             platform_instance=platform_instance,
             env=env,
             graph=self if include_graph else None,
+            report=report,
         )
 
     def initialize_schema_resolver_from_datahub(
@@ -1559,10 +1562,11 @@ class DataHubGraph(DatahubRestEmitter, EntityVersioningAPI):
         platform_instance: Optional[str],
         env: str,
         batch_size: int = 100,
+        report: Optional["SchemaResolverReport"] = None,
     ) -> "SchemaResolver":
         logger.info("Initializing schema resolver")
         schema_resolver = self._make_schema_resolver(
-            platform, platform_instance, env, include_graph=False
+            platform, platform_instance, env, include_graph=False, report=report
         )
 
         logger.info(f"Fetching schemas for platform {platform}, env {env}")

datahub/ingestion/reporting/datahub_ingestion_run_summary_provider.py

@@ -82,7 +82,7 @@ class DatahubIngestionRunSummaryProvider(PipelineRunListener):
         ctx: PipelineContext,
         sink: Sink,
     ) -> PipelineRunListener:
-        reporter_config = DatahubIngestionRunSummaryProviderConfig.parse_obj(
+        reporter_config = DatahubIngestionRunSummaryProviderConfig.model_validate(
             config_dict or {}
         )
         if reporter_config.sink: