openmetadata-ingestion 1.6.7.1__py3-none-any.whl → 1.7.0.0rc1__py3-none-any.whl

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

@@ -13,7 +13,7 @@ REST Auth & Client for Metabase
 """
 import json
 import traceback
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import requests
 
@@ -23,6 +23,7 @@ from metadata.generated.schema.entity.services.connections.dashboard.metabaseCon
 from metadata.ingestion.connections.test_connections import SourceConnectionException
 from metadata.ingestion.ometa.client import REST, ClientConfig
 from metadata.ingestion.source.dashboard.metabase.models import (
+    MetabaseChart,
     MetabaseCollection,
     MetabaseCollectionList,
     MetabaseDashboard,
@@ -32,7 +33,11 @@ from metadata.ingestion.source.dashboard.metabase.models import (
     MetabaseTable,
     MetabaseUser,
 )
-from metadata.utils.constants import AUTHORIZATION_HEADER, NO_ACCESS_TOKEN
+from metadata.utils.constants import (
+    AUTHORIZATION_HEADER,
+    DEFAULT_DASHBAORD,
+    NO_ACCESS_TOKEN,
+)
 from metadata.utils.helpers import clean_uri
 from metadata.utils.logger import ingestion_logger
 
@@ -146,22 +151,76 @@ class MetabaseClient:
             logger.warning("Failed to fetch the collections list")
         return []
 
+    def get_charts_dict(self) -> Dict:
+        charts_dict = {}
+        try:
+            resp_charts = self.client.get("/card")
+            if resp_charts:
+                for chart_data in resp_charts:
+                    chart = MetabaseChart.model_validate(chart_data)
+                    charts_dict[chart.id] = chart
+            return charts_dict
+        except Exception:
+            logger.debug(traceback.format_exc())
+            logger.warning("Failed to fetch the cards")
+        return {}
+
+    def _create_default_dashboard_details(
+        self, orphan_charts_id: List
+    ) -> MetabaseDashboardDetails:
+        """
+        Returns:
+            MetabaseDashboardDetails object representing the default dashboard containing orphaned charts
+        """
+        return MetabaseDashboardDetails(
+            id=DEFAULT_DASHBAORD,
+            card_ids=orphan_charts_id,
+        )
+
+    def _process_dashboard_response(
+        self, resp_dashboard: Dict, charts_dict: Dict, dashboard_id: str
+    ) -> MetabaseDashboardDetails:
+        """
+        Process dashboard response and create MetabaseDashboardDetails object
+        """
+        if "ordered_cards" in resp_dashboard:
+            resp_dashboard["dashcards"] = resp_dashboard["ordered_cards"]
+
+        card_ids = []
+        for card in resp_dashboard.get("dashcards", []):
+            if card.get("card") and card["card"].get("id"):
+                card_id = str(card["card"]["id"])
+                card_ids.append(card_id)
+                if card_id in charts_dict:
+                    charts_dict[card_id].dashboard_ids.append(dashboard_id)
+
+        return MetabaseDashboardDetails(
+            description=resp_dashboard.get("description"),
+            name=resp_dashboard.get("name"),
+            id=resp_dashboard.get("id"),
+            creator_id=resp_dashboard.get("creator_id"),
+            collection_id=resp_dashboard.get("collection_id"),
+            card_ids=card_ids,
+        )
+
     def get_dashboard_details(
-        self, dashboard_id: str
+        self, dashboard_id: str, charts_dict: Dict, orphan_charts_id: List
     ) -> Optional[MetabaseDashboardDetails]:
         """
         Get Dashboard Details
         """
         if not dashboard_id:
             return None  # don't call api if dashboard_id is None
+        if dashboard_id == DEFAULT_DASHBAORD:
+            return self._create_default_dashboard_details(orphan_charts_id)
         try:
             resp_dashboard = self.client.get(f"/dashboard/{dashboard_id}")
             if resp_dashboard:
                 # Small hack needed to support Metabase versions older than 0.48
                 # https://www.metabase.com/releases/metabase-48#fyi--breaking-changes
-                if "ordered_cards" in resp_dashboard:
-                    resp_dashboard["dashcards"] = resp_dashboard["ordered_cards"]
-                return MetabaseDashboardDetails(**resp_dashboard)
+                return self._process_dashboard_response(
+                    resp_dashboard, charts_dict, dashboard_id
+                )
         except Exception:
             logger.debug(traceback.format_exc())
             logger.warning(f"Failed to fetch the dashboard with id: {dashboard_id}")

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

@@ -11,7 +11,7 @@
 """Metabase source module"""
 
 import traceback
-from typing import Any, Iterable, List, Optional
+from typing import Any, Dict, Iterable, List, Optional
 
 from metadata.generated.schema.api.data.createChart import CreateChartRequest
 from metadata.generated.schema.api.data.createDashboard import CreateDashboardRequest
@@ -20,6 +20,7 @@ from metadata.generated.schema.entity.data.chart import Chart
 from metadata.generated.schema.entity.data.dashboard import (
     Dashboard as LineageDashboard,
 )
+from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.connections.dashboard.metabaseConnection import (
     MetabaseConnection,
 )
@@ -42,9 +43,8 @@ from metadata.generated.schema.type.basic import (
 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
+from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper, Dialect
 from metadata.ingestion.lineage.parser import LineageParser
-from metadata.ingestion.lineage.sql_lineage import search_table_entities
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.dashboard.dashboard_service import DashboardServiceSource
 from metadata.ingestion.source.dashboard.metabase.models import (
@@ -54,7 +54,9 @@ from metadata.ingestion.source.dashboard.metabase.models import (
     MetabaseDashboardDetails,
 )
 from metadata.utils import fqn
+from metadata.utils.constants import DEFAULT_DASHBAORD
 from metadata.utils.filters import filter_by_chart
+from metadata.utils.fqn import build_es_fqn_search_string
 from metadata.utils.helpers import (
     clean_uri,
     get_standard_chart_type,
@@ -92,16 +94,22 @@ class MetabaseSource(DashboardServiceSource):
     ):
         super().__init__(config, metadata)
         self.collections: List[MetabaseCollection] = []
+        self.dashboards_list: List[MetabaseDashboard] = []
+        self.charts_dict: Dict[str] = {}
+        self.orphan_charts_id: List[str] = []
+        self._default_dashboard_added = False
 
     def prepare(self):
         self.collections = self.client.get_collections_list()
+        self.charts_dict = self.client.get_charts_dict()
         return super().prepare()
 
     def get_dashboards_list(self) -> Optional[List[MetabaseDashboard]]:
         """
         Get List of all dashboards
         """
-        return self.client.get_dashboards_list(self.collections)
+        self.dashboards_list = self.client.get_dashboards_list(self.collections)
+        return self.dashboards_list
 
     def get_dashboard_name(self, dashboard: MetabaseDashboard) -> str:
         """
@@ -115,13 +123,39 @@ class MetabaseSource(DashboardServiceSource):
         """
         Get Dashboard Details
         """
-        return self.client.get_dashboard_details(dashboard.id)
+        retrieved_dashboards = self.client.get_dashboard_details(
+            dashboard.id, self.charts_dict, self.orphan_charts_id
+        )
+        if (
+            retrieved_dashboards
+            and dashboard == self.dashboards_list[-1]
+            and not self._default_dashboard_added
+        ):
+            # If processing the last dashboard, identify any orphaned charts (not associated with dashboards)
+            # and create a default dashboard to maintain visibility of these charts
+            self.orphan_charts_id = [
+                chart_id
+                for chart_id, chart in self.charts_dict.items()
+                if not chart.dashboard_ids
+            ]
+            if self.orphan_charts_id:
+                # add the default dashboard to the dashboards list
+                default_dashboard = MetabaseDashboard(
+                    name=DEFAULT_DASHBAORD,
+                    id=DEFAULT_DASHBAORD,
+                )
+                self.dashboards_list.append(default_dashboard)
+                self._default_dashboard_added = True
+        return retrieved_dashboards
 
     def get_project_name(self, dashboard_details: Any) -> Optional[str]:
         """
         Method to get the project name by searching the dataset using id in the workspace dict
         """
         try:
+            # Return default for the default dashboard containing orphaned charts
+            if dashboard_details.id == DEFAULT_DASHBAORD:
+                return DEFAULT_DASHBAORD
             if dashboard_details.collection_id:
                 collection_name = next(
                     (
@@ -164,10 +198,14 @@ class MetabaseSource(DashboardServiceSource):
         Method to Get Dashboard Entity
         """
         try:
+            # dashboard_url to be empty for default dashboard
             dashboard_url = (
-                f"{clean_uri(self.service_connection.hostPort)}/dashboard/{dashboard_details.id}-"
+                ""
+                if dashboard_details.id == DEFAULT_DASHBAORD
+                else f"{clean_uri(self.service_connection.hostPort)}/dashboard/{dashboard_details.id}-"
                 f"{replace_special_with(raw=dashboard_details.name.lower(), replacement='-')}"
             )
+
             dashboard_request = CreateDashboardRequest(
                 name=EntityName(str(dashboard_details.id)),
                 sourceUrl=SourceUrl(dashboard_url),
@@ -211,10 +249,10 @@ class MetabaseSource(DashboardServiceSource):
         Returns:
             Iterable[CreateChartRequest]
         """
-        charts = dashboard_details.dashcards
-        for chart in charts:
+        chart_ids = dashboard_details.card_ids
+        for chart_id in chart_ids:
             try:
-                chart_details = chart.card
+                chart_details = self.charts_dict[chart_id]
                 if not chart_details.id or not chart_details.name:
                     continue
                 chart_url = (
@@ -240,7 +278,7 @@ class MetabaseSource(DashboardServiceSource):
                 yield Either(
                     left=StackTraceError(
                         name="Chart",
-                        error=f"Error creating chart [{chart}]: {exc}",
+                        error=f"Error creating chart [{self.charts_dict[chart_id]}]: {exc}",
                         stackTrace=traceback.format_exc(),
                     )
                 )
@@ -248,22 +286,20 @@ class MetabaseSource(DashboardServiceSource):
     def yield_dashboard_lineage_details(
         self,
         dashboard_details: MetabaseDashboardDetails,
-        db_service_name: Optional[str],
+        db_service_name: Optional[str] = None,
     ) -> Iterable[Either[AddLineageRequest]]:
         """Get lineage method
 
         Args:
             dashboard_details
         """
-        if not db_service_name:
-            return
-        chart_list, dashboard_name = (
-            dashboard_details.dashcards,
+        chart_ids, dashboard_name = (
+            dashboard_details.card_ids,
             str(dashboard_details.id),
         )
-        for chart in chart_list:
+        for chart_id in chart_ids:
             try:
-                chart_details = chart.card
+                chart_details = self.charts_dict[chart_id]
                 if (
                     chart_details.dataset_query is None
                     or chart_details.dataset_query.type is None
@@ -296,11 +332,17 @@ class MetabaseSource(DashboardServiceSource):
                     )
                 )
 
-    def _get_database_service(self, db_service_name: str):
+    def _get_database_service(self, db_service_name: Optional[str]):
+        if not db_service_name:
+            return None
         return self.metadata.get_by_name(DatabaseService, db_service_name)
 
+    # pylint: disable=too-many-locals
     def _yield_lineage_from_query(
-        self, chart_details: MetabaseChart, db_service_name: str, dashboard_name: str
+        self,
+        chart_details: MetabaseChart,
+        db_service_name: Optional[str],
+        dashboard_name: str,
     ) -> Iterable[Either[AddLineageRequest]]:
         database = self.client.get_database(chart_details.database_id)
 
@@ -323,20 +365,23 @@ class MetabaseSource(DashboardServiceSource):
             query,
             ConnectionTypeDialectMapper.dialect_of(db_service.serviceType.value)
             if db_service
-            else None,
+            else Dialect.ANSI,
         )
 
         for table in lineage_parser.source_tables:
             database_schema_name, table = fqn.split(str(table))[-2:]
             database_schema_name = self.check_database_schema_name(database_schema_name)
-            from_entities = search_table_entities(
-                metadata=self.metadata,
-                database=database_name,
-                service_name=db_service_name,
-                database_schema=database_schema_name,
-                table=table,
+            fqn_search_string = build_es_fqn_search_string(
+                database_name=database_name,
+                schema_name=database_schema_name,
+                service_name=db_service_name or "*",
+                table_name=table,
+            )
+            from_entities = self.metadata.search_in_any_service(
+                entity_type=Table,
+                fqn_search_string=fqn_search_string,
+                fetch_multiple_entities=True,
             )
-
             to_fqn = fqn.build(
                 self.metadata,
                 entity_type=LineageDashboard,
@@ -348,13 +393,16 @@ class MetabaseSource(DashboardServiceSource):
                 fqn=to_fqn,
             )
 
-            for from_entity in from_entities:
+            for from_entity in from_entities or []:
                 yield self._get_add_lineage_request(
                     to_entity=to_entity, from_entity=from_entity
                 )
 
     def _yield_lineage_from_api(
-        self, chart_details: MetabaseChart, db_service_name: str, dashboard_name: str
+        self,
+        chart_details: MetabaseChart,
+        db_service_name: Optional[str],
+        dashboard_name: str,
     ) -> Iterable[Either[AddLineageRequest]]:
         table = self.client.get_table(chart_details.table_id)
         table_name = table.name or table.display_name
@@ -363,14 +411,17 @@ class MetabaseSource(DashboardServiceSource):
             return
 
         database_name = table.db.details.db if table.db and table.db.details else None
-        from_entities = search_table_entities(
-            metadata=self.metadata,
-            database=database_name,
-            service_name=db_service_name,
-            database_schema=table.table_schema,
-            table=table_name,
+        fqn_search_string = build_es_fqn_search_string(
+            database_name=database_name,
+            schema_name=table.table_schema,
+            service_name=db_service_name or "*",
+            table_name=table_name,
+        )
+        from_entities = self.metadata.search_in_any_service(
+            entity_type=Table,
+            fqn_search_string=fqn_search_string,
+            fetch_multiple_entities=True,
         )
-
         to_fqn = fqn.build(
             self.metadata,
             entity_type=LineageDashboard,
@@ -383,7 +434,7 @@ class MetabaseSource(DashboardServiceSource):
             fqn=to_fqn,
         )
 
-        for from_entity in from_entities:
+        for from_entity in from_entities or []:
             yield self._get_add_lineage_request(
                 to_entity=to_entity, from_entity=from_entity
             )

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

@@ -82,6 +82,7 @@ class MetabaseChart(BaseModel):
     dataset_query: Optional[DatasetQuery] = None
     id: Optional[MetabaseStrId] = None
     display: Optional[str] = None
+    dashboard_ids: List[str] = []
 
 
 class DashCard(BaseModel):
@@ -94,7 +95,7 @@ class MetabaseDashboardDetails(BaseModel):
     """
 
     description: Optional[str] = None
-    dashcards: List[DashCard]
+    card_ids: List[str] = []
     name: Optional[str] = None
     id: MetabaseStrId
     creator_id: Optional[MetabaseStrId] = None

metadata/ingestion/source/dashboard/microstrategy/metadata.py

@@ -159,7 +159,9 @@ class MicrostrategySource(DashboardServiceSource):
                 )
 
     def yield_dashboard_lineage_details(
-        self, dashboard_details: MstrDashboardDetails, db_service_name: str
+        self,
+        dashboard_details: MstrDashboardDetails,
+        db_service_name: Optional[str] = None,
     ) -> Optional[Iterable[AddLineageRequest]]:
         """Not Implemented"""
 

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

@@ -20,6 +20,7 @@ from metadata.generated.schema.entity.data.chart import Chart, ChartType
 from metadata.generated.schema.entity.data.dashboard import (
     Dashboard as Lineage_Dashboard,
 )
+from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.connections.dashboard.modeConnection import (
     ModeConnection,
 )
@@ -38,12 +39,12 @@ from metadata.generated.schema.type.basic import (
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.lineage.parser import LineageParser
-from metadata.ingestion.lineage.sql_lineage import search_table_entities
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.dashboard.dashboard_service import DashboardServiceSource
 from metadata.ingestion.source.dashboard.mode import client
 from metadata.utils import fqn
 from metadata.utils.filters import filter_by_chart
+from metadata.utils.fqn import build_es_fqn_search_string
 from metadata.utils.helpers import clean_uri
 from metadata.utils.logger import ingestion_logger
 
@@ -130,7 +131,9 @@ class ModeSource(DashboardServiceSource):
         self.register_record(dashboard_request=dashboard_request)
 
     def yield_dashboard_lineage_details(
-        self, dashboard_details: dict, db_service_name: str
+        self,
+        dashboard_details: dict,
+        db_service_name: Optional[str] = None,
     ) -> Iterable[Either[AddLineageRequest]]:
         """Get lineage method"""
         try:
@@ -151,14 +154,18 @@ class ModeSource(DashboardServiceSource):
                     database_schema_name = self.check_database_schema_name(
                         database_schema_name
                     )
-                    from_entities = search_table_entities(
-                        metadata=self.metadata,
-                        database=data_source.get(client.DATABASE),
-                        service_name=db_service_name,
-                        database_schema=database_schema_name,
-                        table=table,
+                    fqn_search_string = build_es_fqn_search_string(
+                        database_name=data_source.get(client.DATABASE),
+                        schema_name=database_schema_name,
+                        service_name=db_service_name or "*",
+                        table_name=table,
+                    )
+                    from_entities = self.metadata.search_in_any_service(
+                        entity_type=Table,
+                        fqn_search_string=fqn_search_string,
+                        fetch_multiple_entities=True,
                     )
-                    for from_entity in from_entities:
+                    for from_entity in from_entities or []:
                         to_entity = self.metadata.get_by_name(
                             entity=Lineage_Dashboard,
                             fqn=fqn.build(

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

@@ -14,7 +14,6 @@ REST Auth & Client for PowerBi
 import json
 import math
 import traceback
-from copy import deepcopy
 from time import sleep
 from typing import List, Optional, Tuple
 
@@ -350,13 +349,7 @@ class PowerBiApiClient:
             api_url = f"/myorg/{admin}groups"
             entities_per_page = self.pagination_entity_per_page
             failed_indexes = []
-            parsed_filter_query = None
-            if filter_pattern:
-                parsed_filter_query = self.create_filter_query(filter_pattern)
-                logger.debug(f"Filter query applied = {parsed_filter_query}")
-            params_data = deepcopy(GETGROUPS_DEFAULT_PARAMS)
-            if parsed_filter_query:
-                params_data["$filter"] = parsed_filter_query
+            params_data = GETGROUPS_DEFAULT_PARAMS
             response = self.client.get(api_url, data=params_data)
             if (
                 not response
@@ -379,18 +372,14 @@ class PowerBiApiClient:
                     logger.warning(f"Error processing GetGroups response: {exc}")
                     count = 0
             indexes = math.ceil(count / entities_per_page)
-            logger.debug(
-                f"Total {count} workspaces found, Will run {indexes} iterations fetching"
-                f" maximum {entities_per_page} workspaces in a single iteration"
-            )
             workspaces = []
             for index in range(indexes):
                 params_data = {
                     "$top": str(entities_per_page),
                     "$skip": str(index * entities_per_page),
                 }
-                if parsed_filter_query:
-                    params_data["$filter"] = parsed_filter_query
+                if filter_pattern:
+                    params_data["$filter"] = self.create_filter_query(filter_pattern)
 
                 response = self.client.get(api_url, data=params_data)
                 if (

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

@@ -14,9 +14,6 @@ import re
 import traceback
 from typing import Any, Iterable, List, Optional, Union
 
-from pydantic import EmailStr
-from pydantic_core import PydanticCustomError
-
 from metadata.generated.schema.api.data.createChart import CreateChartRequest
 from metadata.generated.schema.api.data.createDashboard import CreateDashboardRequest
 from metadata.generated.schema.api.data.createDashboardDataModel import (
@@ -51,7 +48,6 @@ from metadata.generated.schema.type.basic import (
     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.models.ometa_lineage import OMetaLineageRequest
@@ -73,6 +69,7 @@ from metadata.utils.filters import (
     filter_by_dashboard,
     filter_by_datamodel,
 )
+from metadata.utils.fqn import build_es_fqn_search_string
 from metadata.utils.helpers import clean_uri
 from metadata.utils.logger import ingestion_logger
 
@@ -491,7 +488,6 @@ class PowerbiSource(DashboardServiceSource):
                     "name": table.name,
                     "displayName": table.name,
                     "description": table.description,
-                    "children": [],
                 }
                 child_columns = self._get_child_columns(table=table)
                 child_measures = self._get_child_measures(table=table)
@@ -538,7 +534,6 @@ class PowerbiSource(DashboardServiceSource):
                         serviceType=DashboardServiceType.PowerBI.value,
                         columns=self._get_column_info(dataset),
                         project=self.get_project_name(dashboard_details=dataset),
-                        owners=self.get_owner_ref(dashboard_details=dataset),
                     )
                     yield Either(right=data_model_request)
                     self.register_record_datamodel(datamodel_request=data_model_request)
@@ -768,17 +763,15 @@ class PowerbiSource(DashboardServiceSource):
         """
         try:
             table_info = self._parse_table_info_from_source_exp(table)
-            table_fqn = fqn.build(
-                self.metadata,
-                entity_type=Table,
-                service_name=db_service_name or "*",
+            fqn_search_string = build_es_fqn_search_string(
                 database_name=table_info.get("database"),
                 schema_name=table_info.get("schema"),
+                service_name=db_service_name or "*",
                 table_name=table_info.get("table") or table.name,
             )
-            table_entity = self.metadata.get_by_name(
-                entity=Table,
-                fqn=table_fqn,
+            table_entity = self.metadata.search_in_any_service(
+                entity_type=Table,
+                fqn_search_string=fqn_search_string,
             )
             if table_entity and datamodel_entity:
                 columns_list = [column.name for column in table.columns]
@@ -946,44 +939,3 @@ class PowerbiSource(DashboardServiceSource):
                 f"Error fetching project name for {dashboard_details.id}: {exc}"
             )
         return None
-
-    def get_owner_ref(  # pylint: disable=unused-argument, useless-return
-        self, dashboard_details: Any
-    ) -> Optional[EntityReferenceList]:
-        """
-        Method to process the dashboard owners
-        """
-        try:
-            owner_ref_list = []  # to assign multiple owners to entity if they exist
-            for owner in dashboard_details.users or []:
-                if owner.email:
-                    owner_ref = None
-                    try:
-                        owner_email = EmailStr._validate(owner.email)
-                        owner_ref = self.metadata.get_reference_by_email(
-                            owner_email.lower()
-                        )
-                    except PydanticCustomError:
-                        logger.warning(
-                            f"Could not fetch owner data for email: {owner.email}"
-                        )
-                        if owner.displayName:
-                            owner_ref = self.metadata.get_reference_by_name(
-                                name=owner.displayName
-                            )
-                    except Exception as err:
-                        logger.warning(
-                            f"Error processing current owner data in {dashboard_details.id}: {err}"
-                        )
-                    if owner_ref:
-                        owner_ref_list.append(owner_ref.root[0])
-            if len(owner_ref_list) > 0:
-                logger.debug(
-                    f"Successfully fetched owners data for {dashboard_details.id}"
-                )
-                return EntityReferenceList(root=owner_ref_list)
-            return None
-        except Exception as err:
-            logger.debug(traceback.format_exc())
-            logger.warning(f"Could not fetch owner data due to {err}")
-        return None

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

@@ -32,15 +32,6 @@ class Tile(BaseModel):
     reportId: Optional[str] = None
 
 
-class PowerBIUser(BaseModel):
-    """
-    PowerBI User Model
-    """
-
-    displayName: Optional[str] = None
-    email: Optional[str] = Field(alias="emailAddress", default=None)
-
-
 class PowerBIDashboard(BaseModel):
     """
     PowerBI PowerBIDashboard Model
@@ -52,7 +43,6 @@ class PowerBIDashboard(BaseModel):
     webUrl: Optional[str] = None
     embedUrl: Optional[str] = None
     tiles: Optional[List[Tile]] = []
-    users: Optional[List[PowerBIUser]] = []
 
 
 class PowerBIReport(BaseModel):
@@ -64,7 +54,6 @@ class PowerBIReport(BaseModel):
     id: str
     name: str
     datasetId: Optional[str] = None
-    users: Optional[List[PowerBIUser]] = []
 
 
 class DashboardsResponse(BaseModel):
@@ -173,7 +162,6 @@ class Dataset(BaseModel):
     name: str
     tables: Optional[List[PowerBiTable]] = []
     description: Optional[str] = None
-    users: Optional[List[PowerBIUser]] = []
 
 
 class DatasetResponse(BaseModel):