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

datahub/_version.py

@@ -1,6 +1,6 @@
 # Published at https://pypi.org/project/acryl-datahub/.
 __package_name__ = "acryl-datahub"
-__version__ = "1.3.1"
+__version__ = "1.3.1.1"
 
 
 def is_dev_mode() -> bool:

datahub/api/entities/common/serialized_value.py

@@ -104,7 +104,7 @@ class SerializedResourceValue(BaseModel):
             assert self.schema_ref
             assert self.schema_ref == model_type.__name__
         object_dict = self.as_raw_json()
-        return model_type.parse_obj(object_dict)
+        return model_type.model_validate(object_dict)
 
     @classmethod
     def from_resource_value(
@@ -131,7 +131,7 @@ class SerializedResourceValue(BaseModel):
         elif isinstance(object, BaseModel):
             return SerializedResourceValue(
                 content_type=models.SerializedValueContentTypeClass.JSON,
-                blob=json.dumps(object.dict(), sort_keys=True).encode("utf-8"),
+                blob=json.dumps(object.model_dump(), sort_keys=True).encode("utf-8"),
                 schema_type=models.SerializedValueSchemaTypeClass.JSON,
                 schema_ref=object.__class__.__name__,
             )

datahub/api/entities/corpgroup/corpgroup.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Callable, Iterable, List, Optional, Union
+from typing import Any, Callable, Iterable, List, Optional, Union
 
-import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
 
 import datahub.emitter.mce_builder as builder
 from datahub.api.entities.corpuser.corpuser import CorpUser, CorpUserGenerationConfig
@@ -70,9 +69,15 @@ class CorpGroup(BaseModel):
 
     _rename_admins_to_owners = pydantic_renamed_field("admins", "owners")
 
-    @pydantic.validator("owners", "members", each_item=True)
-    def make_urn_if_needed(cls, v):
-        if isinstance(v, str):
+    @field_validator("owners", "members", mode="before")
+    @classmethod
+    def make_urn_if_needed(cls, v: Any) -> Any:
+        if isinstance(v, list):
+            return [
+                builder.make_user_urn(item) if isinstance(item, str) else item
+                for item in v
+            ]
+        elif isinstance(v, str):
             return builder.make_user_urn(v)
         return v
 

datahub/api/entities/corpuser/corpuser.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Callable, Iterable, List, Optional
 
-import pydantic
+from pydantic import model_validator
 
 import datahub.emitter.mce_builder as builder
 from datahub.configuration.common import ConfigModel
@@ -65,16 +65,16 @@ class CorpUser(ConfigModel):
     picture_link: Optional[str] = None
     phone: Optional[str] = None
 
-    @pydantic.validator("full_name", always=True)
-    def full_name_can_be_built_from_first_name_last_name(v, values):
-        if not v:
-            if "first_name" in values or "last_name" in values:
-                first_name = values.get("first_name") or ""
-                last_name = values.get("last_name") or ""
-                full_name = f"{first_name} {last_name}" if last_name else first_name
-                return full_name
-        else:
-            return v
+    @model_validator(mode="after")
+    def full_name_can_be_built_from_first_name_last_name(self) -> "CorpUser":
+        if not self.full_name:
+            if self.first_name or self.last_name:
+                first_name = self.first_name or ""
+                last_name = self.last_name or ""
+                self.full_name = (
+                    f"{first_name} {last_name}" if last_name else first_name
+                )
+        return self
 
     @property
     def urn(self):

datahub/api/entities/dataproduct/dataproduct.py

@@ -4,7 +4,7 @@ import time
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
 
-import pydantic
+from pydantic import field_validator, model_validator
 from ruamel.yaml import YAML
 from typing_extensions import assert_never
 
@@ -71,7 +71,8 @@ class Ownership(ConfigModel):
     id: str
     type: str
 
-    @pydantic.validator("type")
+    @field_validator("type", mode="after")
+    @classmethod
     def ownership_type_must_be_mappable_or_custom(cls, v: str) -> str:
         _, _ = builder.validate_ownership_type(v)
         return v
@@ -116,30 +117,49 @@ class DataProduct(ConfigModel):
     output_ports: Optional[List[str]] = None
     _original_yaml_dict: Optional[dict] = None
 
-    @pydantic.validator("assets", each_item=True)
-    def assets_must_be_urns(cls, v: str) -> str:
-        try:
-            Urn.from_string(v)
-        except Exception as e:
-            raise ValueError(f"asset {v} is not an urn: {e}") from e
-
-        return v
-
-    @pydantic.validator("output_ports", each_item=True)
-    def output_ports_must_be_urns(cls, v: str) -> str:
-        try:
-            Urn.create_from_string(v)
-        except Exception as e:
-            raise ValueError(f"Output port {v} is not an urn: {e}") from e
+    @field_validator("assets", mode="before")
+    @classmethod
+    def assets_must_be_urns(cls, v: Any) -> Any:
+        if isinstance(v, list):
+            for item in v:
+                try:
+                    Urn.from_string(item)
+                except Exception as e:
+                    raise ValueError(f"asset {item} is not an urn: {e}") from e
+            return v
+        else:
+            try:
+                Urn.from_string(v)
+            except Exception as e:
+                raise ValueError(f"asset {v} is not an urn: {e}") from e
+            return v
 
+    @field_validator("output_ports", mode="before")
+    @classmethod
+    def output_ports_must_be_urns(cls, v: Any) -> Any:
+        if v is not None:
+            if isinstance(v, list):
+                for item in v:
+                    try:
+                        Urn.create_from_string(item)
+                    except Exception as e:
+                        raise ValueError(
+                            f"Output port {item} is not an urn: {e}"
+                        ) from e
+            else:
+                try:
+                    Urn.create_from_string(v)
+                except Exception as e:
+                    raise ValueError(f"Output port {v} is not an urn: {e}") from e
         return v
 
-    @pydantic.validator("output_ports", each_item=True)
-    def output_ports_must_be_from_asset_list(cls, v: str, values: dict) -> str:
-        assets = values.get("assets", [])
-        if v not in assets:
-            raise ValueError(f"Output port {v} is not in asset list")
-        return v
+    @model_validator(mode="after")
+    def output_ports_must_be_from_asset_list(self) -> "DataProduct":
+        if self.output_ports and self.assets:
+            for port in self.output_ports:
+                if port not in self.assets:
+                    raise ValueError(f"Output port {port} is not in asset list")
+        return self
 
     @property
     def urn(self) -> str:
@@ -454,7 +474,7 @@ class DataProduct(ConfigModel):
                     patches_add.append(new_owner)
                 else:
                     patches_add.append(
-                        Ownership(id=new_owner, type=new_owner_type).dict()
+                        Ownership(id=new_owner, type=new_owner_type).model_dump()
                     )
 
         mutation_needed = bool(patches_replace or patches_drop or patches_add)
@@ -485,8 +505,8 @@ class DataProduct(ConfigModel):
             raise Exception("Original Data Product was not loaded from yaml")
 
         orig_dictionary = original_dataproduct._original_yaml_dict
-        original_dataproduct_dict = original_dataproduct.dict()
-        this_dataproduct_dict = self.dict()
+        original_dataproduct_dict = original_dataproduct.model_dump()
+        this_dataproduct_dict = self.model_dump()
         for simple_field in ["display_name", "description", "external_url"]:
             if original_dataproduct_dict.get(simple_field) != this_dataproduct_dict.get(
                 simple_field
@@ -566,7 +586,7 @@ class DataProduct(ConfigModel):
             yaml = YAML(typ="rt")  # default, if not specfied, is 'rt' (round-trip)
             yaml.indent(mapping=2, sequence=4, offset=2)
             yaml.default_flow_style = False
-            yaml.dump(self.dict(), fp)
+            yaml.dump(self.model_dump(), fp)
 
     @staticmethod
     def get_patch_builder(

datahub/api/entities/dataset/dataset.py

@@ -3,6 +3,7 @@ import logging
 import time
 from pathlib import Path
 from typing import (
+    Any,
     Dict,
     Iterable,
     List,
@@ -19,8 +20,9 @@ from pydantic import (
     BaseModel,
     Field,
     StrictStr,
-    root_validator,
-    validator,
+    ValidationInfo,
+    field_validator,
+    model_validator,
 )
 from ruamel.yaml import YAML
 from typing_extensions import TypeAlias
@@ -213,14 +215,15 @@ class SchemaFieldSpecification(StrictModel):
             ),
         )
 
-    @validator("urn", pre=True, always=True)
-    def either_id_or_urn_must_be_filled_out(cls, v, values):
-        if not v and not values.get("id"):
+    @model_validator(mode="after")
+    def either_id_or_urn_must_be_filled_out(self) -> "SchemaFieldSpecification":
+        if not self.urn and not self.id:
             raise ValueError("Either id or urn must be present")
-        return v
+        return self
 
-    @root_validator(pre=True)
-    def sync_doc_into_description(cls, values: Dict) -> Dict:
+    @model_validator(mode="before")
+    @classmethod
+    def sync_doc_into_description(cls, values: Any) -> Any:
         """Synchronize doc into description field if doc is provided."""
         description = values.get("description")
         doc = values.pop("doc", None)
@@ -348,8 +351,9 @@ class SchemaSpecification(BaseModel):
     fields: Optional[List[SchemaFieldSpecification]] = None
     raw_schema: Optional[str] = None
 
-    @validator("file")
-    def file_must_be_avsc(cls, v):
+    @field_validator("file", mode="after")
+    @classmethod
+    def file_must_be_avsc(cls, v: Optional[str]) -> Optional[str]:
         if v and not v.endswith(".avsc"):
             raise ValueError("file must be a .avsc file")
         return v
@@ -359,7 +363,8 @@ class Ownership(ConfigModel):
     id: str
     type: str
 
-    @validator("type")
+    @field_validator("type", mode="after")
+    @classmethod
     def ownership_type_must_be_mappable_or_custom(cls, v: str) -> str:
         _, _ = validate_ownership_type(v)
         return v
@@ -397,30 +402,36 @@ class Dataset(StrictModel):
             dataset_urn = DatasetUrn.from_string(self.urn)
             return str(dataset_urn.get_data_platform_urn())
 
-    @validator("urn", pre=True, always=True)
-    def urn_must_be_present(cls, v, values):
+    @field_validator("urn", mode="before")
+    @classmethod
+    def urn_must_be_present(cls, v: Any, info: ValidationInfo) -> Any:
         if not v:
+            values = info.data
             assert "id" in values, "id must be present if urn is not"
             assert "platform" in values, "platform must be present if urn is not"
             assert "env" in values, "env must be present if urn is not"
             return make_dataset_urn(values["platform"], values["id"], values["env"])
         return v
 
-    @validator("name", pre=True, always=True)
-    def name_filled_with_id_if_not_present(cls, v, values):
+    @field_validator("name", mode="before")
+    @classmethod
+    def name_filled_with_id_if_not_present(cls, v: Any, info: ValidationInfo) -> Any:
         if not v:
+            values = info.data
             assert "id" in values, "id must be present if name is not"
             return values["id"]
         return v
 
-    @validator("platform")
-    def platform_must_not_be_urn(cls, v):
-        if v.startswith("urn:li:dataPlatform:"):
+    @field_validator("platform", mode="after")
+    @classmethod
+    def platform_must_not_be_urn(cls, v: Optional[str]) -> Optional[str]:
+        if v and v.startswith("urn:li:dataPlatform:"):
             return v[len("urn:li:dataPlatform:") :]
         return v
 
-    @validator("structured_properties")
-    def simplify_structured_properties(cls, v):
+    @field_validator("structured_properties", mode="after")
+    @classmethod
+    def simplify_structured_properties(cls, v: Any) -> Any:
         return StructuredPropertiesHelper.simplify_structured_properties_list(v)
 
     def _mint_auditstamp(self, message: str) -> AuditStampClass:
@@ -461,7 +472,7 @@ class Dataset(StrictModel):
             if isinstance(datasets, dict):
                 datasets = [datasets]
             for dataset_raw in datasets:
-                dataset = Dataset.parse_obj(dataset_raw)
+                dataset = Dataset.model_validate(dataset_raw)
                 # dataset = Dataset.model_validate(dataset_raw, strict=True)
                 yield dataset
 

datahub/api/entities/external/lake_formation_external_entites.py

@@ -12,7 +12,7 @@
 # https://learn.microsoft.com/en-us/azure/databricks/database-objects/tags#constraint
 from typing import Any, Dict, Optional
 
-from pydantic import validator
+from pydantic import field_validator
 from typing_extensions import ClassVar
 
 from datahub.api.entities.external.external_tag import ExternalTag
@@ -50,11 +50,10 @@ class LakeFormationTag(ExternalTag):
     value: Optional[LakeFormationTagValueText] = None
     catalog: Optional[str] = None
 
-    # Pydantic v1 validators
-    @validator("key", pre=True)
+    @field_validator("key", mode="before")
     @classmethod
     def _validate_key(cls, v: Any) -> LakeFormationTagKeyText:
-        """Validate and convert key field for Pydantic v1."""
+        """Validate and convert key field."""
         if isinstance(v, LakeFormationTagKeyText):
             return v
 
@@ -64,10 +63,10 @@ class LakeFormationTag(ExternalTag):
 
         return LakeFormationTagKeyText(raw_text=v)
 
-    @validator("value", pre=True)
+    @field_validator("value", mode="before")
     @classmethod
     def _validate_value(cls, v: Any) -> Optional[LakeFormationTagValueText]:
-        """Validate and convert value field for Pydantic v1."""
+        """Validate and convert value field."""
         if v is None:
             return None
 

datahub/api/entities/external/unity_catalog_external_entites.py

@@ -12,8 +12,7 @@
 # https://learn.microsoft.com/en-us/azure/databricks/database-objects/tags#constraint
 from typing import Any, Dict, Optional, Set
 
-# Import validator for Pydantic v1 (always needed since we removed conditional logic)
-from pydantic import validator
+from pydantic import field_validator
 from typing_extensions import ClassVar
 
 from datahub.api.entities.external.external_tag import ExternalTag
@@ -62,11 +61,10 @@ class UnityCatalogTag(ExternalTag):
     key: UnityCatalogTagKeyText
     value: Optional[UnityCatalogTagValueText] = None
 
-    # Pydantic v1 validators
-    @validator("key", pre=True)
+    @field_validator("key", mode="before")
     @classmethod
     def _validate_key(cls, v: Any) -> UnityCatalogTagKeyText:
-        """Validate and convert key field for Pydantic v1."""
+        """Validate and convert key field."""
         if isinstance(v, UnityCatalogTagKeyText):
             return v
 
@@ -76,10 +74,10 @@ class UnityCatalogTag(ExternalTag):
 
         return UnityCatalogTagKeyText(raw_text=v)
 
-    @validator("value", pre=True)
+    @field_validator("value", mode="before")
     @classmethod
     def _validate_value(cls, v: Any) -> Optional[UnityCatalogTagValueText]:
-        """Validate and convert value field for Pydantic v1."""
+        """Validate and convert value field."""
         if v is None:
             return None
 

datahub/api/entities/forms/forms.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from typing import List, Optional, Union
 
 import yaml
-from pydantic import Field, validator
+from pydantic import Field, model_validator
 from ruamel.yaml import YAML
 from typing_extensions import Literal
 
@@ -70,11 +70,13 @@ class Prompt(ConfigModel):
     structured_property_urn: Optional[str] = Field(default=None, validate_default=True)
     required: Optional[bool] = None
 
-    @validator("structured_property_urn", pre=True, always=True)
-    def structured_property_urn_must_be_present(cls, v, values):
-        if not v and values.get("structured_property_id"):
-            return Urn.make_structured_property_urn(values["structured_property_id"])
-        return v
+    @model_validator(mode="after")
+    def structured_property_urn_must_be_present(self) -> "Prompt":
+        if not self.structured_property_urn and self.structured_property_id:
+            self.structured_property_urn = Urn.make_structured_property_urn(
+                self.structured_property_id
+            )
+        return self
 
 
 class FormType(Enum):
@@ -122,13 +124,13 @@ class Forms(ConfigModel):
     group_owners: Optional[List[str]] = None  # can be group IDs or urns
     actors: Optional[Actors] = None
 
-    @validator("urn", pre=True, always=True)
-    def urn_must_be_present(cls, v, values):
-        if not v:
-            if values.get("id") is None:
+    @model_validator(mode="after")
+    def urn_must_be_present(self) -> "Forms":
+        if not self.urn:
+            if self.id is None:
                 raise ValueError("Form id must be present if urn is not")
-            return f"urn:li:form:{values['id']}"
-        return v
+            self.urn = f"urn:li:form:{self.id}"
+        return self
 
     @staticmethod
     def create(file: str) -> None:
@@ -137,7 +139,7 @@ class Forms(ConfigModel):
         with get_default_graph(ClientMode.CLI) as emitter, open(file) as fp:
             forms: List[dict] = yaml.safe_load(fp)
             for form_raw in forms:
-                form = Forms.parse_obj(form_raw)
+                form = Forms.model_validate(form_raw)
 
                 try:
                     if not FormType.has_value(form.type):
@@ -445,4 +447,4 @@ class Forms(ConfigModel):
             yaml = YAML(typ="rt")  # default, if not specfied, is 'rt' (round-trip)
             yaml.indent(mapping=2, sequence=4, offset=2)
             yaml.default_flow_style = False
-            yaml.dump(self.dict(), fp)
+            yaml.dump(self.model_dump(), fp)

datahub/api/entities/structuredproperties/structuredproperties.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Iterable, List, Optional, Type, Union
 
 import yaml
-from pydantic import Field, StrictStr, validator
+from pydantic import Field, StrictStr, field_validator, model_validator
 from ruamel.yaml import YAML
 
 from datahub.configuration.common import ConfigModel
@@ -61,9 +61,12 @@ def _validate_entity_type_urn(cls: Type, v: str) -> str:
 class TypeQualifierAllowedTypes(ConfigModel):
     allowed_types: List[str]
 
-    _check_allowed_types = validator("allowed_types", each_item=True, allow_reuse=True)(
-        _validate_entity_type_urn
-    )
+    @field_validator("allowed_types", mode="before")
+    @classmethod
+    def _check_allowed_types(cls, v: Union[str, List[str]]) -> Union[str, List[str]]:
+        if isinstance(v, list):
+            return [_validate_entity_type_urn(cls, item) for item in v]
+        return _validate_entity_type_urn(cls, v)
 
 
 class StructuredProperties(ConfigModel):
@@ -80,11 +83,15 @@ class StructuredProperties(ConfigModel):
     type_qualifier: Optional[TypeQualifierAllowedTypes] = None
     immutable: Optional[bool] = False
 
-    _check_entity_types = validator("entity_types", each_item=True, allow_reuse=True)(
-        _validate_entity_type_urn
-    )
+    @field_validator("entity_types", mode="before")
+    @classmethod
+    def _check_entity_types(cls, v: Union[str, List[str]]) -> Union[str, List[str]]:
+        if isinstance(v, list):
+            return [_validate_entity_type_urn(cls, item) for item in v]
+        return _validate_entity_type_urn(cls, v)
 
-    @validator("type")
+    @field_validator("type", mode="after")
+    @classmethod
     def validate_type(cls, v: str) -> str:
         # This logic is somewhat hacky, since we need to deal with
         # 1. fully qualified urns
@@ -123,13 +130,13 @@ class StructuredProperties(ConfigModel):
             )
         return id
 
-    @validator("urn", pre=True, always=True)
-    def urn_must_be_present(cls, v, values):
-        if not v:
-            if "id" not in values:
+    @model_validator(mode="after")
+    def urn_must_be_present(self) -> "StructuredProperties":
+        if not self.urn:
+            if not hasattr(self, "id") or not self.id:
                 raise ValueError("id must be present if urn is not")
-            return f"urn:li:structuredProperty:{values['id']}"
-        return v
+            self.urn = f"urn:li:structuredProperty:{self.id}"
+        return self
 
     @staticmethod
     def from_yaml(file: str) -> List["StructuredProperties"]:
@@ -138,7 +145,7 @@ class StructuredProperties(ConfigModel):
 
         result: List[StructuredProperties] = []
         for structuredproperty_raw in structuredproperties:
-            result.append(StructuredProperties.parse_obj(structuredproperty_raw))
+            result.append(StructuredProperties.model_validate(structuredproperty_raw))
         return result
 
     def generate_mcps(self) -> List[MetadataChangeProposalWrapper]:
@@ -225,7 +232,7 @@ class StructuredProperties(ConfigModel):
             yaml = YAML(typ="rt")  # default, if not specfied, is 'rt' (round-trip)
             yaml.indent(mapping=2, sequence=4, offset=2)
             yaml.default_flow_style = False
-            yaml.dump(self.dict(), fp)
+            yaml.dump(self.model_dump(), fp)
 
     @staticmethod
     def list_urns(graph: DataHubGraph) -> Iterable[str]:

datahub/cli/check_cli.py

@@ -316,7 +316,7 @@ def test_allow_deny(config: str, input: str, pattern_key: str) -> None:
             click.secho(f"{pattern_key} is not defined in the config", fg="red")
             exit(1)
 
-        allow_deny_pattern = AllowDenyPattern.parse_obj(pattern_dict)
+        allow_deny_pattern = AllowDenyPattern.model_validate(pattern_dict)
         if allow_deny_pattern.allowed(input):
             click.secho(f"✅ {input} is allowed by {pattern_key}", fg="green")
             exit(0)
@@ -372,7 +372,7 @@ def test_path_spec(config: str, input: str, path_spec_key: str) -> None:
             pattern_dicts = [pattern_dicts]
 
         for pattern_dict in pattern_dicts:
-            path_spec_pattern = PathSpec.parse_obj(pattern_dict)
+            path_spec_pattern = PathSpec.model_validate(pattern_dict)
             if path_spec_pattern.allowed(input):
                 click.echo(f"{input} is allowed by {path_spec_pattern}")
             else:

datahub/cli/config_utils.py

@@ -114,7 +114,7 @@ def load_client_config() -> DatahubClientConfig:
     try:
         _ensure_datahub_config()
         client_config_dict = get_raw_client_config()
-        datahub_config: DatahubClientConfig = DatahubConfig.parse_obj(
+        datahub_config: DatahubClientConfig = DatahubConfig.model_validate(
             client_config_dict
         ).gms
         return datahub_config
@@ -146,7 +146,7 @@ def write_gms_config(
             logger.debug(
                 f"Failed to retrieve config from file {DATAHUB_CONFIG_PATH}: {e}. This isn't fatal."
             )
-        config_dict = {**previous_config, **config.dict()}
+        config_dict = {**previous_config, **config.model_dump()}
     else:
-        config_dict = config.dict()
+        config_dict = config.model_dump()
     persist_raw_datahub_config(config_dict)

datahub/cli/lite_cli.py

@@ -40,13 +40,13 @@ class DuckDBLiteConfigWrapper(DuckDBLiteConfig):
 
 class LiteCliConfig(DatahubConfig):
     lite: LiteLocalConfig = LiteLocalConfig(
-        type="duckdb", config=DuckDBLiteConfigWrapper().dict()
+        type="duckdb", config=DuckDBLiteConfigWrapper().model_dump()
     )
 
 
 def get_lite_config() -> LiteLocalConfig:
     client_config_dict = get_raw_client_config()
-    lite_config = LiteCliConfig.parse_obj(client_config_dict)
+    lite_config = LiteCliConfig.model_validate(client_config_dict)
     return lite_config.lite
 
 
@@ -55,7 +55,9 @@ def _get_datahub_lite(read_only: bool = False) -> DataHubLiteLocal:
     if lite_config.type == "duckdb":
         lite_config.config["read_only"] = read_only
 
-    duckdb_lite = get_datahub_lite(config_dict=lite_config.dict(), read_only=read_only)
+    duckdb_lite = get_datahub_lite(
+        config_dict=lite_config.model_dump(), read_only=read_only
+    )
     return duckdb_lite
 
 
@@ -308,7 +310,7 @@ def search(
         ):
             result_str = searchable.id
             if details:
-                result_str = json.dumps(searchable.dict())
+                result_str = json.dumps(searchable.model_dump())
             # suppress id if we have already seen it in the non-detailed response
             if details or searchable.id not in result_ids:
                 click.secho(result_str)
@@ -321,7 +323,7 @@ def search(
 def write_lite_config(lite_config: LiteLocalConfig) -> None:
     cli_config = get_raw_client_config()
     assert isinstance(cli_config, dict)
-    cli_config["lite"] = lite_config.dict()
+    cli_config["lite"] = lite_config.model_dump()
     persist_raw_datahub_config(cli_config)
 
 
@@ -332,12 +334,12 @@ def write_lite_config(lite_config: LiteLocalConfig) -> None:
 @telemetry.with_telemetry()
 def init(ctx: click.Context, type: Optional[str], file: Optional[str]) -> None:
     lite_config = get_lite_config()
-    new_lite_config_dict = lite_config.dict()
+    new_lite_config_dict = lite_config.model_dump()
     # Update the type and config sections only
     new_lite_config_dict["type"] = type
     if file:
         new_lite_config_dict["config"]["file"] = file
-    new_lite_config = LiteLocalConfig.parse_obj(new_lite_config_dict)
+    new_lite_config = LiteLocalConfig.model_validate(new_lite_config_dict)
     if lite_config != new_lite_config:
         if click.confirm(
             f"Will replace datahub lite config {lite_config} with {new_lite_config}"