openmetadata-ingestion 1.2.4.0__py3-none-any.whl → 1.3.2.0rc1__py3-none-any.whl

metadata/ingestion/source/dashboard/superset/db_source.py

@@ -15,7 +15,6 @@ Superset source module
 import traceback
 from typing import Iterable, Optional
 
-from sqlalchemy import sql
 from sqlalchemy.engine import Engine
 from sqlalchemy.engine.url import make_url
 
@@ -28,10 +27,13 @@ from metadata.generated.schema.entity.data.chart import Chart
 from metadata.generated.schema.entity.data.dashboardDataModel import DataModelType
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.databaseService import DatabaseService
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
-from metadata.ingestion.api.models import Either, StackTraceError
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.dashboard.superset.mixin import SupersetSourceMixin
 from metadata.ingestion.source.dashboard.superset.models import (
@@ -83,8 +85,9 @@ class SupersetDBSource(SupersetSourceMixin):
     def get_column_list(self, table_name: str) -> Iterable[FetchChart]:
         try:
             if table_name:
-                sql_query = sql.text(FETCH_COLUMN.format(table_name=table_name.lower()))
-                col_list = self.engine.execute(sql_query)
+                col_list = self.engine.execute(
+                    FETCH_COLUMN, table_name=table_name.lower()
+                )
                 return [FetchColumn(**col) for col in col_list]
         except Exception as err:
             logger.debug(traceback.format_exc())
@@ -117,9 +120,10 @@ class SupersetDBSource(SupersetSourceMixin):
                         service_name=self.context.dashboard_service,
                         chart_name=chart,
                     )
-                    for chart in self.context.charts
+                    for chart in self.context.charts or []
                 ],
                 service=self.context.dashboard_service,
+                owner=self.get_owner_ref(dashboard_details=dashboard_details),
             )
             yield Either(right=dashboard_request)
             self.register_record(dashboard_request=dashboard_request)
@@ -131,7 +135,7 @@ class SupersetDBSource(SupersetSourceMixin):
                         f"Error yielding Dashboard [{dashboard_details.id} "
                         f"- {dashboard_details.dashboard_title}]: {exc}"
                     ),
-                    stack_trace=traceback.format_exc(),
+                    stackTrace=traceback.format_exc(),
                 )
             )
 
@@ -173,7 +177,7 @@ class SupersetDBSource(SupersetSourceMixin):
                     left=StackTraceError(
                         name=chart_json.id,
                         error=f"Error yielding Chart [{chart_json.id} - {chart_json.slice_name}]: {exc}",
-                        stack_trace=traceback.format_exc(),
+                        stackTrace=traceback.format_exc(),
                     )
                 )
 
@@ -211,11 +215,10 @@ class SupersetDBSource(SupersetSourceMixin):
     def yield_datamodel(
         self, dashboard_details: FetchDashboard
     ) -> Iterable[Either[CreateDashboardDataModelRequest]]:
-
         if self.source_config.includeDataModels:
             for chart_id in self._get_charts_of_dashboard(dashboard_details):
                 chart_json = self.all_charts.get(chart_id)
-                if not chart_json:
+                if not chart_json or not chart_json.datasource_id:
                     logger.warning(
                         f"chart details for id: {chart_id} not found, skipped"
                     )
@@ -236,13 +239,13 @@ class SupersetDBSource(SupersetSourceMixin):
                         dataModelType=DataModelType.SupersetDataModel.value,
                     )
                     yield Either(right=data_model_request)
-                    self.register_record_datamodel(datamodel_requst=data_model_request)
+                    self.register_record_datamodel(datamodel_request=data_model_request)
 
                 except Exception as exc:
                     yield Either(
                         left=StackTraceError(
                             name=chart_json.table_name,
                             error=f"Error yielding Data Model [{chart_json.table_name}]: {exc}",
-                            stack_trace=traceback.format_exc(),
+                            stackTrace=traceback.format_exc(),
                         )
                     )

metadata/ingestion/source/dashboard/superset/mixin.py

@@ -28,11 +28,14 @@ from metadata.generated.schema.entity.services.dashboardService import (
     DashboardServiceType,
 )
 from metadata.generated.schema.entity.services.databaseService import DatabaseService
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
 from metadata.generated.schema.type.entityReference import EntityReference
-from metadata.ingestion.api.models import Either, StackTraceError
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.dashboard.dashboard_service import DashboardServiceSource
@@ -94,25 +97,26 @@ class SupersetSourceMixin(DashboardServiceSource):
 
     def _get_user_by_email(self, email: Optional[str]) -> Optional[EntityReference]:
         if email:
-            user = self.metadata.get_user_by_email(email)
-            if user:
-                return EntityReference(id=user.id.__root__, type="user")
-
+            return self.metadata.get_reference_by_email(email)
         return None
 
-    def get_owner_details(
+    def get_owner_ref(
         self, dashboard_details: Union[DashboardResult, FetchDashboard]
     ) -> EntityReference:
-        if hasattr(dashboard_details, "owner"):
-            for owner in dashboard_details.owners or []:
-                if owner.email:
-                    user = self._get_user_by_email(owner.email)
-                    if user:
-                        return user
-        if dashboard_details.email:
-            user = self._get_user_by_email(dashboard_details.email)
-            if user:
-                return user
+        try:
+            if hasattr(dashboard_details, "owners"):
+                for owner in dashboard_details.owners or []:
+                    if owner.email:
+                        user = self._get_user_by_email(owner.email)
+                        if user:
+                            return user
+            if dashboard_details.email:
+                user = self._get_user_by_email(dashboard_details.email)
+                if user:
+                    return user
+        except Exception as err:
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Could not fetch owner data due to {err}")
         return None
 
     def _get_charts_of_dashboard(
@@ -185,7 +189,7 @@ class SupersetSourceMixin(DashboardServiceSource):
                                     "Error to yield dashboard lineage details for DB "
                                     f"service name [{db_service_name}]: {exc}"
                                 ),
-                                stack_trace=traceback.format_exc(),
+                                stackTrace=traceback.format_exc(),
                             )
                         )
 
@@ -230,7 +234,7 @@ class SupersetSourceMixin(DashboardServiceSource):
                         name=field.id,
                         displayName=field.column_name,
                         description=field.description,
-                        dataLength=col_parse.get("dataLength", 0),
+                        dataLength=int(col_parse.get("dataLength", 0)),
                     )
                     datasource_columns.append(parsed_fields)
             except Exception as exc:

metadata/ingestion/source/dashboard/superset/queries.py

@@ -85,5 +85,5 @@ inner join
 on 
 	t.id=tc.table_id  
 where 
-	table_name= '{table_name}'
+	table_name=%(table_name)s
 """

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

@@ -15,7 +15,9 @@ import math
 import traceback
 from typing import Any, Callable, Dict, List, Optional
 
+import validators
 from cached_property import cached_property
+from packaging import version
 from tableau_api_lib import TableauServerConnection
 from tableau_api_lib.utils import extract_pages
 
@@ -60,20 +62,22 @@ class TableauClient:
 
     def __init__(
         self,
-        config: Dict[str, Dict[str, Any]],
+        tableau_server_config: Dict[str, Dict[str, Any]],
+        config,
         env: str,
         ssl_verify: bool,
         pagination_limit: int,
     ):
         # ssl_verify is typed as a `bool` in TableauServerConnection
         # However, it is passed as `verify=self.ssl_verify` in each `requests` call.
-        # In requests (https://requests.readthedocs.io/en/latest/user/advanced/#ssl-cert-verification)
+        # In requests (https://requests.readthedocs.io/en/latest/user/advanced.html?highlight=ssl#ssl-cert-verification)
         # the param can be None, False to ignore HTTPS certs or a string with the path to the cert.
         self._client = TableauServerConnection(
-            config_json=config,
+            config_json=tableau_server_config,
             env=env,
             ssl_verify=ssl_verify,
         )
+        self.config = config
         self._client.sign_in().json()
         self.pagination_limit = pagination_limit
 
@@ -81,6 +85,10 @@ class TableauClient:
     def server_info(self) -> Callable:
         return self._client.server_info
 
+    @property
+    def server_api_version(self) -> str:
+        return self.server_info().json()["serverInfo"]["restApiVersion"]
+
     @property
     def site_id(self) -> str:
         return self._client.site_id
@@ -122,11 +130,79 @@ class TableauClient:
             )
         ]
 
+    def get_workbook_charts(self, dashboard_id: str) -> Optional[List[TableauChart]]:
+        """
+        Get the charts for a workbook
+        """
+        try:
+            return [
+                TableauChart(**chart)
+                for chart in self._client.query_views_for_workbook(
+                    workbook_id=dashboard_id,
+                    parameter_dict=TABLEAU_GET_VIEWS_PARAM_DICT,
+                ).json()["views"]["view"]
+            ]
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Error processing charts for dashboard [{dashboard_id}]: {exc}"
+            )
+        return None
+
+    def test_api_version(self):
+        """
+        Method to validate the declared v/s server tableau rest api version
+        """
+        server_api_version = version.parse(self.server_api_version)
+        declared_api_version = version.parse(self.config.apiVersion)
+        if declared_api_version > server_api_version:
+            raise ValueError(
+                f"""
+            Your API version of '{declared_api_version}' is too damn high!
+            The server you are establishing a connection with is using REST API version '{server_api_version}'.
+            """
+            )
+        if declared_api_version < server_api_version:
+            raise ValueError(
+                f"""
+            The Tableau Server REST API version you specified is lower than the version your server uses.
+            Your Tableau Server is on REST API version {server_api_version}.
+            The REST API version you specified is {declared_api_version}.
+            For optimal results, please change the 'api_version' config variable to {server_api_version}.
+            """
+            )
+
+    def test_site_url(self):
+        """
+        Method to test the site url and site name fields
+        """
+        validation = validators.url(self.config.siteUrl)
+        if validation:
+            raise ValueError(
+                f"""
+            The site url "{self.config.siteUrl}" is in incorrect format.
+            If "https://xxx.tableau.com/#/site/MarketingTeam/home" represents the homepage url for your tableau site,
+            the "MarketingTeam" from the url should be entered in the Site Name and Site Url fields.
+            """
+            )
+        return True
+
     def test_get_datamodels(self):
         """
         Method to test the datamodels
         """
-        data = self._query_datasources(entities_per_page=1, offset=0)
+        workbooks = self.get_workbooks()
+
+        if len(workbooks) == 0:
+            raise TableauDataModelsException(
+                "Unable to get any workbooks to fetch tableau data sources"
+            )
+
+        # Take the 1st workbook's id and pass to the graphql query
+        test_workbook = workbooks[0]
+        data = self._query_datasources(
+            dashboard_id=test_workbook.id, entities_per_page=1, offset=0
+        )
         if data:
             return data
         raise TableauDataModelsException(
@@ -138,7 +214,7 @@ class TableauClient:
         )
 
     def _query_datasources(
-        self, entities_per_page: int, offset: int
+        self, dashboard_id: str, entities_per_page: int, offset: int
     ) -> Optional[TableauDatasources]:
         """
         Method to query the graphql endpoint to get data sources
@@ -146,14 +222,14 @@ class TableauClient:
         try:
             datasources_graphql_result = self._client.metadata_graphql_query(
                 query=TABLEAU_DATASOURCES_QUERY.format(
-                    first=entities_per_page, offset=offset
+                    workbook_id=dashboard_id, first=entities_per_page, offset=offset
                 )
             )
             if datasources_graphql_result:
                 resp = datasources_graphql_result.json()
                 if resp and resp.get("data"):
                     tableau_datasource_connection = TableauDatasourcesConnection(
-                        **resp.get("data")
+                        **resp["data"]["workbooks"][0]
                     )
                     return tableau_datasource_connection.embeddedDatasourcesConnection
         except Exception:
@@ -167,13 +243,15 @@ class TableauClient:
             )
         return None
 
-    def get_datasources(self) -> Optional[List[DataSource]]:
+    def get_datasources(self, dashboard_id: str) -> Optional[List[DataSource]]:
         """
-        Paginate and get the list of all data sources
+        Paginate and get the list of all data sources of the workbook
         """
         try:
             # Query the graphql endpoint once to get total count of data sources
-            tableau_datasource = self._query_datasources(entities_per_page=1, offset=1)
+            tableau_datasource = self._query_datasources(
+                dashboard_id=dashboard_id, entities_per_page=1, offset=1
+            )
             entities_per_page = min(50, self.pagination_limit)
             indexes = math.ceil(tableau_datasource.totalCount / entities_per_page)
 
@@ -182,7 +260,9 @@ class TableauClient:
             for index in range(indexes):
                 offset = index * entities_per_page
                 tableau_datasource = self._query_datasources(
-                    entities_per_page=entities_per_page, offset=offset
+                    dashboard_id=dashboard_id,
+                    entities_per_page=entities_per_page,
+                    offset=offset,
                 )
                 if tableau_datasource:
                     data_sources.extend(tableau_datasource.nodes)

metadata/ingestion/source/dashboard/tableau/connection.py

@@ -52,7 +52,8 @@ def get_connection(connection: TableauConnection) -> TableauClient:
     get_verify_ssl = get_verify_ssl_fn(connection.verifySSL)
     try:
         return TableauClient(
-            config=tableau_server_config,
+            tableau_server_config=tableau_server_config,
+            config=connection,
             env=connection.env,
             ssl_verify=get_verify_ssl(connection.sslConfig),
             pagination_limit=connection.paginationLimit,
@@ -77,6 +78,14 @@ def test_connection(
 
     test_fn = {
         "ServerInfo": client.server_info,
+        # The Tableau server_info API doesn't provide direct access to the API version.
+        # This is due to the "api_version" being a mandatory field for the tableau library's connection class.
+        # Without this information, requests to the Tableau server cannot be made,
+        # including fetching the server info containing the "api_version".
+        # Consequently, we'll compare the declared api_version with the server's api_version during the test connection
+        # once the tableau library's connection class is initialized.
+        "ValidateApiVersion": client.test_api_version,
+        "ValidateSiteUrl": client.test_site_url,
         "GetWorkbooks": partial(
             extract_pages,
             query_func=client.query_workbooks_for_site,

metadata/ingestion/source/dashboard/tableau/metadata.py

@@ -14,6 +14,8 @@ Tableau source module
 import traceback
 from typing import Any, Iterable, List, Optional, Set
 
+from requests.utils import urlparse
+
 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 (
@@ -39,11 +41,14 @@ from metadata.generated.schema.entity.services.dashboardService import (
     DashboardServiceType,
 )
 from metadata.generated.schema.entity.services.databaseService import DatabaseService
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
 from metadata.generated.schema.type.entityReference import EntityReference
-from metadata.ingestion.api.models import Either, StackTraceError
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.models.ometa_classification import OMetaTagAndClassification
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
@@ -82,51 +87,6 @@ class TableauSource(DashboardServiceSource):
     metadata_config: OpenMetadataConnection
     client: TableauClient
 
-    def __init__(
-        self,
-        config: WorkflowSource,
-        metadata: OpenMetadata,
-    ):
-        super().__init__(config, metadata)
-        self.workbooks: List[
-            TableauDashboard
-        ] = []  # We will populate this in `prepare`
-        self.tags: Set[TableauTag] = set()
-
-    def prepare(self):
-        """Restructure the API response"""
-        try:
-            # get workbooks which are considered Dashboards in OM
-            self.workbooks = self.client.get_workbooks()
-
-            # get views which are considered charts in OM
-            charts = self.client.get_charts()
-
-            # get datasources which are considered as datamodels in OM
-            data_models = self.client.get_datasources()
-
-            # add all the charts (views) and datasources from the API to each workbook
-            for workbook in self.workbooks:
-                workbook.charts = [
-                    chart for chart in charts if chart.workbook.id == workbook.id
-                ]
-
-                for data_model in data_models or []:
-                    if data_model.workbook and data_model.workbook.luid == workbook.id:
-                        workbook.dataModels.append(data_model)
-
-            # collect all the tags from charts and workbooks before yielding final entities
-            if self.source_config.includeTags:
-                for container in [self.workbooks, charts]:
-                    for elem in container:
-                        self.tags.update(elem.tags)
-
-        except Exception:
-            logger.debug(traceback.format_exc())
-            logger.error("Error in fetching the Tableau Workbook metadata")
-
-        return super().prepare()
-
     @classmethod
     def create(cls, config_dict: dict, metadata: OpenMetadata):
         config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
@@ -138,36 +98,76 @@ class TableauSource(DashboardServiceSource):
         return cls(config, metadata)
 
     def get_dashboards_list(self) -> Optional[List[TableauDashboard]]:
-        return self.workbooks
+        return self.client.get_workbooks()
 
     def get_dashboard_name(self, dashboard: TableauDashboard) -> str:
         return dashboard.name
 
     def get_dashboard_details(self, dashboard: TableauDashboard) -> TableauDashboard:
         """
-        Get Dashboard Details. Returning the identity here as we prepare everything
-        during the `prepare` stage
+        Get Dashboard Details including the dashboard charts and datamodels
         """
+
+        # Get the tableau views/sheets
+        dashboard.charts = self.client.get_workbook_charts(dashboard_id=dashboard.id)
+
+        # Get the tableau data sources
+        dashboard.dataModels = self.client.get_datasources(dashboard_id=dashboard.id)
+
         return dashboard
 
-    def get_owner_details(
+    def get_owner_ref(
         self, dashboard_details: TableauDashboard
     ) -> Optional[EntityReference]:
-        """Get dashboard owner from email"""
-        if dashboard_details.owner and dashboard_details.owner.email:
-            user = self.metadata.get_user_by_email(dashboard_details.owner.email)
-            if user:
-                return EntityReference(id=user.id.__root__, type="user")
+        """
+        Get dashboard owner from email
+        """
+        try:
+            if dashboard_details.owner and dashboard_details.owner.email:
+                return self.metadata.get_reference_by_email(
+                    dashboard_details.owner.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_tag(self, *_, **__) -> Iterable[Either[OMetaTagAndClassification]]:
-        yield from get_ometa_tag_and_classification(
-            tags=[tag.label for tag in self.tags],
-            classification_name=TABLEAU_TAG_CATEGORY,
-            tag_description="Tableau Tag",
-            classification_description="Tags associated with tableau entities",
-            include_tags=self.source_config.includeTags,
-        )
+    def yield_tags(
+        self, dashboard_details: TableauDashboard
+    ) -> Iterable[Either[OMetaTagAndClassification]]:
+        """
+        Method to yield tags related to specific dashboards
+        """
+        if self.source_config.includeTags:
+            tags: Set[TableauTag] = set()
+            for container in [[dashboard_details], dashboard_details.charts]:
+                for elem in container:
+                    tags.update(elem.tags)
+
+            yield from get_ometa_tag_and_classification(
+                tags=[tag.label for tag in tags],
+                classification_name=TABLEAU_TAG_CATEGORY,
+                tag_description="Tableau Tag",
+                classification_description="Tags associated with tableau entities",
+                include_tags=self.source_config.includeTags,
+            )
+
+    def _get_datamodel_sql_query(self, data_model: DataSource) -> Optional[str]:
+        """
+        Method to fetch the custom sql query from the tableau datamodels
+        """
+        try:
+            sql_queries = []
+            for table in data_model.upstreamTables or []:
+                for referenced_query in table.referencedByQueries or []:
+                    sql_queries.append(referenced_query.query)
+            return "\n\n".join(sql_queries) or None
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Error processing queries for datamodel [{data_model.id}]: {exc}"
+            )
+        return None
 
     def yield_datamodel(
         self, dashboard_details: TableauDashboard
@@ -188,16 +188,17 @@ class TableauSource(DashboardServiceSource):
                         dataModelType=DataModelType.TableauDataModel.value,
                         serviceType=DashboardServiceType.Tableau.value,
                         columns=self.get_column_info(data_model),
+                        sql=self._get_datamodel_sql_query(data_model=data_model),
                     )
                     yield Either(right=data_model_request)
-                    self.register_record_datamodel(datamodel_requst=data_model_request)
+                    self.register_record_datamodel(datamodel_request=data_model_request)
 
                 except Exception as exc:
                     yield Either(
                         left=StackTraceError(
                             name=data_model_name,
                             error=f"Error yielding Data Model [{data_model_name}]: {exc}",
-                            stack_trace=traceback.format_exc(),
+                            stackTrace=traceback.format_exc(),
                         )
                     )
 
@@ -214,6 +215,10 @@ class TableauSource(DashboardServiceSource):
         topology. And they are cleared after processing each Dashboard because of the 'clear_cache' option.
         """
         try:
+            dashboard_url = (
+                f"{clean_uri(str(self.config.serviceConnection.__root__.config.hostPort))}"
+                f"/#{urlparse(dashboard_details.webpageUrl).fragment}/views"
+            )
             dashboard_request = CreateDashboardRequest(
                 name=dashboard_details.id,
                 displayName=dashboard_details.name,
@@ -226,7 +231,7 @@ class TableauSource(DashboardServiceSource):
                         service_name=self.context.dashboard_service,
                         chart_name=chart,
                     )
-                    for chart in self.context.charts
+                    for chart in self.context.charts or []
                 ],
                 dataModels=[
                     fqn.build(
@@ -243,8 +248,9 @@ class TableauSource(DashboardServiceSource):
                     classification_name=TABLEAU_TAG_CATEGORY,
                     include_tags=self.source_config.includeTags,
                 ),
-                sourceUrl=dashboard_details.webpageUrl,
+                sourceUrl=dashboard_url,
                 service=self.context.dashboard_service,
+                owner=self.get_owner_ref(dashboard_details=dashboard_details),
             )
             yield Either(right=dashboard_request)
             self.register_record(dashboard_request=dashboard_request)
@@ -253,7 +259,7 @@ class TableauSource(DashboardServiceSource):
                 left=StackTraceError(
                     name=dashboard_details.id,
                     error=f"Error to yield dashboard for {dashboard_details}: {exc}",
-                    stack_trace=traceback.format_exc(),
+                    stackTrace=traceback.format_exc(),
                 )
             )
 
@@ -294,7 +300,7 @@ class TableauSource(DashboardServiceSource):
                             "Error to yield dashboard lineage details for DB "
                             f"service name [{db_service_name}]: {err}"
                         ),
-                        stack_trace=traceback.format_exc(),
+                        stackTrace=traceback.format_exc(),
                     )
                 )
 
@@ -342,7 +348,7 @@ class TableauSource(DashboardServiceSource):
                     left=StackTraceError(
                         name="Chart",
                         error=f"Error to yield dashboard chart [{chart}]: {exc}",
-                        stack_trace=traceback.format_exc(),
+                        stackTrace=traceback.format_exc(),
                     )
                 )
 

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

@@ -99,12 +99,6 @@ class DatasourceField(BaseModel):
     description: Optional[str]
 
 
-class Workbook(BaseModel):
-    id: str
-    luid: str
-    name: Optional[str]
-
-
 class UpstreamTableColumn(BaseModel):
     id: str
     name: Optional[str]
@@ -130,7 +124,6 @@ class DataSource(BaseModel):
     id: str
     name: Optional[str]
     fields: Optional[List[DatasourceField]]
-    workbook: Optional[Workbook]
     upstreamTables: Optional[List[UpstreamTable]]
 
 
@@ -148,7 +141,6 @@ class TableauChart(TableauBaseModel):
     Aux class for Chart object of the tableau_api_lib response
     """
 
-    workbook: TableauBaseModel
     owner: Optional[TableauOwner]
     tags: Optional[List[TableauTag]] = []
     _extract_tags = validator("tags", pre=True, allow_reuse=True)(transform_tags)