openmetadata-ingestion 1.4.6.0__py3-none-any.whl → 1.5.0.0rc1__py3-none-any.whl

metadata/ingestion/source/dashboard/looker/metadata.py

@@ -73,9 +73,17 @@ from metadata.generated.schema.security.credentials.bitbucketCredentials import
 from metadata.generated.schema.security.credentials.githubCredentials import (
     GitHubCredentials,
 )
+from metadata.generated.schema.type.basic import (
+    EntityName,
+    FullyQualifiedEntityName,
+    Markdown,
+    SourceUrl,
+    Uuid,
+)
 from metadata.generated.schema.type.entityLineage import EntitiesEdge, LineageDetails
 from metadata.generated.schema.type.entityLineage import Source as LineageSource
 from metadata.generated.schema.type.entityReference import EntityReference
+from metadata.generated.schema.type.entityReferenceList import EntityReferenceList
 from metadata.generated.schema.type.usageRequest import UsageRequest
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
@@ -180,8 +188,8 @@ class LookerSource(DashboardServiceSource):
         metadata: OpenMetadata,
         pipeline_name: Optional[str] = None,
     ) -> "LookerSource":
-        config = WorkflowSource.parse_obj(config_dict)
-        connection: LookerConnection = config.serviceConnection.__root__.config
+        config = WorkflowSource.model_validate(config_dict)
+        connection: LookerConnection = config.serviceConnection.root.config
         if not isinstance(connection, LookerConnection):
             raise InvalidSourceException(
                 f"Expected LookerConnection, but got {connection}"
@@ -198,8 +206,10 @@ class LookerSource(DashboardServiceSource):
             ]
         ]
     ) -> "LookMLRepo":
-        repo_name = f"{credentials.repositoryOwner.__root__}/{credentials.repositoryName.__root__}"
-        repo_path = f"{REPO_TMP_LOCAL_PATH}/{credentials.repositoryName.__root__}"
+        repo_name = (
+            f"{credentials.repositoryOwner.root}/{credentials.repositoryName.root}"
+        )
+        repo_path = f"{REPO_TMP_LOCAL_PATH}/{credentials.repositoryName.root}"
         _clone_repo(
             repo_name,
             repo_path,
@@ -223,7 +233,7 @@ class LookerSource(DashboardServiceSource):
         if not os.path.isfile(file_path):
             return None
         with open(file_path, "r", encoding="utf-8") as fle:
-            manifest = LookMLManifest.parse_obj(lkml.load(fle))
+            manifest = LookMLManifest.model_validate(lkml.load(fle))
             if manifest and manifest.remote_dependency:
                 remote_name = manifest.remote_dependency["name"]
                 remote_git_url = manifest.remote_dependency["url"]
@@ -398,9 +408,11 @@ class LookerSource(DashboardServiceSource):
                 self.status.filter(datamodel_name, "Data model filtered out.")
             else:
                 explore_datamodel = CreateDashboardDataModelRequest(
-                    name=datamodel_name,
+                    name=EntityName(datamodel_name),
                     displayName=model.name,
-                    description=model.description,
+                    description=Markdown(model.description)
+                    if model.description
+                    else None,
                     service=self.context.get().dashboard_service,
                     dataModelType=DataModelType.LookMlExplore.value,
                     serviceType=DashboardServiceType.Looker.value,
@@ -419,7 +431,7 @@ class LookerSource(DashboardServiceSource):
                 # Maybe use the project_name as key too?
                 # Save the explores for when we create the lineage with the dashboards and views
                 self._explores_cache[
-                    explore_datamodel.name.__root__
+                    explore_datamodel.name.root
                 ] = self.context.get().dataModel  # This is the newly created explore
 
                 # We can get VIEWs from the JOINs to know the dependencies
@@ -496,9 +508,13 @@ class LookerSource(DashboardServiceSource):
 
             if view:
                 data_model_request = CreateDashboardDataModelRequest(
-                    name=build_datamodel_name(explore.model_name, view.name),
+                    name=EntityName(
+                        build_datamodel_name(explore.model_name, view.name)
+                    ),
                     displayName=view.name,
-                    description=view.description,
+                    description=Markdown(view.description)
+                    if view.description
+                    else None,
                     service=self.context.get().dashboard_service,
                     dataModelType=DataModelType.LookMlView.value,
                     serviceType=DashboardServiceType.Looker.value,
@@ -623,7 +639,7 @@ class LookerSource(DashboardServiceSource):
 
     def get_owner_ref(
         self, dashboard_details: LookerDashboard
-    ) -> Optional[EntityReference]:
+    ) -> Optional[EntityReferenceList]:
         """Get dashboard owner
 
         Store the visited users in the _owners_ref cache, even if we found them
@@ -654,24 +670,30 @@ class LookerSource(DashboardServiceSource):
         Method to Get Dashboard Entity
         """
         dashboard_request = CreateDashboardRequest(
-            name=clean_dashboard_name(dashboard_details.id),
+            name=EntityName(clean_dashboard_name(dashboard_details.id)),
             displayName=dashboard_details.title,
-            description=dashboard_details.description or None,
+            description=Markdown(dashboard_details.description)
+            if dashboard_details.description
+            else None,
             charts=[
-                fqn.build(
-                    self.metadata,
-                    entity_type=Chart,
-                    service_name=self.context.get().dashboard_service,
-                    chart_name=chart,
+                FullyQualifiedEntityName(
+                    fqn.build(
+                        self.metadata,
+                        entity_type=Chart,
+                        service_name=self.context.get().dashboard_service,
+                        chart_name=chart,
+                    )
                 )
                 for chart in self.context.get().charts or []
             ],
             # Dashboards are created from the UI directly. They are not linked to a project
             # like LookML assets, but rather just organised in folders.
             project=self.get_project_name(dashboard_details),
-            sourceUrl=f"{clean_uri(self.service_connection.hostPort)}/dashboards/{dashboard_details.id}",
+            sourceUrl=SourceUrl(
+                f"{clean_uri(self.service_connection.hostPort)}/dashboards/{dashboard_details.id}"
+            ),
             service=self.context.get().dashboard_service,
-            owner=self.get_owner_ref(dashboard_details=dashboard_details),
+            owners=self.get_owner_ref(dashboard_details=dashboard_details),
         )
         yield Either(right=dashboard_request)
         self.register_record(dashboard_request=dashboard_request)
@@ -774,11 +796,11 @@ class LookerSource(DashboardServiceSource):
                         right=AddLineageRequest(
                             edge=EntitiesEdge(
                                 fromEntity=EntityReference(
-                                    id=cached_explore.id.__root__,
+                                    id=Uuid(cached_explore.id.root),
                                     type="dashboardDataModel",
                                 ),
                                 toEntity=EntityReference(
-                                    id=dashboard_entity.id.__root__,
+                                    id=Uuid(dashboard_entity.id.root),
                                     type="dashboard",
                                 ),
                                 lineageDetails=LineageDetails(
@@ -833,15 +855,10 @@ class LookerSource(DashboardServiceSource):
             )
 
             if from_entity:
-                if from_entity.id.__root__ not in self._added_lineage:
-                    self._added_lineage[from_entity.id.__root__] = []
-                if (
-                    to_entity.id.__root__
-                    not in self._added_lineage[from_entity.id.__root__]
-                ):
-                    self._added_lineage[from_entity.id.__root__].append(
-                        to_entity.id.__root__
-                    )
+                if from_entity.id.root not in self._added_lineage:
+                    self._added_lineage[from_entity.id.root] = []
+                if to_entity.id.root not in self._added_lineage[from_entity.id.root]:
+                    self._added_lineage[from_entity.id.root].append(to_entity.id.root)
                     return self._get_add_lineage_request(
                         to_entity=to_entity, from_entity=from_entity
                     )
@@ -867,15 +884,18 @@ class LookerSource(DashboardServiceSource):
                     logger.debug(f"Found chart {chart} without id. Skipping.")
                     continue
 
+                description = self.build_chart_description(chart)
                 yield Either(
                     right=CreateChartRequest(
-                        name=chart.id,
+                        name=EntityName(chart.id),
                         displayName=chart.title or chart.id,
-                        description=self.build_chart_description(chart) or None,
+                        description=Markdown(description) if description else None,
                         chartType=get_standard_chart_type(chart.type).value,
-                        sourceUrl=chart.query.share_url
+                        sourceUrl=SourceUrl(chart.query.share_url)
                         if chart.query is not None
-                        else f"{clean_uri(self.service_connection.hostPort)}/merge?mid={chart.merge_result_id}",
+                        else SourceUrl(
+                            f"{clean_uri(self.service_connection.hostPort)}/merge?mid={chart.merge_result_id}"
+                        ),
                         service=self.context.get().dashboard_service,
                     )
                 )
@@ -968,7 +988,7 @@ class LookerSource(DashboardServiceSource):
 
             if not dashboard.usageSummary:
                 logger.info(
-                    f"Yielding fresh usage for {dashboard.fullyQualifiedName.__root__}"
+                    f"Yielding fresh usage for {dashboard.fullyQualifiedName.root}"
                 )
                 yield Either(
                     right=DashboardUsage(
@@ -978,7 +998,7 @@ class LookerSource(DashboardServiceSource):
                 )
 
             elif (
-                str(dashboard.usageSummary.date.__root__) != self.today
+                str(dashboard.usageSummary.date.root) != self.today
                 or not dashboard.usageSummary.dailyStats.count
             ):
                 latest_usage = dashboard.usageSummary.dailyStats.count
@@ -990,7 +1010,7 @@ class LookerSource(DashboardServiceSource):
                     )
 
                 logger.info(
-                    f"Yielding new usage for {dashboard.fullyQualifiedName.__root__}"
+                    f"Yielding new usage for {dashboard.fullyQualifiedName.root}"
                 )
                 yield Either(
                     right=DashboardUsage(
@@ -1006,7 +1026,7 @@ class LookerSource(DashboardServiceSource):
                     f"Latest usage {dashboard.usageSummary} vs. today {self.today}. Nothing to compute."
                 )
                 logger.info(
-                    f"Usage already informed for {dashboard.fullyQualifiedName.__root__}"
+                    f"Usage already informed for {dashboard.fullyQualifiedName.root}"
                 )
 
         except Exception as exc:

metadata/ingestion/source/dashboard/looker/parser.py

@@ -115,7 +115,7 @@ class LkmlParser:
         Processing of a single path
         """
         file = self._read_file(path)
-        lkml_file = LkmlFile.parse_obj(lkml.load(file))
+        lkml_file = LkmlFile.model_validate(lkml.load(file))
         self.parsed_files[path] = file
 
         # Cache everything
@@ -211,6 +211,6 @@ class LkmlParser:
         Customize string repr for logs
         """
         return (
-            f"Parser at [{self.reader.credentials.repositoryOwner.__root__}/"
-            f"{self.reader.credentials.repositoryName.__root__}]"
+            f"Parser at [{self.reader.credentials.repositoryOwner.root}/"
+            f"{self.reader.credentials.repositoryName.root}]"
         )

metadata/ingestion/source/dashboard/looker/utils.py

@@ -56,9 +56,9 @@ def _clone_repo(
         url = None
         allow_unsafe_protocols = False
         if isinstance(credential, GitHubCredentials):
-            url = f"https://x-oauth-basic:{credential.token.__root__.get_secret_value()}@github.com/{repo_name}.git"
+            url = f"https://x-oauth-basic:{credential.token.root.get_secret_value()}@github.com/{repo_name}.git"
         elif isinstance(credential, BitBucketCredentials):
-            url = f"https://x-token-auth:{credential.token.__root__.get_secret_value()}@bitbucket.org/{repo_name}.git"
+            url = f"https://x-token-auth:{credential.token.root.get_secret_value()}@bitbucket.org/{repo_name}.git"
             allow_unsafe_protocols = True
 
         assert url is not None

metadata/ingestion/source/dashboard/metabase/client.py

@@ -30,6 +30,7 @@ from metadata.ingestion.source.dashboard.metabase.models import (
     MetabaseDashboardList,
     MetabaseDatabase,
     MetabaseTable,
+    MetabaseUser,
 )
 from metadata.utils.constants import AUTHORIZATION_HEADER, NO_ACCESS_TOKEN
 from metadata.utils.logger import ingestion_logger
@@ -55,7 +56,7 @@ class MetabaseClient:
             if self.config.password:
                 params[PASSWORD_HEADER] = self.config.password.get_secret_value()
             self.resp = requests.post(
-                f"{self.config.hostPort}/{API_VERSION}/session/",
+                f"{self.config.hostPort}{API_VERSION}/session/",
                 data=json.dumps(params),
                 headers=SESSION_HEADERS,
                 timeout=DEFAULT_TIMEOUT,
@@ -77,7 +78,7 @@ class MetabaseClient:
         self.config = config
         session_token = self._get_metabase_session()
         client_config: ClientConfig = ClientConfig(
-            base_url=self.config.hostPort,
+            base_url=str(self.config.hostPort)[:-1],  # remove trailing slash
             api_version=API_VERSION,
             auth_header=AUTHORIZATION_HEADER,
             auth_token=lambda: (NO_ACCESS_TOKEN, 0),
@@ -194,3 +195,18 @@ class MetabaseClient:
             logger.debug(traceback.format_exc())
             logger.warning(f"Failed to fetch the table with id: {table_id}")
         return None
+
+    def get_user_details(self, user_id: str) -> Optional[MetabaseUser]:
+        """
+        Get User using user ID
+        """
+        if not user_id:
+            return None  # don't call api if table_id is None
+        try:
+            resp_table = self.client.get(f"/user/{user_id}")
+            if resp_table:
+                return MetabaseUser(**resp_table)
+        except Exception:
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Failed to fetch the user with id: {user_id}")
+        return None

metadata/ingestion/source/dashboard/metabase/metadata.py

@@ -33,6 +33,13 @@ from metadata.generated.schema.entity.services.ingestionPipelines.status import
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
+from metadata.generated.schema.type.basic import (
+    EntityName,
+    FullyQualifiedEntityName,
+    Markdown,
+    SourceUrl,
+)
+from metadata.generated.schema.type.entityReferenceList import EntityReferenceList
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper
@@ -70,8 +77,8 @@ class MetabaseSource(DashboardServiceSource):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config = WorkflowSource.parse_obj(config_dict)
-        connection: MetabaseConnection = config.serviceConnection.__root__.config
+        config = WorkflowSource.model_validate(config_dict)
+        connection: MetabaseConnection = config.serviceConnection.root.config
         if not isinstance(connection, MetabaseConnection):
             raise InvalidSourceException(
                 f"Expected MetabaseConnection, but got {connection}"
@@ -102,7 +109,9 @@ class MetabaseSource(DashboardServiceSource):
         """
         return dashboard.name
 
-    def get_dashboard_details(self, dashboard: MetabaseDashboard) -> dict:
+    def get_dashboard_details(
+        self, dashboard: MetabaseDashboard
+    ) -> Optional[MetabaseDashboardDetails]:
         """
         Get Dashboard Details
         """
@@ -130,6 +139,24 @@ class MetabaseSource(DashboardServiceSource):
             )
         return None
 
+    def get_owner_ref(
+        self, dashboard_details: MetabaseDashboardDetails
+    ) -> Optional[EntityReferenceList]:
+        """
+        Get dashboard owner from email
+        """
+        try:
+            if dashboard_details.creator_id:
+                owner_details = self.client.get_user_details(
+                    dashboard_details.creator_id
+                )
+                if owner_details and owner_details.email:
+                    return self.metadata.get_reference_by_email(owner_details.email)
+        except Exception as err:
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Could not fetch owner data due to {err}")
+        return None
+
     def yield_dashboard(
         self, dashboard_details: MetabaseDashboardDetails
     ) -> Iterable[Either[CreateDashboardRequest]]:
@@ -142,22 +169,26 @@ class MetabaseSource(DashboardServiceSource):
                 f"{replace_special_with(raw=dashboard_details.name.lower(), replacement='-')}"
             )
             dashboard_request = CreateDashboardRequest(
-                name=dashboard_details.id,
-                sourceUrl=dashboard_url,
+                name=EntityName(str(dashboard_details.id)),
+                sourceUrl=SourceUrl(dashboard_url),
                 displayName=dashboard_details.name,
-                description=dashboard_details.description,
+                description=Markdown(dashboard_details.description)
+                if dashboard_details.description
+                else None,
                 project=self.context.get().project_name,
                 charts=[
-                    fqn.build(
-                        self.metadata,
-                        entity_type=Chart,
-                        service_name=self.context.get().dashboard_service,
-                        chart_name=chart,
+                    FullyQualifiedEntityName(
+                        fqn.build(
+                            self.metadata,
+                            entity_type=Chart,
+                            service_name=self.context.get().dashboard_service,
+                            chart_name=chart,
+                        )
                     )
                     for chart in self.context.get().charts or []
                 ],
                 service=self.context.get().dashboard_service,
-                owner=self.get_owner_ref(dashboard_details=dashboard_details),
+                owners=self.get_owner_ref(dashboard_details=dashboard_details),
             )
             yield Either(right=dashboard_request)
             self.register_record(dashboard_request=dashboard_request)
@@ -197,11 +228,11 @@ class MetabaseSource(DashboardServiceSource):
                     continue
                 yield Either(
                     right=CreateChartRequest(
-                        name=chart_details.id,
+                        name=EntityName(chart_details.id),
                         displayName=chart_details.name,
                         description=chart_details.description,
                         chartType=get_standard_chart_type(chart_details.display).value,
-                        sourceUrl=chart_url,
+                        sourceUrl=SourceUrl(chart_url),
                         service=self.context.get().dashboard_service,
                     )
                 )

metadata/ingestion/source/dashboard/metabase/models.py

@@ -13,7 +13,24 @@ Metabase Models
 """
 from typing import List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, BeforeValidator, Field
+from typing_extensions import Annotated
+
+MetabaseStrId = Annotated[str, BeforeValidator(lambda x: str(x))]
+
+
+class MetabaseUser(BaseModel):
+    """
+    Metabase user model
+    """
+
+    id: MetabaseStrId
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    common_name: Optional[str] = None
+    email: Optional[str] = None
+    is_superuser: Optional[bool] = False
+    last_edit_timestamp: Optional[str] = Field(None, alias="timestamp")
 
 
 class MetabaseDashboard(BaseModel):
@@ -21,10 +38,10 @@ class MetabaseDashboard(BaseModel):
     Metabase dashboard model
     """
 
-    description: Optional[str]
+    description: Optional[str] = None
     name: str
-    id: int
-    collection_id: Optional[str]
+    id: MetabaseStrId
+    collection_id: Optional[MetabaseStrId] = None
 
 
 class MetabaseCollection(BaseModel):
@@ -33,24 +50,24 @@ class MetabaseCollection(BaseModel):
     """
 
     name: str
-    id: str
+    id: MetabaseStrId
 
 
 class MetabaseDashboardList(BaseModel):
-    data: Optional[List[MetabaseDashboard]]
+    data: List[MetabaseDashboard] = []
 
 
 class MetabaseCollectionList(BaseModel):
-    collections: Optional[List[MetabaseCollection]]
+    collections: List[MetabaseCollection] = []
 
 
 class Native(BaseModel):
-    query: Optional[str]
+    query: Optional[str] = None
 
 
 class DatasetQuery(BaseModel):
-    type: Optional[str]
-    native: Optional[Native]
+    type: Optional[str] = None
+    native: Optional[Native] = None
 
 
 class MetabaseChart(BaseModel):
@@ -58,13 +75,13 @@ class MetabaseChart(BaseModel):
     Metabase card model
     """
 
-    description: Optional[str]
-    table_id: Optional[str]
-    database_id: Optional[int]
-    name: Optional[str]
-    dataset_query: Optional[DatasetQuery]
-    id: Optional[int]
-    display: Optional[str]
+    description: Optional[str] = None
+    table_id: Optional[MetabaseStrId] = None
+    database_id: Optional[MetabaseStrId] = None
+    name: Optional[str] = None
+    dataset_query: Optional[DatasetQuery] = None
+    id: Optional[MetabaseStrId] = None
+    display: Optional[str] = None
 
 
 class DashCard(BaseModel):
@@ -76,15 +93,16 @@ class MetabaseDashboardDetails(BaseModel):
     Metabase dashboard details model
     """
 
-    description: Optional[str]
+    description: Optional[str] = None
     dashcards: List[DashCard]
-    name: Optional[str]
-    id: int
-    collection_id: Optional[str]
+    name: Optional[str] = None
+    id: MetabaseStrId
+    creator_id: Optional[MetabaseStrId] = None
+    collection_id: Optional[MetabaseStrId] = None
 
 
 class MetabaseDatabaseDetails(BaseModel):
-    db: Optional[str]
+    db: Optional[str] = None
 
 
 class MetabaseDatabase(BaseModel):
@@ -92,12 +110,12 @@ class MetabaseDatabase(BaseModel):
     Metabase database model
     """
 
-    details: Optional[MetabaseDatabaseDetails]
+    details: Optional[MetabaseDatabaseDetails] = None
 
 
 class MetabaseTable(BaseModel):
-    table_schema: Optional[str] = Field(..., alias="schema")
-    db: Optional[MetabaseDatabase]
-    name: Optional[str]
-    id: Optional[int]
-    display_name: Optional[str]
+    table_schema: Optional[str] = Field(None, alias="schema")
+    db: Optional[MetabaseDatabase] = None
+    name: Optional[str] = None
+    id: Optional[MetabaseStrId] = None
+    display_name: Optional[str] = None

metadata/ingestion/source/dashboard/mode/client.py

@@ -50,7 +50,7 @@ class ModeApiClient:
     def __init__(self, config):
         self.config = config
         client_config = ClientConfig(
-            base_url=config.hostPort,
+            base_url=str(config.hostPort),
             api_version="api",
             auth_header="Authorization",
             auth_token_mode="Basic",

metadata/ingestion/source/dashboard/mode/metadata.py

@@ -29,6 +29,12 @@ from metadata.generated.schema.entity.services.ingestionPipelines.status import
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
+from metadata.generated.schema.type.basic import (
+    EntityName,
+    FullyQualifiedEntityName,
+    Markdown,
+    SourceUrl,
+)
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.lineage.parser import LineageParser
@@ -55,15 +61,15 @@ class ModeSource(DashboardServiceSource):
         metadata: OpenMetadata,
     ):
         super().__init__(config, metadata)
-        self.workspace_name = config.serviceConnection.__root__.config.workspaceName
+        self.workspace_name = config.serviceConnection.root.config.workspaceName
         self.data_sources = self.client.get_all_data_sources(self.workspace_name)
 
     @classmethod
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config = WorkflowSource.parse_obj(config_dict)
-        connection: ModeConnection = config.serviceConnection.__root__.config
+        config = WorkflowSource.model_validate(config_dict)
+        connection: ModeConnection = config.serviceConnection.root.config
         if not isinstance(connection, ModeConnection):
             raise InvalidSourceException(
                 f"Expected ModeConnection, but got {connection}"
@@ -97,21 +103,25 @@ class ModeSource(DashboardServiceSource):
         dashboard_path = dashboard_details[client.LINKS][client.SHARE][client.HREF]
         dashboard_url = f"{clean_uri(self.service_connection.hostPort)}{dashboard_path}"
         dashboard_request = CreateDashboardRequest(
-            name=dashboard_details.get(client.TOKEN),
-            sourceUrl=dashboard_url,
+            name=EntityName(dashboard_details.get(client.TOKEN)),
+            sourceUrl=SourceUrl(dashboard_url),
             displayName=dashboard_details.get(client.NAME),
-            description=dashboard_details.get(client.DESCRIPTION),
+            description=Markdown(dashboard_details.get(client.DESCRIPTION))
+            if dashboard_details.get(client.DESCRIPTION)
+            else None,
             charts=[
-                fqn.build(
-                    self.metadata,
-                    entity_type=Chart,
-                    service_name=self.context.get().dashboard_service,
-                    chart_name=chart,
+                FullyQualifiedEntityName(
+                    fqn.build(
+                        self.metadata,
+                        entity_type=Chart,
+                        service_name=self.context.get().dashboard_service,
+                        chart_name=chart,
+                    )
                 )
                 for chart in self.context.get().charts or []
             ],
             service=self.context.get().dashboard_service,
-            owner=self.get_owner_ref(dashboard_details=dashboard_details),
+            owners=self.get_owner_ref(dashboard_details=dashboard_details),
         )
         yield Either(right=dashboard_request)
         self.register_record(dashboard_request=dashboard_request)
@@ -201,10 +211,10 @@ class ModeSource(DashboardServiceSource):
                     )
                     yield Either(
                         right=CreateChartRequest(
-                            name=chart.get(client.TOKEN),
+                            name=EntityName(chart.get(client.TOKEN)),
                             displayName=chart_name,
                             chartType=ChartType.Other,
-                            sourceUrl=chart_url,
+                            sourceUrl=SourceUrl(chart_url),
                             service=self.context.get().dashboard_service,
                         )
                     )

metadata/ingestion/source/dashboard/mstr/client.py

@@ -167,7 +167,7 @@ class MSTRClient:
             dashboards = []
             for result in results:
                 dashboards.append(
-                    MstrDashboard(projectName=project_name, **result.dict())
+                    MstrDashboard(projectName=project_name, **result.model_dump())
                 )
 
             dashboards_list = MstrDashboardList(dashboards=dashboards)