openmetadata-ingestion 1.5.11.0__py3-none-any.whl → 1.6.0.0rc1__py3-none-any.whl

metadata/ingestion/source/api/rest/metadata.py

@@ -0,0 +1,278 @@
+#  Copyright 2024 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""REST source module"""
+
+import traceback
+from typing import Iterable, List, Optional
+
+from pydantic import AnyUrl
+
+from metadata.generated.schema.api.data.createAPICollection import (
+    CreateAPICollectionRequest,
+)
+from metadata.generated.schema.api.data.createAPIEndpoint import (
+    CreateAPIEndpointRequest,
+)
+from metadata.generated.schema.entity.data.apiCollection import APICollection
+from metadata.generated.schema.entity.data.apiEndpoint import ApiRequestMethod
+from metadata.generated.schema.entity.services.connections.api.restConnection import (
+    RestConnection,
+)
+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.apiSchema import APISchema
+from metadata.generated.schema.type.basic import FullyQualifiedEntityName
+from metadata.generated.schema.type.schema import DataTypeTopic, FieldModel
+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.api.api_service import ApiServiceSource
+from metadata.ingestion.source.api.rest.models import RESTCollection, RESTEndpoint
+from metadata.utils import fqn
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class RestSource(ApiServiceSource):
+    """
+    Source implementation to ingest REST data.
+
+    We will iterate on the registered collections, endpoints
+    and prepare an iterator of
+    """
+
+    def __init__(self, config: WorkflowSource, metadata: OpenMetadata):
+        super().__init__(config, metadata)
+
+    @classmethod
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: RestConnection = config.serviceConnection.root.config
+        if not isinstance(connection, RestConnection):
+            raise InvalidSourceException(
+                f"Expected RestConnection, but got {connection}"
+            )
+        return cls(config, metadata)
+
+    def get_api_collections(self, *args, **kwargs) -> Iterable[RESTCollection]:
+        """
+        Method to list all collections to process.
+        Here is where filtering happens
+        """
+        try:
+            self.json_response = self.connection.json()
+            if self.json_response.get("tags", []):
+                # Works only if list of tags are present in schema so we can fetch collection names
+                for collection in self.json_response.get("tags", []):
+                    if not collection.get("name"):
+                        continue
+                    yield RESTCollection(**collection)
+            else:
+                # in other case collect tags from paths because we have to yield collection/tags first
+                collections_set = set()
+                for path, methods in self.json_response.get("paths", {}).items():
+                    for method_type, info in methods.items():
+                        collections_set.update({tag for tag in info.get("tags", [])})
+                for collection_name in collections_set:
+                    data = {"name": collection_name}
+                    yield RESTCollection(**data)
+        except Exception as err:
+            logger.error(f"Error while fetching collections from schema URL :{err}")
+
+    def yield_api_collection(
+        self, collection: RESTCollection
+    ) -> Iterable[Either[CreateAPICollectionRequest]]:
+        """Method to return api collection Entities"""
+        try:
+            collection.url = self._generate_collection_url(collection.name.root)
+            collection_request = CreateAPICollectionRequest(
+                name=collection.name,
+                displayName=collection.display_name,
+                description=collection.description,
+                service=FullyQualifiedEntityName(self.context.get().api_service),
+                endpointURL=collection.url,
+            )
+            yield Either(right=collection_request)
+            self.register_record(collection_request=collection_request)
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name=collection.name.root,
+                    error=f"Error creating api collection request: {exc}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )
+
+    def yield_api_endpoint(
+        self, collection: RESTCollection
+    ) -> Iterable[Either[CreateAPIEndpointRequest]]:
+        """Method to return api endpoint Entities"""
+        filtered_endpoints = self._filter_collection_endpoints(collection) or {}
+        for path, methods in filtered_endpoints.items():
+            for method_type, info in methods.items():
+                try:
+                    endpoint = self._prepare_endpoint_data(path, method_type, info)
+                    if not endpoint:
+                        continue
+                    yield Either(
+                        right=CreateAPIEndpointRequest(
+                            name=endpoint.name,
+                            displayName=endpoint.display_name,
+                            description=endpoint.description,
+                            endpointURL=endpoint.url,
+                            requestMethod=self._get_api_request_method(method_type),
+                            requestSchema=self._get_request_schema(info),
+                            responseSchema=self._get_response_schema(info),
+                            apiCollection=FullyQualifiedEntityName(
+                                fqn.build(
+                                    self.metadata,
+                                    entity_type=APICollection,
+                                    service_name=self.context.get().api_service,
+                                    api_collection_name=collection.name.root,
+                                )
+                            ),
+                        )
+                    )
+                except Exception as exc:  # pylint: disable=broad-except
+                    yield Either(
+                        left=StackTraceError(
+                            name=endpoint.name,
+                            error=f"Error creating API Endpoint request [{info.get('operationId')}]: {exc}",
+                            stackTrace=traceback.format_exc(),
+                        )
+                    )
+
+    def _filter_collection_endpoints(
+        self, collection: RESTCollection
+    ) -> Optional[dict]:
+        """filter endpoints related to specific collection"""
+        try:
+            filtered_paths = {}
+            for path, methods in self.json_response.get("paths", {}).items():
+                for method_type, info in methods.items():
+                    if collection.name.root in info.get("tags", []):
+                        # path & methods are part of collection
+                        filtered_paths.update({path: methods})
+                    break
+            return filtered_paths
+        except Exception as err:
+            logger.info(
+                f"Error while filtering endpoints for collection {collection.name.root}"
+            )
+            return None
+
+    def _prepare_endpoint_data(self, path, method_type, info) -> Optional[RESTEndpoint]:
+        try:
+            endpoint = RESTEndpoint(**info)
+            endpoint.url = self._generate_endpoint_url(endpoint.name)
+            if not endpoint.name:
+                endpoint.name = f"{path} - {method_type}"
+            return endpoint
+        except Exception as err:
+            logger.info(f"Error while parsing endpoint data: {err}")
+        return None
+
+    def _generate_collection_url(self, collection_name: str) -> Optional[AnyUrl]:
+        """generate collection url"""
+        try:
+            if collection_name:
+                return AnyUrl(
+                    f"{self.config.serviceConnection.root.config.openAPISchemaURL}#tag/{collection_name}"
+                )
+        except Exception as err:
+            logger.info(f"Error while generating collection url: {err}")
+        return None
+
+    def _generate_endpoint_url(self, endpoint_name: str) -> AnyUrl:
+        """generate endpoint url"""
+        base_url = self.config.serviceConnection.root.config.openAPISchemaURL
+        if endpoint_name:
+            return AnyUrl(f"{base_url}#operation/{endpoint_name}")
+        else:
+            return AnyUrl(base_url)
+
+    def _get_api_request_method(self, method_type: str) -> Optional[str]:
+        """fetch endpoint request method"""
+        try:
+            return ApiRequestMethod[method_type.upper()]
+        except KeyError as err:
+            logger.info(f"Keyerror while fetching request method: {err}")
+        return None
+
+    def _get_request_schema(self, info: dict) -> Optional[APISchema]:
+        """fetch request schema"""
+        try:
+            schema_ref = (
+                info.get("requestBody", {})
+                .get("content", {})
+                .get("application/json", {})
+                .get("schema", {})
+                .get("$ref")
+            )
+            if not schema_ref:
+                logger.debug("No request schema found for the endpoint")
+                return None
+            return self._process_schema(schema_ref)
+        except Exception as err:
+            logger.info(f"Error while parsing request schema: {err}")
+        return None
+
+    def _get_response_schema(self, info: dict) -> Optional[APISchema]:
+        """fetch response schema"""
+        try:
+            schema_ref = (
+                info.get("responses", {})
+                .get("200", {})
+                .get("content", {})
+                .get("application/json", {})
+                .get("schema", {})
+                .get("$ref", {})
+            )
+            if not schema_ref:
+                logger.debug("No response schema found for the endpoint")
+                return None
+            return self._process_schema(schema_ref)
+        except Exception as err:
+            logger.info(f"Error while parsing response schema: {err}")
+        return None
+
+    def _process_schema(self, schema_ref: str) -> Optional[List[APISchema]]:
+        """process schema"""
+        try:
+            schema_ref = schema_ref.split("/")[-1]
+            schema_fields = (
+                self.json_response.get("components").get("schemas").get(schema_ref)
+            )
+
+            fetched_fields = []
+            for key, val in schema_fields.get("properties", {}).items():
+                dtype = val.get("type")
+                if not dtype:
+                    continue
+                fetched_fields.append(
+                    FieldModel(
+                        name=key,
+                        dataType=DataTypeTopic[dtype.upper()]
+                        if dtype.upper() in DataTypeTopic.__members__
+                        else DataTypeTopic.UNKNOWN,
+                    )
+                )
+            return APISchema(schemaFields=fetched_fields)
+        except Exception as err:
+            logger.info(f"Error while processing request schema: {err}")
+        return None

metadata/ingestion/source/api/rest/models.py

@@ -0,0 +1,41 @@
+#  Copyright 2024 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""
+OpenAPI REST API Models
+"""
+from typing import Optional
+
+from pydantic import AnyUrl, BaseModel, Field
+
+from metadata.generated.schema.entity.data.apiEndpoint import ApiRequestMethod
+from metadata.generated.schema.type import basic
+from metadata.generated.schema.type.apiSchema import APISchema
+
+
+class RESTCollection(BaseModel):
+    """REST colleciton model"""
+
+    name: basic.EntityName
+    display_name: Optional[str] = None
+    description: Optional[basic.Markdown] = None
+    url: Optional[AnyUrl] = None
+
+
+class RESTEndpoint(BaseModel):
+    """REST endpoint model"""
+
+    name: Optional[str] = Field(None, alias="operationId")
+    display_name: Optional[str] = None
+    description: Optional[basic.Markdown] = None
+    url: Optional[AnyUrl] = None
+    request_method: Optional[ApiRequestMethod] = None
+    request_schema: Optional[APISchema] = None
+    response_schema: Optional[APISchema] = None

metadata/ingestion/source/api/rest/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.api.rest.metadata import RestSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=RestSource)

metadata/ingestion/source/dashboard/domodashboard/service_spec.py

@@ -0,0 +1,6 @@
+from metadata.ingestion.source.dashboard.domodashboard.metadata import (
+    DomodashboardSource,
+)
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=DomodashboardSource)

metadata/ingestion/source/dashboard/lightdash/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.lightdash.metadata import LightdashSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=LightdashSource)

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

@@ -28,6 +28,7 @@ from typing import Dict, Iterable, List, Optional, Sequence, Set, Type, Union, c
 
 import giturlparse
 import lkml
+from liquid import Template
 from looker_sdk.sdk.api40.methods import Looker40SDK
 from looker_sdk.sdk.api40.models import Dashboard as LookerDashboard
 from looker_sdk.sdk.api40.models import (
@@ -450,11 +451,11 @@ class LookerSource(DashboardServiceSource):
                                 view.name, "Data model (View) filtered out."
                             )
                             continue
-
+                        view_name = view.from_ if view.from_ else view.name
                         yield from self._process_view(
-                            view_name=ViewName(view.name), explore=model
+                            view_name=ViewName(view_name), explore=model
                         )
-                    if len(model.joins) == 0 and model.sql_table_name:
+                    if model.view_name:
                         yield from self._process_view(
                             view_name=ViewName(model.view_name), explore=model
                         )
@@ -570,7 +571,8 @@ class LookerSource(DashboardServiceSource):
             db_service_names = self.get_db_service_names()
 
             if view.sql_table_name:
-                source_table_name = self._clean_table_name(view.sql_table_name)
+                sql_table_name = self._render_table_name(view.sql_table_name)
+                source_table_name = self._clean_table_name(sql_table_name)
 
                 # View to the source is only there if we are informing the dbServiceNames
                 for db_service_name in db_service_names or []:
@@ -726,6 +728,33 @@ class LookerSource(DashboardServiceSource):
 
         return table_name.lower().split(" as ")[0].strip()
 
+    @staticmethod
+    def _render_table_name(table_name: str) -> str:
+        """
+        sql_table_names might contain Liquid templates
+        when defining an explore. e.g,:
+        sql_table_name:
+            {% if openmetadata %}
+                event
+            {% elsif event.created_week._in_query %}
+                event_by_week
+            {% else %}
+                event
+            {% endif %} ;;
+        we should render the template and give the option
+        to render a specific value during metadata ingestion
+        using the "openmetadata" context argument
+        :param table_name: table name with possible templating
+        :return: rendered table name
+        """
+        try:
+            context = {"openmetadata": True}
+            template = Template(table_name)
+            sql_table_name = template.render(context)
+        except Exception:
+            sql_table_name = table_name
+        return sql_table_name
+
     @staticmethod
     def get_dashboard_sources(dashboard_details: LookerDashboard) -> Set[str]:
         """

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

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.looker.metadata import LookerSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=LookerSource)

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

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.metabase.metadata import MetabaseSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=MetabaseSource)

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

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.mode.metadata import ModeSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=ModeSource)

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

@@ -30,6 +30,7 @@ from metadata.ingestion.source.dashboard.mstr.models import (
     MstrSearchResult,
     MstrSearchResultList,
 )
+from metadata.utils.helpers import clean_uri
 from metadata.utils.logger import ingestion_logger
 
 logger = ingestion_logger()
@@ -44,8 +45,8 @@ class MSTRClient:
 
     def _get_base_url(self, path=None):
         if not path:
-            return f"{self.config.hostPort}/{API_VERSION}/"
-        return f"{self.config.hostPort}/{API_VERSION}/{path}"
+            return f"{clean_uri(self.config.hostPort)}/{API_VERSION}/"
+        return f"{clean_uri(self.config.hostPort)}/{API_VERSION}/{path}"
 
     def _get_mstr_session(self) -> MSTRRESTSession:
         try:

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

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.mstr.metadata import MstrSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=MstrSource)

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

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.powerbi.metadata import PowerbiSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=PowerbiSource)

metadata/ingestion/source/dashboard/qlikcloud/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.qlikcloud.metadata import QlikcloudSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=QlikcloudSource)

metadata/ingestion/source/dashboard/qliksense/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.qliksense.metadata import QliksenseSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=QliksenseSource)

metadata/ingestion/source/dashboard/quicksight/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.quicksight.metadata import QuicksightSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=QuicksightSource)

metadata/ingestion/source/dashboard/redash/service_spec.py

@@ -0,0 +1,4 @@
+from metadata.ingestion.source.dashboard.redash.metadata import RedashSource
+from metadata.utils.service_spec import BaseSpec
+
+ServiceSpec = BaseSpec(metadata_source_class=RedashSource)

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

@@ -0,0 +1,186 @@
+#  Copyright 2021 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""
+REST Auth & Client for Sigma
+"""
+
+import traceback
+from base64 import b64encode
+from typing import List, Optional, Tuple
+
+from metadata.generated.schema.entity.services.connections.dashboard.sigmaConnection import (
+    SigmaConnection,
+)
+from metadata.ingestion.ometa.client import REST, ClientConfig
+from metadata.ingestion.source.dashboard.sigma.models import (
+    AuthToken,
+    EdgeSourceResponse,
+    Elements,
+    ElementsResponse,
+    NodeDetails,
+    OwnerDetails,
+    Workbook,
+    WorkbookDetails,
+    WorkBookPageResponse,
+    WorkBookResponseDetails,
+)
+from metadata.utils.constants import AUTHORIZATION_HEADER, UTF_8
+from metadata.utils.helpers import clean_uri
+from metadata.utils.logger import utils_logger
+
+logger = utils_logger()
+
+HEADERS = {
+    "accept": "application/json",
+    "Content-type": "application/x-www-form-urlencoded",
+}
+
+TOKEN_PAYLOAD = {"grant_type": "client_credentials"}
+
+
+class SigmaApiClient:
+    """
+    REST Auth & Client for Sigma
+    """
+
+    client: REST
+
+    def __init__(self, config: SigmaConnection):
+        self.config = config
+        token_api_key = str(
+            b64encode(
+                f"{self.config.clientId}:{self.config.clientSecret.get_secret_value()}".encode(
+                    UTF_8
+                )
+            ).decode(UTF_8)
+        )
+
+        token_config = ClientConfig(
+            base_url=clean_uri(config.hostPort),
+            api_version=config.apiVersion,
+            auth_header=AUTHORIZATION_HEADER,
+            extra_headers=HEADERS,
+            auth_token=lambda: (token_api_key, 0),
+            auth_token_mode="Basic",
+        )
+
+        self.token_client = REST(token_config)
+
+        client_config = ClientConfig(
+            base_url=clean_uri(config.hostPort),
+            api_version=config.apiVersion,
+            auth_token=self.get_auth_token,
+            auth_header=AUTHORIZATION_HEADER,
+        )
+
+        self.client = REST(client_config)
+
+    def get_auth_token(self) -> Tuple[str, int]:
+        """
+        generate auth token
+         Returns:
+            Tuple[str, int]: A tuple containing the access_token (str) and expires_in (int)
+        """
+        result = AuthToken.model_validate(
+            self.token_client.post("/auth/token", data=TOKEN_PAYLOAD)
+        )
+        return result.access_token, result.expires_in
+
+    def get_dashboards(self) -> Optional[List[Workbook]]:
+        """
+        method to fetch dashboards from api
+        """
+        result = WorkBookResponseDetails.model_validate(self.client.get("/workbooks"))
+        if result:
+            return result.entries
+
+    def get_dashboard_detail(self, workbook_id: str) -> Optional[WorkbookDetails]:
+        """
+        method to fetch dashboard details from api
+        """
+        try:
+            result = WorkbookDetails.model_validate(
+                self.client.get(f"/workbooks/{workbook_id}")
+            )
+            if result:
+                return result
+        except Exception as exc:  # pylint: disable=broad-except
+            logger.debug(traceback.format_exc())
+            logger.error(
+                f"Error fetching Dashboard details for for workbook {workbook_id}: {exc}"
+            )
+        return None
+
+    def get_owner_detail(self, owner_id: str) -> Optional[OwnerDetails]:
+        """
+        method to fetch dashboard owner details from api
+        """
+        try:
+            result = OwnerDetails.model_validate(
+                self.client.get(f"/members/{owner_id}")
+            )
+            if result:
+                return result
+        except Exception as exc:  # pylint: disable=broad-except
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Failed to fetch owner details for owner {owner_id}: {exc}")
+        return None
+
+    def get_chart_details(self, workbook_id: str) -> Optional[List[Elements]]:
+        """
+        method to fetch dashboards chart details from api
+        """
+        try:
+            elements_list = []
+            pages = WorkBookPageResponse.model_validate(
+                self.client.get(f"/workbooks/{workbook_id}/pages")
+            )
+            for page in pages.entries:
+                elements = ElementsResponse.model_validate(
+                    self.client.get(
+                        f"/workbooks/{workbook_id}/pages/{page.pageId}/elements"
+                    )
+                )
+                elements_list.extend(elements.entries or [])
+            return elements_list
+        except Exception as exc:  # pylint: disable=broad-except
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Failed to fetch chart details for workbook {workbook_id}: {exc}"
+            )
+        return None
+
+    def get_lineage_details(
+        self, workbook_id: str, element_id: str
+    ) -> Optional[List[NodeDetails]]:
+        """
+        method to fetch dashboards lineage details from api
+        """
+        try:
+            source_nodes = []
+            edges_response = EdgeSourceResponse.model_validate(
+                self.client.get(
+                    f"/workbooks/{workbook_id}/lineage/elements/{element_id}"
+                )
+            )
+            for node in edges_response.edges:
+                if node.node_id:
+                    node_details = NodeDetails.model_validate(
+                        self.client.get(f"/files/{node.node_id}")
+                    )
+                    source_nodes.append(node_details)
+            return source_nodes
+        except Exception as exc:  # pylint: disable=broad-except
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Failed to fetch lineage details for workbook {workbook_id}: {exc}"
+            )
+        return None