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

datahub/ingestion/source/dremio/dremio_source.py

@@ -55,7 +55,7 @@ from datahub.ingestion.source.state.stateful_ingestion_base import (
 from datahub.ingestion.source_report.ingestion_stage import (
     LINEAGE_EXTRACTION,
     METADATA_EXTRACTION,
-    IngestionHighStage,
+    PROFILING,
 )
 from datahub.metadata.com.linkedin.pegasus2avro.dataset import (
     DatasetLineageTypeClass,
@@ -201,7 +201,7 @@ class DremioSource(StatefulIngestionSourceBase):
         return "dremio"
 
     def _build_source_map(self) -> Dict[str, DremioSourceMapEntry]:
-        dremio_sources = self.dremio_catalog.get_sources()
+        dremio_sources = list(self.dremio_catalog.get_sources())
         source_mappings_config = self.config.source_mappings or []
 
         source_map = build_dremio_source_map(dremio_sources, source_mappings_config)
@@ -242,9 +242,7 @@ class DremioSource(StatefulIngestionSourceBase):
                     )
 
             # Process Datasets
-            datasets = self.dremio_catalog.get_datasets()
-
-            for dataset_info in datasets:
+            for dataset_info in self.dremio_catalog.get_datasets():
                 try:
                     yield from self.process_dataset(dataset_info)
                     logger.info(
@@ -258,10 +256,8 @@ class DremioSource(StatefulIngestionSourceBase):
                         exc=exc,
                     )
 
-            # Process Glossary Terms
-            glossary_terms = self.dremio_catalog.get_glossary_terms()
-
-            for glossary_term in glossary_terms:
+            # Process Glossary Terms using streaming
+            for glossary_term in self.dremio_catalog.get_glossary_terms():
                 try:
                     yield from self.process_glossary_term(glossary_term)
                 except Exception as exc:
@@ -283,14 +279,16 @@ class DremioSource(StatefulIngestionSourceBase):
             # Profiling
             if self.config.is_profiling_enabled():
                 with (
-                    self.report.new_high_stage(IngestionHighStage.PROFILING),
+                    self.report.new_stage(PROFILING),
                     ThreadPoolExecutor(
                         max_workers=self.config.profiling.max_workers
                     ) as executor,
                 ):
+                    # Collect datasets for profiling
+                    datasets_for_profiling = list(self.dremio_catalog.get_datasets())
                     future_to_dataset = {
                         executor.submit(self.generate_profiles, dataset): dataset
-                        for dataset in datasets
+                        for dataset in datasets_for_profiling
                     }
 
                     for future in as_completed(future_to_dataset):
@@ -338,10 +336,10 @@ class DremioSource(StatefulIngestionSourceBase):
             return
 
         dataset_urn = make_dataset_urn_with_platform_instance(
-            platform=self.get_platform(),
-            name=dataset_name,
-            platform_instance=self.config.platform_instance,
+            platform=make_data_platform_urn(self.get_platform()),
+            name=f"dremio.{dataset_name}",
             env=self.config.env,
+            platform_instance=self.config.platform_instance,
         )
 
         for dremio_mcp in self.dremio_aspects.populate_dataset_mcp(
@@ -421,10 +419,10 @@ class DremioSource(StatefulIngestionSourceBase):
         schema_str = ".".join(dataset_info.path)
         dataset_name = f"{schema_str}.{dataset_info.resource_name}".lower()
         dataset_urn = make_dataset_urn_with_platform_instance(
-            platform=self.get_platform(),
-            name=dataset_name,
-            platform_instance=self.config.platform_instance,
+            platform=make_data_platform_urn(self.get_platform()),
+            name=f"dremio.{dataset_name}",
             env=self.config.env,
+            platform_instance=self.config.platform_instance,
         )
         yield from self.profiler.get_workunits(dataset_info, dataset_urn)
 
@@ -436,10 +434,10 @@ class DremioSource(StatefulIngestionSourceBase):
         """
         upstream_urns = [
             make_dataset_urn_with_platform_instance(
-                platform=self.get_platform(),
-                name=upstream_table.lower(),
-                platform_instance=self.config.platform_instance,
+                platform=make_data_platform_urn(self.get_platform()),
+                name=f"dremio.{upstream_table.lower()}",
                 env=self.config.env,
+                platform_instance=self.config.platform_instance,
             )
             for upstream_table in parents
         ]
@@ -498,19 +496,19 @@ class DremioSource(StatefulIngestionSourceBase):
         if query.query and query.affected_dataset:
             upstream_urns = [
                 make_dataset_urn_with_platform_instance(
-                    platform=self.get_platform(),
-                    name=ds.lower(),
-                    platform_instance=self.config.platform_instance,
+                    platform=make_data_platform_urn(self.get_platform()),
+                    name=f"dremio.{ds.lower()}",
                     env=self.config.env,
+                    platform_instance=self.config.platform_instance,
                 )
                 for ds in query.queried_datasets
             ]
 
             downstream_urn = make_dataset_urn_with_platform_instance(
-                platform=self.get_platform(),
-                name=query.affected_dataset.lower(),
-                platform_instance=self.config.platform_instance,
+                platform=make_data_platform_urn(self.get_platform()),
+                name=f"dremio.{query.affected_dataset.lower()}",
                 env=self.config.env,
+                platform_instance=self.config.platform_instance,
             )
 
             # Add query to SqlParsingAggregator

datahub/ingestion/source/dynamodb/dynamodb.py

@@ -200,7 +200,7 @@ class DynamoDBSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "DynamoDBSource":
-        config = DynamoDBConfig.parse_obj(config_dict)
+        config = DynamoDBConfig.model_validate(config_dict)
         return cls(ctx, config, "dynamodb")
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/elastic_search.py

@@ -8,7 +8,7 @@ from hashlib import md5
 from typing import Any, Dict, Generator, Iterable, List, Optional, Tuple, Type, Union
 
 from elasticsearch import Elasticsearch
-from pydantic import validator
+from pydantic import field_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import AllowDenyPattern, ConfigModel
@@ -330,7 +330,8 @@ class ElasticsearchSourceConfig(
             self.profiling.operation_config
         )
 
-    @validator("host")
+    @field_validator("host", mode="after")
+    @classmethod
     def host_colon_port_comma(cls, host_val: str) -> str:
         for entry in host_val.split(","):
             entry = remove_protocol(entry)
@@ -382,7 +383,7 @@ class ElasticsearchSource(StatefulIngestionSourceBase):
     def create(
         cls, config_dict: Dict[str, Any], ctx: PipelineContext
     ) -> "ElasticsearchSource":
-        config = ElasticsearchSourceConfig.parse_obj(config_dict)
+        config = ElasticsearchSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:
@@ -407,12 +408,78 @@ class ElasticsearchSource(StatefulIngestionSourceBase):
         for mcp in self._get_data_stream_index_count_mcps():
             yield mcp.as_workunit()
         if self.source_config.ingest_index_templates:
-            templates = self.client.indices.get_template()
-            for template in templates:
+            # Fetch legacy index templates
+            legacy_templates = self.client.indices.get_template()
+            for template in legacy_templates:
                 if self.source_config.index_template_pattern.allowed(template):
                     for mcp in self._extract_mcps(template, is_index=False):
                         yield mcp.as_workunit()
 
+            # Fetch composable index templates (ES 7.8+ / OpenSearch)
+            try:
+                composable_templates = self.client.indices.get_index_template()
+                for template_info in composable_templates.get("index_templates", []):
+                    template = template_info.get("name")
+                    if template and self.source_config.index_template_pattern.allowed(
+                        template
+                    ):
+                        for mcp in self._extract_mcps(
+                            template, is_index=False, is_composable_template=True
+                        ):
+                            yield mcp.as_workunit()
+            except Exception as e:
+                logger.warning(f"Unable to fetch composable index templates: {e}")
+
+    def _get_template_metadata(
+        self, template_name: str, is_composable: bool
+    ) -> Dict[str, Any]:
+        """Fetch template metadata from Elasticsearch/OpenSearch."""
+        if is_composable:
+            # For composable templates (ES 7.8+ / OpenSearch)
+            raw_response = self.client.indices.get_index_template(name=template_name)
+            template_data = raw_response.get("index_templates", [{}])[0]
+            return template_data.get("index_template", {})
+        else:
+            # For legacy templates
+            raw_response = self.client.indices.get_template(name=template_name)
+            return raw_response[template_name]
+
+    def _extract_template_custom_properties(
+        self, raw_metadata: Dict[str, Any], is_composable: bool
+    ) -> Dict[str, str]:
+        """Extract custom properties from template metadata."""
+        custom_properties: Dict[str, str] = {}
+
+        # Extract aliases
+        if is_composable:
+            aliases_dict = raw_metadata.get("template", {}).get("aliases", {})
+        else:
+            aliases_dict = raw_metadata.get("aliases", {})
+        index_aliases: List[str] = list(aliases_dict.keys()) if aliases_dict else []
+        if index_aliases:
+            custom_properties["aliases"] = ",".join(index_aliases)
+
+        # Extract index_patterns
+        index_patterns: List[str] = raw_metadata.get("index_patterns", [])
+        if index_patterns:
+            custom_properties["index_patterns"] = ",".join(index_patterns)
+
+        # Extract settings
+        if is_composable:
+            index_settings: Dict[str, Any] = (
+                raw_metadata.get("template", {}).get("settings", {}).get("index", {})
+            )
+        else:
+            index_settings = raw_metadata.get("settings", {}).get("index", {})
+        num_shards: str = index_settings.get("number_of_shards", "")
+        if num_shards:
+            custom_properties["num_shards"] = num_shards
+        num_replicas: str = index_settings.get("number_of_replicas", "")
+        if num_replicas:
+            custom_properties["num_replicas"] = num_replicas
+
+        return custom_properties
+
     def _get_data_stream_index_count_mcps(
         self,
     ) -> Iterable[MetadataChangeProposalWrapper]:
@@ -434,9 +501,11 @@ class ElasticsearchSource(StatefulIngestionSourceBase):
             )
 
     def _extract_mcps(
-        self, index: str, is_index: bool = True
+        self, index: str, is_index: bool = True, is_composable_template: bool = False
     ) -> Iterable[MetadataChangeProposalWrapper]:
-        logger.debug(f"index='{index}', is_index={is_index}")
+        logger.debug(
+            f"index='{index}', is_index={is_index}, is_composable_template={is_composable_template}"
+        )
 
         if is_index:
             raw_index = self.client.indices.get(index=index)
@@ -451,15 +520,20 @@ class ElasticsearchSource(StatefulIngestionSourceBase):
                     # This is a duplicate, skip processing it further.
                     return
         else:
-            raw_index = self.client.indices.get_template(name=index)
-            raw_index_metadata = raw_index[index]
+            raw_index_metadata = self._get_template_metadata(
+                index, is_composable_template
+            )
         collapsed_index_name = collapse_name(
             name=index, collapse_urns=self.source_config.collapse_urns
         )
 
         # 1. Construct and emit the schemaMetadata aspect
         # 1.1 Generate the schema fields from ES mappings.
-        index_mappings = raw_index_metadata["mappings"]
+        # For composable templates, mappings are under 'template.mappings'
+        if is_composable_template:
+            index_mappings = raw_index_metadata.get("template", {}).get("mappings", {})
+        else:
+            index_mappings = raw_index_metadata.get("mappings", {})
         index_mappings_json_str: str = json.dumps(index_mappings)
         md5_hash = md5(index_mappings_json_str.encode()).hexdigest()
         schema_fields = list(
@@ -517,28 +591,32 @@ class ElasticsearchSource(StatefulIngestionSourceBase):
             ),
         )
 
-        # 4. Construct and emit properties if needed. Will attempt to get the following properties
-        custom_properties: Dict[str, str] = {}
-        # 4.1 aliases
-        index_aliases: List[str] = raw_index_metadata.get("aliases", {}).keys()
-        if index_aliases:
-            custom_properties["aliases"] = ",".join(index_aliases)
-        # 4.2 index_patterns
-        index_patterns: List[str] = raw_index_metadata.get("index_patterns", [])
-        if index_patterns:
-            custom_properties["index_patterns"] = ",".join(index_patterns)
-
-        # 4.3 number_of_shards
-        index_settings: Dict[str, Any] = raw_index_metadata.get("settings", {}).get(
-            "index", {}
-        )
-        num_shards: str = index_settings.get("number_of_shards", "")
-        if num_shards:
-            custom_properties["num_shards"] = num_shards
-        # 4.4 number_of_replicas
-        num_replicas: str = index_settings.get("number_of_replicas", "")
-        if num_replicas:
-            custom_properties["num_replicas"] = num_replicas
+        # 4. Construct and emit properties
+        if is_index:
+            custom_properties: Dict[str, str] = {}
+            # Extract properties for indices
+            index_aliases: List[str] = list(
+                raw_index_metadata.get("aliases", {}).keys()
+            )
+            if index_aliases:
+                custom_properties["aliases"] = ",".join(index_aliases)
+            index_patterns: List[str] = raw_index_metadata.get("index_patterns", [])
+            if index_patterns:
+                custom_properties["index_patterns"] = ",".join(index_patterns)
+            index_settings: Dict[str, Any] = raw_index_metadata.get("settings", {}).get(
+                "index", {}
+            )
+            num_shards: str = index_settings.get("number_of_shards", "")
+            if num_shards:
+                custom_properties["num_shards"] = num_shards
+            num_replicas: str = index_settings.get("number_of_replicas", "")
+            if num_replicas:
+                custom_properties["num_replicas"] = num_replicas
+        else:
+            # Extract properties for templates
+            custom_properties = self._extract_template_custom_properties(
+                raw_index_metadata, is_composable_template
+            )
 
         yield MetadataChangeProposalWrapper(
             entityUrn=dataset_urn,

datahub/ingestion/source/excel/source.py

@@ -156,7 +156,7 @@ class ExcelSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "ExcelSource":
-        config = ExcelSourceConfig.parse_obj(config_dict)
+        config = ExcelSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]:

datahub/ingestion/source/feast.py

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

datahub/ingestion/source/file.py

@@ -9,7 +9,7 @@ from functools import partial
 from typing import Any, Iterable, Iterator, List, Optional, Tuple, Union
 
 import ijson
-from pydantic import validator
+from pydantic import field_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import ConfigEnum
@@ -103,7 +103,8 @@ class FileSourceConfig(StatefulIngestionConfigBase):
 
     stateful_ingestion: Optional[StatefulStaleMetadataRemovalConfig] = None
 
-    @validator("file_extension", always=True)
+    @field_validator("file_extension", mode="after")
+    @classmethod
     def add_leading_dot_to_extension(cls, v: str) -> str:
         if v:
             if v.startswith("."):
@@ -205,7 +206,7 @@ class GenericFileSource(StatefulIngestionSourceBase, TestableSource):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = FileSourceConfig.parse_obj(config_dict)
+        config = FileSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     def get_filenames(self) -> Iterable[FileInfo]:
@@ -358,7 +359,7 @@ class GenericFileSource(StatefulIngestionSourceBase, TestableSource):
 
     @staticmethod
     def test_connection(config_dict: dict) -> TestConnectionReport:
-        config = FileSourceConfig.parse_obj(config_dict)
+        config = FileSourceConfig.model_validate(config_dict)
         exists = os.path.exists(config.path)
         if not exists:
             return TestConnectionReport(

datahub/ingestion/source/fivetran/config.py

@@ -1,10 +1,10 @@
 import dataclasses
 import logging
 import warnings
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 import pydantic
-from pydantic import Field, root_validator
+from pydantic import Field, field_validator, model_validator
 from typing_extensions import Literal
 
 from datahub.configuration.common import (
@@ -98,7 +98,8 @@ class DatabricksDestinationConfig(UnityCatalogConnectionConfig):
     catalog: str = Field(description="The fivetran connector log catalog.")
     log_schema: str = Field(description="The fivetran connector log schema.")
 
-    @pydantic.validator("warehouse_id")
+    @field_validator("warehouse_id", mode="after")
+    @classmethod
     def warehouse_id_should_not_be_empty(cls, warehouse_id: Optional[str]) -> str:
         if warehouse_id is None or (warehouse_id and warehouse_id.strip() == ""):
             raise ValueError("Fivetran requires warehouse_id to be set")
@@ -141,29 +142,28 @@ class FivetranLogConfig(ConfigModel):
         "destination_config", "snowflake_destination_config"
     )
 
-    @root_validator(skip_on_failure=True)
-    def validate_destination_platfrom_and_config(cls, values: Dict) -> Dict:
-        destination_platform = values["destination_platform"]
-        if destination_platform == "snowflake":
-            if "snowflake_destination_config" not in values:
+    @model_validator(mode="after")
+    def validate_destination_platform_and_config(self) -> "FivetranLogConfig":
+        if self.destination_platform == "snowflake":
+            if self.snowflake_destination_config is None:
                 raise ValueError(
                     "If destination platform is 'snowflake', user must provide snowflake destination configuration in the recipe."
                 )
-        elif destination_platform == "bigquery":
-            if "bigquery_destination_config" not in values:
+        elif self.destination_platform == "bigquery":
+            if self.bigquery_destination_config is None:
                 raise ValueError(
                     "If destination platform is 'bigquery', user must provide bigquery destination configuration in the recipe."
                 )
-        elif destination_platform == "databricks":
-            if "databricks_destination_config" not in values:
+        elif self.destination_platform == "databricks":
+            if self.databricks_destination_config is None:
                 raise ValueError(
                     "If destination platform is 'databricks', user must provide databricks destination configuration in the recipe."
                 )
         else:
             raise ValueError(
-                f"Destination platform '{destination_platform}' is not yet supported."
+                f"Destination platform '{self.destination_platform}' is not yet supported."
             )
-        return values
+        return self
 
 
 @dataclasses.dataclass
@@ -267,8 +267,9 @@ class FivetranSourceConfig(StatefulIngestionConfigBase, DatasetSourceConfigMixin
         description="Fivetran REST API configuration, used to provide wider support for connections.",
     )
 
-    @pydantic.root_validator(pre=True)
-    def compat_sources_to_database(cls, values: Dict) -> Dict:
+    @model_validator(mode="before")
+    @classmethod
+    def compat_sources_to_database(cls, values: Any) -> Any:
         if "sources_to_database" in values:
             warnings.warn(
                 "The sources_to_database field is deprecated, please use sources_to_platform_instance instead.",

datahub/ingestion/source/fivetran/fivetran.py

@@ -234,12 +234,12 @@ class FivetranSource(StatefulIngestionSourceBase):
         return dict(
             **{
                 f"source.{k}": str(v)
-                for k, v in source_details.dict().items()
+                for k, v in source_details.model_dump().items()
                 if v is not None and not isinstance(v, bool)
             },
             **{
                 f"destination.{k}": str(v)
-                for k, v in destination_details.dict().items()
+                for k, v in destination_details.model_dump().items()
                 if v is not None and not isinstance(v, bool)
             },
         )

datahub/ingestion/source/gc/datahub_gc.py

@@ -127,7 +127,7 @@ class DataHubGcSource(Source):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = DataHubGcSourceConfig.parse_obj(config_dict)
+        config = DataHubGcSourceConfig.model_validate(config_dict)
         return cls(ctx, config)
 
     # auto_work_unit_report is overriden to disable a couple of automation like auto status aspect, etc. which is not needed her.

datahub/ingestion/source/gcs/gcs_source.py

@@ -1,7 +1,7 @@
 import logging
-from typing import Dict, Iterable, List, Optional
+from typing import Iterable, List, Optional
 
-from pydantic import Field, SecretStr, validator
+from pydantic import Field, SecretStr, model_validator
 
 from datahub.configuration.common import ConfigModel
 from datahub.configuration.source_common import DatasetSourceConfigMixin
@@ -64,18 +64,16 @@ class GCSSourceConfig(
 
     stateful_ingestion: Optional[StatefulStaleMetadataRemovalConfig] = None
 
-    @validator("path_specs", always=True)
-    def check_path_specs_and_infer_platform(
-        cls, path_specs: List[PathSpec], values: Dict
-    ) -> List[PathSpec]:
-        if len(path_specs) == 0:
+    @model_validator(mode="after")
+    def check_path_specs_and_infer_platform(self) -> "GCSSourceConfig":
+        if len(self.path_specs) == 0:
             raise ValueError("path_specs must not be empty")
 
         # Check that all path specs have the gs:// prefix.
-        if any([not is_gcs_uri(path_spec.include) for path_spec in path_specs]):
+        if any([not is_gcs_uri(path_spec.include) for path_spec in self.path_specs]):
             raise ValueError("All path_spec.include should start with gs://")
 
-        return path_specs
+        return self
 
 
 class GCSSourceReport(DataLakeSourceReport):
@@ -105,7 +103,7 @@ class GCSSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict, ctx):
-        config = GCSSourceConfig.parse_obj(config_dict)
+        config = GCSSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def create_equivalent_s3_config(self):

datahub/ingestion/source/ge_profiling_config.py

@@ -4,6 +4,7 @@ import os
 from typing import Annotated, Any, Dict, List, Optional
 
 import pydantic
+from pydantic import model_validator
 from pydantic.fields import Field
 
 from datahub.configuration.common import AllowDenyPattern, ConfigModel, SupportedSources
@@ -212,7 +213,8 @@ class GEProfilingConfig(GEProfilingBaseConfig):
         description="Whether to profile complex types like structs, arrays and maps. ",
     )
 
-    @pydantic.root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def deprecate_bigquery_temp_table_schema(cls, values):
         # TODO: Update docs to remove mention of this field.
         if "bigquery_temp_table_schema" in values:
@@ -222,16 +224,17 @@ class GEProfilingConfig(GEProfilingBaseConfig):
             del values["bigquery_temp_table_schema"]
         return values
 
-    @pydantic.root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def ensure_field_level_settings_are_normalized(
-        cls: "GEProfilingConfig", values: Dict[str, Any]
+        cls, 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)
 
         # Disable all field-level metrics.
         if values.get("profile_table_level_only"):
-            for field_level_metric in cls.__fields__:
+            for field_level_metric in cls.model_fields:
                 if field_level_metric.startswith("include_field_"):
                     if values.get(field_level_metric):
                         raise ValueError(
@@ -267,7 +270,7 @@ class GEProfilingConfig(GEProfilingBaseConfig):
         )
 
     def config_for_telemetry(self) -> Dict[str, Any]:
-        config_dict = self.dict()
+        config_dict = self.model_dump()
 
         return {
             flag: config_dict[flag]

datahub/ingestion/source/grafana/grafana_api.py

@@ -69,7 +69,7 @@ class GrafanaAPIClient:
                 if not batch:
                     break
 
-                folders.extend(Folder.parse_obj(folder) for folder in batch)
+                folders.extend(Folder.model_validate(folder) for folder in batch)
                 page += 1
             except requests.exceptions.RequestException as e:
                 self.report.report_failure(
@@ -88,7 +88,7 @@ class GrafanaAPIClient:
         try:
             response = self.session.get(f"{self.base_url}/api/dashboards/uid/{uid}")
             response.raise_for_status()
-            return Dashboard.parse_obj(response.json())
+            return Dashboard.model_validate(response.json())
         except requests.exceptions.RequestException as e:
             self.report.warning(
                 title="Dashboard Fetch Error",

datahub/ingestion/source/grafana/grafana_config.py

@@ -1,6 +1,6 @@
 from typing import Dict, Optional
 
-from pydantic import Field, SecretStr, validator
+from pydantic import Field, SecretStr, field_validator
 
 from datahub.configuration.common import AllowDenyPattern, HiddenFromDocs
 from datahub.configuration.source_common import (
@@ -99,6 +99,7 @@ class GrafanaSourceConfig(
         description="Map of Grafana datasource types/UIDs to platform connection configs for lineage extraction",
     )
 
-    @validator("url", allow_reuse=True)
-    def remove_trailing_slash(cls, v):
+    @field_validator("url", mode="after")
+    @classmethod
+    def remove_trailing_slash(cls, v: str) -> str:
         return config_clean.remove_trailing_slashes(v)

datahub/ingestion/source/grafana/grafana_source.py

@@ -171,7 +171,7 @@ class GrafanaSource(StatefulIngestionSourceBase):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "GrafanaSource":
-        config = GrafanaSourceConfig.parse_obj(config_dict)
+        config = GrafanaSourceConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_workunit_processors(self) -> List[Optional[MetadataWorkUnitProcessor]]: