openmetadata-ingestion 1.6.6.5__py3-none-any.whl → 1.6.7.0__py3-none-any.whl

metadata/ingestion/source/dashboard/powerbi/metadata.py

@@ -50,7 +50,6 @@ from metadata.generated.schema.type.basic import (
 )
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
-from metadata.ingestion.models.ometa_lineage import OMetaLineageRequest
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.ometa.utils import model_str
 from metadata.ingestion.source.dashboard.dashboard_service import DashboardServiceSource
@@ -58,7 +57,6 @@ from metadata.ingestion.source.dashboard.powerbi.models import (
     Dataset,
     Group,
     PowerBIDashboard,
-    PowerBiMeasureModel,
     PowerBIReport,
     PowerBiTable,
 )
@@ -68,6 +66,7 @@ from metadata.utils.filters import (
     filter_by_chart,
     filter_by_dashboard,
     filter_by_datamodel,
+    filter_by_project,
 )
 from metadata.utils.helpers import clean_uri
 from metadata.utils.logger import ingestion_logger
@@ -93,59 +92,87 @@ class PowerbiSource(DashboardServiceSource):
         self.workspace_data = []
         self.datamodel_file_mappings = []
 
+    def prepare(self):
+        """
+        - Since we get all the required info i.e. reports, dashboards, charts, datasets
+          with workflow scan approach, we are populating bulk data for workspace.
+        - Some individual APIs are not able to yield data with details.
+        """
+        if self.service_connection.useAdminApis:
+            groups = self.get_admin_workspace_data()
+        else:
+            groups = self.get_org_workspace_data()
+        if groups:
+            self.workspace_data = self.get_filtered_workspaces(groups)
+        return super().prepare()
+
     def close(self):
         self.metadata.close()
         if self.client.file_client:
             self.client.file_client.delete_tmp_files()
 
-    def get_org_workspace_data(self) -> Iterable[Optional[Group]]:
+    def get_filtered_workspaces(self, groups: List[Group]) -> List[Group]:
         """
-        fetch all the workspace data for non-admin users
+        Method to get the workspaces filtered by project filter pattern
         """
-        filter_pattern = self.source_config.projectFilterPattern
-        workspaces = self.client.api_client.fetch_all_workspaces(filter_pattern)
-        for workspace in workspaces:
-            # add the dashboards to the workspace
-            workspace.dashboards.extend(
-                self.client.api_client.fetch_all_org_dashboards(group_id=workspace.id)
-                or []
+        filtered_groups = []
+        for group in groups:
+            if filter_by_project(
+                self.source_config.projectFilterPattern,
+                group.name,
+            ):
+                self.status.filter(
+                    group.name,
+                    "Workspace Filtered Out",
+                )
+                continue
+            filtered_groups.append(group)
+        return filtered_groups
+
+    def get_org_workspace_data(self) -> Optional[List[Group]]:
+        """
+        fetch all the group workspace ids
+        """
+        groups = self.client.api_client.fetch_all_workspaces()
+        for group in groups:
+            # add the dashboards to the groups
+            group.dashboards.extend(
+                self.client.api_client.fetch_all_org_dashboards(group_id=group.id) or []
             )
-            for dashboard in workspace.dashboards:
+            for dashboard in group.dashboards:
                 # add the tiles to the dashboards
                 dashboard.tiles.extend(
                     self.client.api_client.fetch_all_org_tiles(
-                        group_id=workspace.id, dashboard_id=dashboard.id
+                        group_id=group.id, dashboard_id=dashboard.id
                     )
                     or []
                 )
 
-            # add the reports to the workspaces
-            workspace.reports.extend(
-                self.client.api_client.fetch_all_org_reports(group_id=workspace.id)
-                or []
+            # add the reports to the groups
+            group.reports.extend(
+                self.client.api_client.fetch_all_org_reports(group_id=group.id) or []
             )
 
-            # add the datasets to the workspaces
-            workspace.datasets.extend(
-                self.client.api_client.fetch_all_org_datasets(group_id=workspace.id)
-                or []
+            # add the datasets to the groups
+            group.datasets.extend(
+                self.client.api_client.fetch_all_org_datasets(group_id=group.id) or []
             )
-            for dataset in workspace.datasets:
+            for dataset in group.datasets:
                 # add the tables to the datasets
                 dataset.tables.extend(
                     self.client.api_client.fetch_dataset_tables(
-                        group_id=workspace.id, dataset_id=dataset.id
+                        group_id=group.id, dataset_id=dataset.id
                     )
                     or []
                 )
-            yield workspace
+        return groups
 
-    def get_admin_workspace_data(self) -> Iterable[Optional[Group]]:
+    def get_admin_workspace_data(self) -> Optional[List[Group]]:
         """
-        fetch all the workspace data
+        fetch all the workspace ids
         """
-        filter_pattern = self.source_config.projectFilterPattern
-        workspaces = self.client.api_client.fetch_all_workspaces(filter_pattern)
+        groups = []
+        workspaces = self.client.api_client.fetch_all_workspaces()
         if workspaces:
             workspace_id_list = [workspace.id for workspace in workspaces]
 
@@ -192,12 +219,17 @@ class PowerbiSource(DashboardServiceSource):
                     )
                     count += 1
                     continue
-                for active_workspace in response.workspaces:
-                    if active_workspace.state == "Active":
-                        yield active_workspace
+                groups.extend(
+                    [
+                        active_workspace
+                        for active_workspace in response.workspaces
+                        if active_workspace.state == "Active"
+                    ]
+                )
                 count += 1
         else:
             logger.error("Unable to fetch any PowerBI workspaces")
+        return groups or None
 
     @classmethod
     def create(
@@ -211,30 +243,23 @@ class PowerbiSource(DashboardServiceSource):
             )
         return cls(config, metadata)
 
-    def _prepare_workspace_data(self):
-        """
-        - Since we get all the required info i.e. reports, dashboards, charts, datasets
-          with workflow scan approach, we are populating bulk data for workspace.
-        - Some individual APIs are not able to yield data with details.
-        """
-        if self.service_connection.useAdminApis:
-            for workspace in self.get_admin_workspace_data():
-                yield workspace
-        else:
-            for workspace in self.get_org_workspace_data():
-                yield workspace
-
     def get_dashboard(self) -> Any:
         """
         Method to iterate through dashboard lists filter dashboards & yield dashboard details
         """
-        for workspace in self._prepare_workspace_data():
-            self.workspace_data.append(workspace)
+        for workspace in self.workspace_data:
             self.context.get().workspace = workspace
-            self.filtered_dashboards = []
-            for dashboard in self.get_dashboards_list() or []:
-                dashboard_details = self.get_dashboard_details(dashboard)
+            for dashboard in self.get_dashboards_list():
+                try:
+                    dashboard_details = self.get_dashboard_details(dashboard)
+                except Exception as exc:
+                    logger.debug(traceback.format_exc())
+                    logger.warning(
+                        f"Cannot extract dashboard details from {dashboard}: {exc}"
+                    )
+                    continue
                 dashboard_name = self.get_dashboard_name(dashboard_details)
+
                 if filter_by_dashboard(
                     self.source_config.dashboardFilterPattern,
                     dashboard_name,
@@ -244,8 +269,7 @@ class PowerbiSource(DashboardServiceSource):
                         "Dashboard Filtered Out",
                     )
                     continue
-                self.filtered_dashboards.append(dashboard_details)
-            yield workspace
+                yield dashboard_details
 
     def get_dashboards_list(
         self,
@@ -308,147 +332,54 @@ class PowerbiSource(DashboardServiceSource):
             f"{workspace_id}/{chart_url_postfix}"
         )
 
-    def yield_dashboard(
-        self, dashboard_details: Group
-    ) -> Iterable[Either[CreateDashboardRequest]]:
-        """
-        Method to Get Dashboard Entity, Dashboard Charts & Lineage
+    def list_datamodels(self) -> Iterable[Dataset]:
         """
-        try:
-            for dashboard in self.filtered_dashboards or []:
-                dashboard_details = self.get_dashboard_details(dashboard)
-                if isinstance(dashboard_details, PowerBIDashboard):
-                    dashboard_request = CreateDashboardRequest(
-                        name=EntityName(dashboard_details.id),
-                        sourceUrl=SourceUrl(
-                            self._get_dashboard_url(
-                                workspace_id=self.context.get().workspace.id,
-                                dashboard_id=dashboard_details.id,
-                            )
-                        ),
-                        project=self.get_project_name(dashboard_details),
-                        displayName=dashboard_details.displayName,
-                        dashboardType=DashboardType.Dashboard,
-                        charts=[
-                            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=FullyQualifiedEntityName(
-                            self.context.get().dashboard_service
-                        ),
-                        owners=self.get_owner_ref(dashboard_details=dashboard_details),
-                    )
-                else:
-                    dashboard_request = CreateDashboardRequest(
-                        name=EntityName(dashboard_details.id),
-                        dashboardType=DashboardType.Report,
-                        sourceUrl=SourceUrl(
-                            self._get_report_url(
-                                workspace_id=self.context.get().workspace.id,
-                                dashboard_id=dashboard_details.id,
-                            )
-                        ),
-                        project=self.get_project_name(dashboard_details),
-                        displayName=dashboard_details.name,
-                        service=self.context.get().dashboard_service,
-                        owners=self.get_owner_ref(dashboard_details=dashboard_details),
-                    )
-                yield Either(right=dashboard_request)
-                self.register_record(dashboard_request=dashboard_request)
-        except Exception as exc:  # pylint: disable=broad-except
-            yield Either(
-                left=StackTraceError(
-                    name=dashboard_details.name,
-                    error=f"Error creating dashboard [{dashboard_details}]: {exc}",
-                    stackTrace=traceback.format_exc(),
-                )
-            )
-
-    def yield_dashboard_chart(
-        self, dashboard_details: Group
-    ) -> Iterable[Either[CreateChartRequest]]:
-        """Get chart method
-        Args:
-            dashboard_details:
-        Returns:
-            Iterable[Chart]
+        Get All the Powerbi Datasets
         """
-        for dashboard in self.filtered_dashboards or []:
-            dashboard_details = self.get_dashboard_details(dashboard)
-            if isinstance(dashboard_details, PowerBIDashboard):
-                charts = dashboard_details.tiles
-                for chart in charts or []:
-                    try:
-                        chart_title = chart.title
-                        chart_display_name = chart_title if chart_title else chart.id
-                        if filter_by_chart(
-                            self.source_config.chartFilterPattern, chart_display_name
+        if self.source_config.includeDataModels:
+            try:
+                for workspace in self.workspace_data:
+                    for dataset in workspace.datasets or []:
+                        if filter_by_datamodel(
+                            self.source_config.dataModelFilterPattern, dataset.name
                         ):
-                            self.status.filter(
-                                chart_display_name, "Chart Pattern not Allowed"
-                            )
+                            self.status.filter(dataset.name, "Data model filtered out.")
                             continue
-                        yield Either(
-                            right=CreateChartRequest(
-                                name=EntityName(chart.id),
-                                displayName=chart_display_name,
-                                chartType=ChartType.Other.value,
-                                sourceUrl=SourceUrl(
-                                    self._get_chart_url(
-                                        report_id=chart.reportId,
-                                        workspace_id=self.context.get().workspace.id,
-                                        dashboard_id=dashboard_details.id,
-                                    )
-                                ),
-                                service=FullyQualifiedEntityName(
-                                    self.context.get().dashboard_service
-                                ),
-                            )
-                        )
-                    except Exception as exc:
-                        yield Either(
-                            left=StackTraceError(
-                                name=chart.title,
-                                error=f"Error creating chart [{chart.title}]: {exc}",
-                                stackTrace=traceback.format_exc(),
-                            )
-                        )
+                        yield dataset
+            except Exception as err:
+                logger.debug(traceback.format_exc())
+                logger.error(f"Unexpected error fetching PowerBI datasets - {err}")
 
-    def _get_child_measures(self, table: PowerBiTable) -> List[Column]:
+    def yield_bulk_datamodel(
+        self, dataset: Dataset
+    ) -> Iterable[Either[CreateDashboardDataModelRequest]]:
         """
-        Extract the measures of the table
+        Method to fetch DataModels in bulk
         """
-        measures = []
-        for measure in table.measures or []:
-            try:
-                measure_type = (
-                    DataType.MEASURE_HIDDEN
-                    if measure.isHidden
-                    else DataType.MEASURE_VISIBLE
-                )
-                description_text = (
-                    f"{measure.description}\n\nExpression : {measure.expression}"
-                    if measure.description
-                    else f"Expression : {measure.expression}"
-                )
-                parsed_measure = PowerBiMeasureModel(
-                    dataType=measure_type,
-                    dataTypeDisplay=measure_type,
-                    name=measure.name,
-                    description=description_text,
+        try:
+            data_model_request = CreateDashboardDataModelRequest(
+                name=EntityName(dataset.id),
+                displayName=dataset.name,
+                description=Markdown(dataset.description)
+                if dataset.description
+                else None,
+                service=FullyQualifiedEntityName(self.context.get().dashboard_service),
+                dataModelType=DataModelType.PowerBIDataModel.value,
+                serviceType=DashboardServiceType.PowerBI.value,
+                columns=self._get_column_info(dataset),
+                project=self._fetch_dataset_workspace(dataset_id=dataset.id),
+            )
+            yield Either(right=data_model_request)
+            self.register_record_datamodel(datamodel_request=data_model_request)
+
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name=dataset.name,
+                    error=f"Error yielding Data Model [{dataset.name}]: {exc}",
+                    stackTrace=traceback.format_exc(),
                 )
-                measures.append(Column(**parsed_measure.model_dump()))
-            except Exception as err:
-                logger.debug(traceback.format_exc())
-                logger.warning(f"Error processing datamodel nested measure: {err}")
-        return measures
+            )
 
     def _get_child_columns(self, table: PowerBiTable) -> List[Column]:
         """
@@ -466,7 +397,6 @@ class PowerbiSource(DashboardServiceSource):
                     ),
                     "name": column.name,
                     "displayName": column.name,
-                    "description": column.description,
                 }
                 if column.dataType and column.dataType == DataType.ARRAY.value:
                     parsed_column["arrayDataType"] = DataType.UNKNOWN
@@ -489,58 +419,71 @@ class PowerbiSource(DashboardServiceSource):
                     "description": table.description,
                 }
                 child_columns = self._get_child_columns(table=table)
-                child_measures = self._get_child_measures(table=table)
                 if child_columns:
                     parsed_table["children"] = child_columns
-                if child_measures:
-                    parsed_table["children"].extend(child_measures)
                 datasource_columns.append(Column(**parsed_table))
             except Exception as exc:
                 logger.debug(traceback.format_exc())
                 logger.warning(f"Error to yield datamodel column: {exc}")
         return datasource_columns
 
-    def _get_datamodels_list(self) -> List[Dataset]:
-        """
-        Get All the Powerbi Datasets
-        """
-        return self.context.get().workspace.datasets
-
-    def yield_datamodel(
-        self, dashboard_details: Group
-    ) -> Iterable[Either[CreateDashboardDataModelRequest]]:
+    def yield_dashboard(
+        self, dashboard_details: Union[PowerBIDashboard, PowerBIReport]
+    ) -> Iterable[Either[CreateDashboardRequest]]:
         """
-        Get All the Powerbi Datasets
+        Method to Get Dashboard Entity, Dashboard Charts & Lineage
         """
         try:
-            if self.source_config.includeDataModels:
-                for dataset in self._get_datamodels_list() or []:
-                    if filter_by_datamodel(
-                        self.source_config.dataModelFilterPattern, dataset.name
-                    ):
-                        self.status.filter(dataset.name, "Data model filtered out.")
-                        continue
-                    data_model_request = CreateDashboardDataModelRequest(
-                        name=EntityName(dataset.id),
-                        displayName=dataset.name,
-                        description=Markdown(dataset.description)
-                        if dataset.description
-                        else None,
-                        service=FullyQualifiedEntityName(
-                            self.context.get().dashboard_service
-                        ),
-                        dataModelType=DataModelType.PowerBIDataModel.value,
-                        serviceType=DashboardServiceType.PowerBI.value,
-                        columns=self._get_column_info(dataset),
-                        project=self.get_project_name(dashboard_details=dataset),
-                    )
-                    yield Either(right=data_model_request)
-                    self.register_record_datamodel(datamodel_request=data_model_request)
-        except Exception as exc:
+            if isinstance(dashboard_details, PowerBIDashboard):
+                dashboard_request = CreateDashboardRequest(
+                    name=EntityName(dashboard_details.id),
+                    sourceUrl=SourceUrl(
+                        self._get_dashboard_url(
+                            workspace_id=self.context.get().workspace.id,
+                            dashboard_id=dashboard_details.id,
+                        )
+                    ),
+                    project=self.get_project_name(dashboard_details=dashboard_details),
+                    displayName=dashboard_details.displayName,
+                    dashboardType=DashboardType.Dashboard,
+                    charts=[
+                        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=FullyQualifiedEntityName(
+                        self.context.get().dashboard_service
+                    ),
+                    owners=self.get_owner_ref(dashboard_details=dashboard_details),
+                )
+            else:
+                dashboard_request = CreateDashboardRequest(
+                    name=EntityName(dashboard_details.id),
+                    dashboardType=DashboardType.Report,
+                    sourceUrl=SourceUrl(
+                        self._get_report_url(
+                            workspace_id=self.context.get().workspace.id,
+                            dashboard_id=dashboard_details.id,
+                        )
+                    ),
+                    project=self.get_project_name(dashboard_details=dashboard_details),
+                    displayName=dashboard_details.name,
+                    service=self.context.get().dashboard_service,
+                    owners=self.get_owner_ref(dashboard_details=dashboard_details),
+                )
+            yield Either(right=dashboard_request)
+            self.register_record(dashboard_request=dashboard_request)
+        except Exception as exc:  # pylint: disable=broad-except
             yield Either(
                 left=StackTraceError(
-                    name=dataset.name,
-                    error=f"Error yielding Data Model [{dataset.name}]: {exc}",
+                    name=dashboard_details.name,
+                    error=f"Error creating dashboard [{dashboard_details}]: {exc}",
                     stackTrace=traceback.format_exc(),
                 )
             )
@@ -589,9 +532,7 @@ class PowerbiSource(DashboardServiceSource):
             )
 
     def create_datamodel_report_lineage(
-        self,
-        db_service_name: Optional[str],
-        dashboard_details: PowerBIReport,
+        self, db_service_name: str, dashboard_details: PowerBIReport
     ) -> Iterable[Either[CreateDashboardRequest]]:
         """
         create the lineage between datamodel and report
@@ -753,7 +694,7 @@ class PowerbiSource(DashboardServiceSource):
 
     def _get_table_and_datamodel_lineage(
         self,
-        db_service_name: Optional[str],
+        db_service_name: str,
         table: PowerBiTable,
         datamodel_entity: DashboardDataModel,
     ) -> Optional[Either[AddLineageRequest]]:
@@ -765,7 +706,7 @@ class PowerbiSource(DashboardServiceSource):
             table_fqn = fqn.build(
                 self.metadata,
                 entity_type=Table,
-                service_name=db_service_name or "*",
+                service_name=db_service_name,
                 database_name=table_info.get("database"),
                 schema_name=table_info.get("schema"),
                 table_name=table_info.get("table") or table.name,
@@ -774,6 +715,7 @@ class PowerbiSource(DashboardServiceSource):
                 entity=Table,
                 fqn=table_fqn,
             )
+
             if table_entity and datamodel_entity:
                 columns_list = [column.name for column in table.columns]
                 column_lineage = self._get_column_lineage(
@@ -799,7 +741,7 @@ class PowerbiSource(DashboardServiceSource):
 
     def create_table_datamodel_lineage_from_files(
         self,
-        db_service_name: Optional[str],
+        db_service_name: str,
         datamodel_entity: Optional[DashboardDataModel],
     ) -> Iterable[Either[AddLineageRequest]]:
         """
@@ -843,50 +785,80 @@ class PowerbiSource(DashboardServiceSource):
 
     def yield_dashboard_lineage_details(
         self,
-        dashboard_details: Group,
-        db_service_name: Optional[str] = None,
+        dashboard_details: Union[PowerBIDashboard, PowerBIReport],
+        db_service_name: str,
     ) -> Iterable[Either[AddLineageRequest]]:
         """
         We will build the logic to build the logic as below
         tables - datamodel - report - dashboard
         """
-        for dashboard in self.filtered_dashboards or []:
-            dashboard_details = self.get_dashboard_details(dashboard)
-            try:
-                if isinstance(dashboard_details, PowerBIReport):
-                    yield from self.create_datamodel_report_lineage(
-                        db_service_name=db_service_name,
-                        dashboard_details=dashboard_details,
-                    )
-                if isinstance(dashboard_details, PowerBIDashboard):
-                    yield from self.create_report_dashboard_lineage(
-                        dashboard_details=dashboard_details
-                    )
-            except Exception as exc:  # pylint: disable=broad-except
-                yield Either(
-                    left=StackTraceError(
-                        name="Dashboard Lineage",
-                        error=f"Error to yield dashboard lineage details for DB service name [{db_service_name}]: {exc}",
-                        stackTrace=traceback.format_exc(),
-                    )
+        try:
+            if isinstance(dashboard_details, PowerBIReport):
+                yield from self.create_datamodel_report_lineage(
+                    db_service_name=db_service_name, dashboard_details=dashboard_details
                 )
 
-    def yield_dashboard_lineage(
-        self, dashboard_details: Group
-    ) -> Iterable[Either[OMetaLineageRequest]]:
-        """
-        Yields lineage if config is enabled.
+            if isinstance(dashboard_details, PowerBIDashboard):
+                yield from self.create_report_dashboard_lineage(
+                    dashboard_details=dashboard_details
+                )
+
+        except Exception as exc:  # pylint: disable=broad-except
+            yield Either(
+                left=StackTraceError(
+                    name="Dashboard Lineage",
+                    error=f"Error to yield dashboard lineage details for DB service name [{db_service_name}]: {exc}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )
 
-        We will look for the data in all the services
-        we have informed.
+    def yield_dashboard_chart(
+        self, dashboard_details: Union[PowerBIDashboard, PowerBIReport]
+    ) -> Iterable[Either[CreateChartRequest]]:
+        """Get chart method
+        Args:
+            dashboard_details:
+        Returns:
+            Iterable[Chart]
         """
-        db_service_names = self.get_db_service_names()
-        if not db_service_names:
-            yield from self.yield_dashboard_lineage_details(dashboard_details) or []
-        for db_service_name in db_service_names or []:
-            yield from self.yield_dashboard_lineage_details(
-                dashboard_details, db_service_name
-            ) or []
+        if isinstance(dashboard_details, PowerBIDashboard):
+            charts = dashboard_details.tiles
+            for chart in charts or []:
+                try:
+                    chart_title = chart.title
+                    chart_display_name = chart_title if chart_title else chart.id
+                    if filter_by_chart(
+                        self.source_config.chartFilterPattern, chart_display_name
+                    ):
+                        self.status.filter(
+                            chart_display_name, "Chart Pattern not Allowed"
+                        )
+                        continue
+                    yield Either(
+                        right=CreateChartRequest(
+                            name=EntityName(chart.id),
+                            displayName=chart_display_name,
+                            chartType=ChartType.Other.value,
+                            sourceUrl=SourceUrl(
+                                self._get_chart_url(
+                                    report_id=chart.reportId,
+                                    workspace_id=self.context.get().workspace.id,
+                                    dashboard_id=dashboard_details.id,
+                                )
+                            ),
+                            service=FullyQualifiedEntityName(
+                                self.context.get().dashboard_service
+                            ),
+                        )
+                    )
+                except Exception as exc:
+                    yield Either(
+                        left=StackTraceError(
+                            name=chart.title,
+                            error=f"Error creating chart [{chart.title}]: {exc}",
+                            stackTrace=traceback.format_exc(),
+                        )
+                    )
 
     def _fetch_dataset_from_workspace(
         self, dataset_id: Optional[str]
@@ -928,6 +900,21 @@ class PowerbiSource(DashboardServiceSource):
                     return report_data
         return None
 
+    def _fetch_dataset_workspace(self, dataset_id: Optional[str]) -> Optional[str]:
+        """
+        Method to search the workspace name in which the dataset in contained
+        """
+        if dataset_id:
+            workspace_names = (
+                workspace.name
+                for workspace in self.workspace_data
+                for dataset in workspace.datasets
+                if dataset.id == dataset_id
+            )
+            return next(iter(workspace_names), None)
+
+        return None
+
     def get_project_name(self, dashboard_details: Any) -> Optional[str]:
         """
         Get the project / workspace / folder / collection name of the dashboard