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

datahub/ingestion/run/pipeline.py

@@ -215,7 +215,7 @@ class Pipeline:
                     sink_class = sink_registry.get(self.sink_type)
 
                 with _add_init_error_context(f"configure the sink ({self.sink_type})"):
-                    sink_config = self.config.sink.dict().get("config") or {}
+                    sink_config = self.config.sink.model_dump().get("config") or {}
                     self.sink = exit_stack.enter_context(
                         sink_class.create(sink_config, self.ctx)
                     )
@@ -245,7 +245,7 @@ class Pipeline:
                 ):
                     self.source = inner_exit_stack.enter_context(
                         source_class.create(
-                            self.config.source.dict().get("config", {}), self.ctx
+                            self.config.source.model_dump().get("config", {}), self.ctx
                         )
                     )
                     logger.debug(
@@ -288,7 +288,7 @@ class Pipeline:
             for transformer in self.config.transformers:
                 transformer_type = transformer.type
                 transformer_class = transform_registry.get(transformer_type)
-                transformer_config = transformer.dict().get("config", {})
+                transformer_config = transformer.model_dump().get("config", {})
                 self.transformers.append(
                     transformer_class.create(transformer_config, self.ctx)
                 )
@@ -310,12 +310,12 @@ class Pipeline:
                 reporter.type for reporter in self.config.reporting
             ]:
                 self.config.reporting.append(
-                    ReporterConfig.parse_obj({"type": "datahub"})
+                    ReporterConfig.model_validate({"type": "datahub"})
                 )
         elif report_to:
             # we assume this is a file name, and add the file reporter
             self.config.reporting.append(
-                ReporterConfig.parse_obj(
+                ReporterConfig.model_validate(
                     {"type": "file", "config": {"filename": report_to}}
                 )
             )
@@ -323,7 +323,7 @@ class Pipeline:
         for reporter in self.config.reporting:
             reporter_type = reporter.type
             reporter_class = reporting_provider_registry.get(reporter_type)
-            reporter_config_dict = reporter.dict().get("config", {})
+            reporter_config_dict = reporter.model_dump().get("config", {})
             try:
                 self.reporters.append(
                     reporter_class.create(

datahub/ingestion/run/pipeline_config.py

@@ -2,9 +2,9 @@ import datetime
 import logging
 import random
 import string
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
-from pydantic import Field, validator
+from pydantic import Field, model_validator
 
 from datahub.configuration.common import ConfigModel, DynamicTypedConfig, HiddenFromDocs
 from datahub.ingestion.graph.config import DatahubClientConfig
@@ -96,30 +96,28 @@ class PipelineConfig(ConfigModel):
         None  # the raw dict that was parsed to construct this config
     )
 
-    @validator("run_id", pre=True, always=True)
-    def run_id_should_be_semantic(
-        cls, v: Optional[str], values: Dict[str, Any], **kwargs: Any
-    ) -> str:
-        if v == DEFAULT_RUN_ID:
+    @model_validator(mode="after")
+    def run_id_should_be_semantic(self) -> "PipelineConfig":
+        if self.run_id == DEFAULT_RUN_ID:
             source_type = None
-            if "source" in values and hasattr(values["source"], "type"):
-                source_type = values["source"].type
+            if hasattr(self.source, "type"):
+                source_type = self.source.type
 
-            return _generate_run_id(source_type)
+            self.run_id = _generate_run_id(source_type)
         else:
-            assert v is not None
-            return v
+            assert self.run_id is not None
+        return self
 
     @classmethod
     def from_dict(
         cls, resolved_dict: dict, raw_dict: Optional[dict] = None
     ) -> "PipelineConfig":
-        config = cls.parse_obj(resolved_dict)
+        config = cls.model_validate(resolved_dict)
         config._raw_dict = raw_dict
         return config
 
     def get_raw_dict(self) -> Dict:
         result = self._raw_dict
         if result is None:
-            result = self.dict()
+            result = self.model_dump()
         return result

datahub/ingestion/run/sink_callback.py

@@ -39,7 +39,7 @@ class LoggingCallback(WriteCallback):
 class DeadLetterQueueCallback(WriteCallback, Closeable):
     def __init__(self, ctx: PipelineContext, config: Optional[FileSinkConfig]) -> None:
         if not config:
-            config = FileSinkConfig.parse_obj({"filename": "failed_events.json"})
+            config = FileSinkConfig.model_validate({"filename": "failed_events.json"})
         self.file_sink: FileSink = FileSink(ctx, config)
         self.file_sink_lock = threading.Lock()
         self.logging_callback = LoggingCallback(name="failure-queue")

datahub/ingestion/sink/datahub_rest.py

@@ -9,6 +9,7 @@ from enum import auto
 from typing import List, Optional, Tuple, Union
 
 import pydantic
+from pydantic import field_validator
 
 from datahub.configuration.common import (
     ConfigEnum,
@@ -63,8 +64,8 @@ class RestSinkMode(ConfigEnum):
     ASYNC_BATCH = auto()
 
 
-_DEFAULT_REST_SINK_MODE = pydantic.parse_obj_as(
-    RestSinkMode, get_rest_sink_default_mode() or RestSinkMode.ASYNC_BATCH
+_DEFAULT_REST_SINK_MODE = pydantic.TypeAdapter(RestSinkMode).validate_python(
+    get_rest_sink_default_mode() or RestSinkMode.ASYNC_BATCH
 )
 
 
@@ -80,8 +81,9 @@ class DatahubRestSinkConfig(DatahubClientConfig):
     # Only applies in async batch mode.
     max_per_batch: pydantic.PositiveInt = 100
 
-    @pydantic.validator("max_per_batch", always=True)
-    def validate_max_per_batch(cls, v):
+    @field_validator("max_per_batch", mode="before")
+    @classmethod
+    def validate_max_per_batch(cls, v: int) -> int:
         if v > BATCH_INGEST_MAX_PAYLOAD_LENGTH:
             raise ValueError(
                 f"max_per_batch must be less than or equal to {BATCH_INGEST_MAX_PAYLOAD_LENGTH}"

datahub/ingestion/source/abs/config.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Any, Dict, List, Optional, Union
 
-import pydantic
+from pydantic import ValidationInfo, field_validator, model_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import AllowDenyPattern
@@ -105,9 +105,10 @@ class DataLakeSourceConfig(
             self.profiling.operation_config
         )
 
-    @pydantic.validator("path_specs", always=True)
+    @field_validator("path_specs", mode="before")
+    @classmethod
     def check_path_specs_and_infer_platform(
-        cls, path_specs: List[PathSpec], values: Dict
+        cls, path_specs: List[PathSpec], info: ValidationInfo
     ) -> List[PathSpec]:
         if len(path_specs) == 0:
             raise ValueError("path_specs must not be empty")
@@ -124,38 +125,37 @@ class DataLakeSourceConfig(
 
         # Ensure abs configs aren't used for file sources.
         if guessed_platform != "abs" and (
-            values.get("use_abs_container_properties")
-            or values.get("use_abs_blob_tags")
-            or values.get("use_abs_blob_properties")
+            info.data.get("use_abs_container_properties")
+            or info.data.get("use_abs_blob_tags")
+            or info.data.get("use_abs_blob_properties")
         ):
             raise ValueError(
                 "Cannot grab abs blob/container tags when platform is not abs. Remove the flag or use abs."
             )
 
         # Infer platform if not specified.
-        if values.get("platform") and values["platform"] != guessed_platform:
+        if info.data.get("platform") and info.data["platform"] != guessed_platform:
             raise ValueError(
-                f"All path_specs belong to {guessed_platform} platform, but platform is set to {values['platform']}"
+                f"All path_specs belong to {guessed_platform} platform, but platform is set to {info.data['platform']}"
             )
         else:
             logger.debug(f'Setting config "platform": {guessed_platform}')
-            values["platform"] = guessed_platform
+            info.data["platform"] = guessed_platform
 
         return path_specs
 
-    @pydantic.validator("platform", always=True)
-    def platform_not_empty(cls, platform: Any, values: dict) -> str:
-        inferred_platform = values.get("platform")  # we may have inferred it above
+    @field_validator("platform", mode="before")
+    @classmethod
+    def platform_not_empty(cls, platform: Any, info: ValidationInfo) -> str:
+        inferred_platform = info.data.get("platform")  # we may have inferred it above
         platform = platform or inferred_platform
         if not platform:
             raise ValueError("platform must not be empty")
         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

datahub/ingestion/source/abs/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/abs/source.py

@@ -149,7 +149,7 @@ class ABSSource(StatefulIngestionSourceBase):
         self.report = DataLakeSourceReport()
         self.profiling_times_taken = []
         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 = {
@@ -164,7 +164,7 @@ class ABSSource(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/aws/aws_common.py

@@ -246,7 +246,7 @@ def assume_role(
         **dict(
             RoleSessionName="DatahubIngestionSource",
         ),
-        **{k: v for k, v in role.dict().items() if v is not None},
+        **{k: v for k, v in role.model_dump().items() if v is not None},
     }
 
     assumed_role_object = sts_client.assume_role(

datahub/ingestion/source/aws/glue.py

@@ -21,7 +21,7 @@ from urllib.parse import urlparse
 
 import botocore.exceptions
 import yaml
-from pydantic import validator
+from pydantic import field_validator
 from pydantic.fields import Field
 
 from datahub.api.entities.dataset.dataset import Dataset
@@ -221,7 +221,8 @@ class GlueSourceConfig(
     def lakeformation_client(self):
         return self.get_lakeformation_client()
 
-    @validator("glue_s3_lineage_direction")
+    @field_validator("glue_s3_lineage_direction", mode="after")
+    @classmethod
     def check_direction(cls, v: str) -> str:
         if v.lower() not in ["upstream", "downstream"]:
             raise ValueError(
@@ -229,7 +230,8 @@ class GlueSourceConfig(
             )
         return v.lower()
 
-    @validator("platform")
+    @field_validator("platform", mode="after")
+    @classmethod
     def platform_validator(cls, v: str) -> str:
         if not v or v in VALID_PLATFORMS:
             return v
@@ -473,7 +475,7 @@ class GlueSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = GlueSourceConfig.parse_obj(config_dict)
+        config = GlueSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @property

datahub/ingestion/source/aws/sagemaker.py

@@ -66,7 +66,7 @@ class SagemakerSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = SagemakerSourceConfig.parse_obj(config_dict)
+        config = SagemakerSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/azure/azure_common.py

@@ -1,9 +1,9 @@
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 from azure.identity import ClientSecretCredential
 from azure.storage.blob import BlobServiceClient
 from azure.storage.filedatalake import DataLakeServiceClient, FileSystemClient
-from pydantic import Field, root_validator
+from pydantic import Field, model_validator
 
 from datahub.configuration import ConfigModel
 from datahub.configuration.common import ConfigurationError
@@ -81,18 +81,14 @@ class AzureConnectionConfig(ConfigModel):
             )
         return self.sas_token if self.sas_token is not None else self.account_key
 
-    @root_validator(skip_on_failure=True)
-    def _check_credential_values(cls, values: Dict) -> Dict:
+    @model_validator(mode="after")
+    def _check_credential_values(self) -> "AzureConnectionConfig":
         if (
-            values.get("account_key")
-            or values.get("sas_token")
-            or (
-                values.get("client_id")
-                and values.get("client_secret")
-                and values.get("tenant_id")
-            )
+            self.account_key
+            or self.sas_token
+            or (self.client_id and self.client_secret and self.tenant_id)
         ):
-            return values
+            return self
         raise ConfigurationError(
             "credentials missing, requires one combination of account_key or sas_token or (client_id and client_secret and tenant_id)"
         )

datahub/ingestion/source/bigquery_v2/bigquery.py

@@ -211,7 +211,7 @@ class BigqueryV2Source(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "BigqueryV2Source":
-        config = BigQueryV2Config.parse_obj(config_dict)
+        config = BigQueryV2Config.model_validate(config_dict)
         return cls(ctx, config)
 
     @staticmethod

datahub/ingestion/source/bigquery_v2/bigquery_config.py

@@ -2,9 +2,16 @@ import logging
 import re
 from copy import deepcopy
 from datetime import timedelta
-from typing import Dict, List, Optional, Union
-
-from pydantic import Field, PositiveInt, PrivateAttr, root_validator, validator
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import (
+    Field,
+    PositiveInt,
+    PrivateAttr,
+    ValidationInfo,
+    field_validator,
+    model_validator,
+)
 
 from datahub.configuration.common import AllowDenyPattern, ConfigModel, HiddenFromDocs
 from datahub.configuration.env_vars import get_bigquery_schema_parallelism
@@ -63,8 +70,9 @@ class BigQueryBaseConfig(ConfigModel):
         description="The regex pattern to match sharded tables and group as one table. This is a very low level config parameter, only change if you know what you are doing, ",
     )
 
-    @validator("sharded_table_pattern")
-    def sharded_table_pattern_is_a_valid_regexp(cls, v):
+    @field_validator("sharded_table_pattern", mode="after")
+    @classmethod
+    def sharded_table_pattern_is_a_valid_regexp(cls, v: str) -> str:
         try:
             re.compile(v)
         except Exception as e:
@@ -73,7 +81,8 @@ class BigQueryBaseConfig(ConfigModel):
             ) from e
         return v
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def project_id_backward_compatibility_configs_set(cls, values: Dict) -> Dict:
         # Create a copy to avoid modifying the input dictionary, preventing state contamination in tests
         values = deepcopy(values)
@@ -188,12 +197,11 @@ class BigQueryFilterConfig(SQLFilterConfig):
         default=AllowDenyPattern.allow_all(),
     )
 
-    @root_validator(pre=False, skip_on_failure=True)
-    def backward_compatibility_configs_set(cls, values: Dict) -> Dict:
-        # Create a copy to avoid modifying the input dictionary, preventing state contamination in tests
-        values = deepcopy(values)
-        dataset_pattern: Optional[AllowDenyPattern] = values.get("dataset_pattern")
-        schema_pattern = values.get("schema_pattern")
+    @model_validator(mode="after")
+    def backward_compatibility_configs_set(self) -> Any:
+        dataset_pattern = self.dataset_pattern
+        schema_pattern = self.schema_pattern
+
         if (
             dataset_pattern == AllowDenyPattern.allow_all()
             and schema_pattern != AllowDenyPattern.allow_all()
@@ -202,7 +210,7 @@ class BigQueryFilterConfig(SQLFilterConfig):
                 "dataset_pattern is not set but schema_pattern is set, using schema_pattern as dataset_pattern. "
                 "schema_pattern will be deprecated, please use dataset_pattern instead."
             )
-            values["dataset_pattern"] = schema_pattern
+            self.dataset_pattern = schema_pattern
             dataset_pattern = schema_pattern
         elif (
             dataset_pattern != AllowDenyPattern.allow_all()
@@ -213,7 +221,7 @@ class BigQueryFilterConfig(SQLFilterConfig):
                 " please use dataset_pattern only."
             )
 
-        match_fully_qualified_names = values.get("match_fully_qualified_names")
+        match_fully_qualified_names = self.match_fully_qualified_names
 
         if (
             dataset_pattern is not None
@@ -243,7 +251,7 @@ class BigQueryFilterConfig(SQLFilterConfig):
                     " of the form `<project_id>.<dataset_name>`."
                 )
 
-        return values
+        return self
 
 
 class BigQueryIdentifierConfig(
@@ -478,7 +486,8 @@ class BigQueryV2Config(
     _include_view_column_lineage = pydantic_removed_field("include_view_column_lineage")
     _lineage_parse_view_ddl = pydantic_removed_field("lineage_parse_view_ddl")
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def set_include_schema_metadata(cls, values: Dict) -> Dict:
         # Create a copy to avoid modifying the input dictionary, preventing state contamination in tests
         values = deepcopy(values)
@@ -498,30 +507,33 @@ class BigQueryV2Config(
 
         return values
 
-    @root_validator(skip_on_failure=True)
+    @model_validator(mode="before")
+    @classmethod
     def profile_default_settings(cls, values: Dict) -> Dict:
         # Create a copy to avoid modifying the input dictionary, preventing state contamination in tests
         values = deepcopy(values)
         # Extra default SQLAlchemy option for better connection pooling and threading.
         # https://docs.sqlalchemy.org/en/14/core/pooling.html#sqlalchemy.pool.QueuePool.params.max_overflow
-        values["options"].setdefault("max_overflow", -1)
+        values.setdefault("options", {}).setdefault("max_overflow", -1)
 
         return values
 
-    @validator("bigquery_audit_metadata_datasets")
+    @field_validator("bigquery_audit_metadata_datasets", mode="after")
+    @classmethod
     def validate_bigquery_audit_metadata_datasets(
-        cls, v: Optional[List[str]], values: Dict
+        cls, v: Optional[List[str]], info: ValidationInfo
     ) -> Optional[List[str]]:
-        if values.get("use_exported_bigquery_audit_metadata"):
+        if info.data.get("use_exported_bigquery_audit_metadata"):
             assert v and len(v) > 0, (
                 "`bigquery_audit_metadata_datasets` should be set if using `use_exported_bigquery_audit_metadata: True`."
             )
 
         return v
 
-    @validator("upstream_lineage_in_report")
-    def validate_upstream_lineage_in_report(cls, v: bool, values: Dict) -> bool:
-        if v and values.get("use_queries_v2", True):
+    @field_validator("upstream_lineage_in_report", mode="after")
+    @classmethod
+    def validate_upstream_lineage_in_report(cls, v: bool, info: ValidationInfo) -> bool:
+        if v and info.data.get("use_queries_v2", True):
             logging.warning(
                 "`upstream_lineage_in_report` is enabled but will be ignored because `use_queries_v2` is enabled."
                 "This debugging feature only works with the legacy lineage approach (`use_queries_v2: false`)."
@@ -529,11 +541,12 @@ class BigQueryV2Config(
 
         return v
 
-    @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) -> "BigQueryV2Config":
+        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 "
@@ -541,7 +554,7 @@ class BigQueryV2Config(
                     "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 get_table_pattern(self, pattern: List[str]) -> str:
         return "|".join(pattern) if pattern else ""

datahub/ingestion/source/bigquery_v2/bigquery_queries.py

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

datahub/ingestion/source/cassandra/cassandra.py

@@ -109,7 +109,7 @@ class CassandraSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = CassandraSourceConfig.parse_obj(config_dict)
+        config = CassandraSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_platform(self) -> str:

datahub/ingestion/source/common/gcp_credentials_config.py

@@ -1,8 +1,8 @@
 import json
 import tempfile
-from typing import Any, Dict, Optional
+from typing import Dict, Optional
 
-from pydantic import Field, root_validator
+from pydantic import Field, model_validator
 
 from datahub.configuration import ConfigModel
 from datahub.configuration.validate_multiline_string import pydantic_multiline_string
@@ -37,16 +37,16 @@ class GCPCredential(ConfigModel):
 
     _fix_private_key_newlines = pydantic_multiline_string("private_key")
 
-    @root_validator(skip_on_failure=True)
-    def validate_config(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if values.get("client_x509_cert_url") is None:
-            values["client_x509_cert_url"] = (
-                f"https://www.googleapis.com/robot/v1/metadata/x509/{values['client_email']}"
+    @model_validator(mode="after")
+    def validate_config(self) -> "GCPCredential":
+        if self.client_x509_cert_url is None:
+            self.client_x509_cert_url = (
+                f"https://www.googleapis.com/robot/v1/metadata/x509/{self.client_email}"
             )
-        return values
+        return self
 
     def create_credential_temp_file(self, project_id: Optional[str] = None) -> str:
-        configs = self.dict()
+        configs = self.model_dump()
         if project_id:
             configs["project_id"] = project_id
         with tempfile.NamedTemporaryFile(delete=False) as fp:
@@ -55,7 +55,7 @@ class GCPCredential(ConfigModel):
             return fp.name
 
     def to_dict(self, project_id: Optional[str] = None) -> Dict[str, str]:
-        configs = self.dict()
+        configs = self.model_dump()
         if project_id:
             configs["project_id"] = project_id
         return configs