openmetadata-ingestion 1.3.3.0rc1__py3-none-any.whl → 1.4.0.0rc1__py3-none-any.whl

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

@@ -0,0 +1,249 @@
+#  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.
+"""QlikCloud source module"""
+
+import traceback
+from typing import Iterable, List, Optional
+
+from metadata.generated.schema.api.data.createChart import CreateChartRequest
+from metadata.generated.schema.api.data.createDashboard import CreateDashboardRequest
+from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
+from metadata.generated.schema.entity.data.chart import Chart, ChartType
+from metadata.generated.schema.entity.data.dashboardDataModel import DashboardDataModel
+from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.entity.services.connections.dashboard.qlikCloudConnection import (
+    QlikCloudConnection,
+)
+from metadata.generated.schema.entity.services.connections.metadata.openMetadataConnection import (
+    OpenMetadataConnection,
+)
+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
+from metadata.ingestion.api.steps import InvalidSourceException
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.dashboard.qlikcloud.client import QlikCloudClient
+from metadata.ingestion.source.dashboard.qlikcloud.models import QlikApp, QlikAppList
+from metadata.ingestion.source.dashboard.qliksense.metadata import QliksenseSource
+from metadata.ingestion.source.dashboard.qliksense.models import QlikTable
+from metadata.utils import fqn
+from metadata.utils.filters import filter_by_chart
+from metadata.utils.helpers import clean_uri
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class QlikcloudSource(QliksenseSource):
+    """
+    QlikCloud Source Class
+    """
+
+    config: WorkflowSource
+    client: QlikCloudClient
+    metadata_config: OpenMetadataConnection
+
+    @classmethod
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
+        config = WorkflowSource.parse_obj(config_dict)
+        connection: QlikCloudConnection = config.serviceConnection.__root__.config
+        if not isinstance(connection, QlikCloudConnection):
+            raise InvalidSourceException(
+                f"Expected QlikCloudConnection, but got {connection}"
+            )
+        return cls(config, metadata)
+
+    def __init__(
+        self,
+        config: WorkflowSource,
+        metadata: OpenMetadata,
+    ):
+        super().__init__(config, metadata)
+        self.collections: List[QlikAppList] = []
+        self.data_models: List[QlikTable] = []
+
+    def filter_draft_dashboard(self, dashboard: QlikApp) -> bool:
+        # When only published(non-draft) dashboards are allowed, filter dashboard based on "published" flag from QlikApp
+        return (not self.source_config.includeDraftDashboard) and (
+            not dashboard.published
+        )
+
+    def get_dashboards_list(self) -> Iterable[QlikApp]:
+        """
+        Get List of all apps
+        """
+        for dashboard in self.client.get_dashboards_list():
+            if self.filter_draft_dashboard(dashboard):
+                # Skip unpublished dashboards
+                continue
+            # clean data models for next iteration
+            self.data_models = []
+            yield dashboard
+
+    def get_dashboard_name(self, dashboard: QlikApp) -> str:
+        """
+        Get app Name
+        """
+        return dashboard.name
+
+    def get_dashboard_details(self, dashboard: QlikApp) -> dict:
+        """
+        Get app Details
+        """
+        return self.client.get_dashboard_details(dashboard.app_id)
+
+    def yield_dashboard(
+        self, dashboard_details: QlikApp
+    ) -> Iterable[Either[CreateDashboardRequest]]:
+        """
+        Method to Get Dashboard Entity
+        """
+        try:
+            dashboard_url = f"{clean_uri(self.service_connection.hostPort)}/sense/app/{dashboard_details.id}/overview"
+
+            dashboard_request = CreateDashboardRequest(
+                name=dashboard_details.id,
+                sourceUrl=dashboard_url,
+                displayName=dashboard_details.name,
+                description=dashboard_details.description,
+                project=self.context.get().project_name,
+                charts=[
+                    fqn.build(
+                        self.metadata,
+                        entity_type=Chart,
+                        service_name=self.context.get().dashboard_service,
+                        chart_name=chart,
+                    )
+                    for chart in self.context.get().charts or []
+                ],
+                service=self.context.get().dashboard_service,
+                owner=self.get_owner_ref(dashboard_details=dashboard_details),
+            )
+            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.name}]: {exc}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )
+
+    def _get_database_table(
+        self,
+        db_service_entity: DatabaseService,
+        data_model_entity: DashboardDataModel,
+    ) -> Optional[Table]:
+        """
+        Get the table entity for lineage
+        """
+        # table.name in tableau can come as db.schema.table_name. Hence the logic to split it
+        if data_model_entity and db_service_entity:
+            try:
+                schema_name, database_name = None, None
+                table_fqn = fqn.build(
+                    self.metadata,
+                    entity_type=Table,
+                    service_name=db_service_entity.name.__root__,
+                    schema_name=schema_name,
+                    table_name=data_model_entity.displayName,
+                    database_name=database_name,
+                )
+                if table_fqn:
+                    return self.metadata.get_by_name(
+                        entity=Table,
+                        fqn=table_fqn,
+                    )
+            except Exception as exc:
+                logger.debug(traceback.format_exc())
+                logger.warning(f"Error occured while finding table fqn: {exc}")
+        return None
+
+    def yield_dashboard_lineage_details(
+        self,
+        dashboard_details: QlikApp,
+        db_service_name: Optional[str],
+    ) -> Iterable[Either[AddLineageRequest]]:
+        """Get lineage method"""
+        db_service_entity = self.metadata.get_by_name(
+            entity=DatabaseService, fqn=db_service_name
+        )
+        for datamodel in self.data_models or []:
+            try:
+                data_model_entity = self._get_datamodel(datamodel_id=datamodel.id)
+                if data_model_entity:
+                    om_table = self._get_database_table(
+                        db_service_entity, data_model_entity
+                    )
+                    if om_table:
+                        columns_list = [col.name for col in datamodel.fields]
+                        column_lineage = self._get_column_lineage(
+                            om_table, data_model_entity, columns_list
+                        )
+                        yield self._get_add_lineage_request(
+                            to_entity=data_model_entity,
+                            from_entity=om_table,
+                            column_lineage=column_lineage,
+                        )
+            except Exception as err:
+                yield Either(
+                    left=StackTraceError(
+                        name=f"{dashboard_details.name} Lineage",
+                        error=(
+                            "Error to yield dashboard lineage details for DB "
+                            f"service name [{db_service_name}]: {err}"
+                        ),
+                        stackTrace=traceback.format_exc(),
+                    )
+                )
+
+    def yield_dashboard_chart(
+        self, dashboard_details: QlikApp
+    ) -> Iterable[Either[CreateChartRequest]]:
+        """Get chart method"""
+        charts = self.client.get_dashboard_charts(dashboard_id=dashboard_details.id)
+        for chart in charts:
+            try:
+                chart_url = (
+                    f"{clean_uri(self.service_connection.hostPort)}/sense/app/{dashboard_details.id}"
+                    f"/sheet/{chart.qInfo.qId}"
+                )
+                if chart.qMeta.title and filter_by_chart(
+                    self.source_config.chartFilterPattern, chart.qMeta.title
+                ):
+                    self.status.filter(chart.qMeta.title, "Chart Pattern not allowed")
+                    continue
+                yield Either(
+                    right=CreateChartRequest(
+                        name=chart.qInfo.qId,
+                        displayName=chart.qMeta.title,
+                        description=chart.qMeta.description,
+                        chartType=ChartType.Other,
+                        sourceUrl=chart_url,
+                        service=self.context.get().dashboard_service,
+                    )
+                )
+            except Exception as exc:  # pylint: disable=broad-except
+                yield Either(
+                    left=StackTraceError(
+                        name=dashboard_details.name,
+                        error=f"Error creating chart [{chart}]: {exc}",
+                        stackTrace=traceback.format_exc(),
+                    )
+                )

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

@@ -0,0 +1,33 @@
+#  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.
+"""
+QlikCloud Models
+"""
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+# App Models
+class QlikApp(BaseModel):
+    """QlikCloud App model"""
+
+    description: Optional[str]
+    name: Optional[str]
+    id: str
+    app_id: Optional[str] = Field(alias="resourceId", default=None)
+    published: Optional[bool]
+
+
+class QlikAppList(BaseModel):
+    """QlikCloud Apps List"""
+
+    apps: Optional[List[QlikApp]]

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

@@ -40,8 +40,9 @@ from metadata.ingestion.source.dashboard.qliksense.models import (
     QlikTable,
 )
 from metadata.utils.constants import UTF_8
-from metadata.utils.helpers import clean_uri, delete_dir_content, init_staging_dir
+from metadata.utils.helpers import clean_uri
 from metadata.utils.logger import ingestion_logger
+from metadata.utils.ssl_manager import SSLManager
 
 logger = ingestion_logger()
 
@@ -72,35 +73,17 @@ class QlikSenseClient:
                 "ca_certs": self.config.certificates.rootCertificate,
                 "certfile": self.config.certificates.clientCertificate,
                 "keyfile": self.config.certificates.clientKeyCertificate,
+                "check_hostname": self.config.validateHostName,
             }
             return context
 
-        init_staging_dir(self.config.certificates.stagingDir)
-        root_path = Path(self.config.certificates.stagingDir, "root.pem")
-        client_path = Path(self.config.certificates.stagingDir, "client.pem")
-        client_key_path = Path(self.config.certificates.stagingDir, "client_key.pem")
-
-        self.write_data_to_file(
-            root_path, self.config.certificates.rootCertificateData.get_secret_value()
-        )
-
-        self.write_data_to_file(
-            client_path,
-            self.config.certificates.clientCertificateData.get_secret_value(),
+        self.ssl_manager = SSLManager(
+            ca=self.config.certificates.sslConfig.__root__.caCertificate,
+            cert=self.config.certificates.sslConfig.__root__.sslCertificate,
+            key=self.config.certificates.sslConfig.__root__.sslKey,
         )
 
-        self.write_data_to_file(
-            client_key_path,
-            self.config.certificates.clientKeyCertificateData.get_secret_value(),
-        )
-
-        context = {
-            "ca_certs": root_path,
-            "certfile": client_path,
-            "keyfile": client_key_path,
-        }
-
-        return context
+        return self.ssl_manager.setup_ssl(self.config)
 
     def connect_websocket(self, app_id: str = None) -> None:
         """
@@ -133,7 +116,7 @@ class QlikSenseClient:
             self.socket_connection.close()
 
         if isinstance(self.config.certificates, QlikCertificateValues):
-            delete_dir_content(self.config.certificates.stagingDir)
+            self.ssl_manager.cleanup_temp_files()
 
     def __init__(
         self,

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

@@ -31,9 +31,6 @@ from metadata.generated.schema.entity.services.connections.dashboard.qlikSenseCo
 from metadata.generated.schema.entity.services.connections.metadata.openMetadataConnection import (
     OpenMetadataConnection,
 )
-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,
@@ -66,7 +63,9 @@ class QliksenseSource(DashboardServiceSource):
     metadata_config: OpenMetadataConnection
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         config = WorkflowSource.parse_obj(config_dict)
         connection: QlikSenseConnection = config.serviceConnection.__root__.config
         if not isinstance(connection, QlikSenseConnection):
@@ -85,9 +84,18 @@ class QliksenseSource(DashboardServiceSource):
         # Data models will be cleared up for each dashboard
         self.data_models: List[QlikTable] = []
 
+    def filter_draft_dashboard(self, dashboard: QlikDashboard) -> bool:
+        # When only published(non-draft) dashboards are allowed, filter dashboard based on "published" flag from QlikDashboardMeta(qMeta)
+        return (not self.source_config.includeDraftDashboard) and (
+            not dashboard.qMeta.published
+        )
+
     def get_dashboards_list(self) -> Iterable[QlikDashboard]:
         """Get List of all dashboards"""
         for dashboard in self.client.get_dashboards_list():
+            if self.filter_draft_dashboard(dashboard):
+                # Skip unpublished dashboards
+                continue
             # create app specific websocket
             self.client.connect_websocket(dashboard.qDocId)
             # clean data models for next iteration
@@ -126,12 +134,12 @@ class QliksenseSource(DashboardServiceSource):
                     fqn.build(
                         self.metadata,
                         entity_type=Chart,
-                        service_name=self.context.dashboard_service,
+                        service_name=self.context.get().dashboard_service,
                         chart_name=chart,
                     )
-                    for chart in self.context.charts or []
+                    for chart in self.context.get().charts or []
                 ],
-                service=self.context.dashboard_service,
+                service=self.context.get().dashboard_service,
                 owner=self.get_owner_ref(dashboard_details=dashboard_details),
             )
             yield Either(right=dashboard_request)
@@ -173,7 +181,7 @@ class QliksenseSource(DashboardServiceSource):
                         description=chart.qMeta.description,
                         chartType=ChartType.Other,
                         sourceUrl=chart_url,
-                        service=self.context.dashboard_service,
+                        service=self.context.get().dashboard_service,
                     )
                 )
             except Exception as exc:  # pylint: disable=broad-except
@@ -215,13 +223,12 @@ class QliksenseSource(DashboardServiceSource):
                     ):
                         self.status.filter(data_model_name, "Data model filtered out.")
                         continue
-
                     data_model_request = CreateDashboardDataModelRequest(
                         name=data_model.id,
                         displayName=data_model_name,
-                        service=self.context.dashboard_service,
-                        dataModelType=DataModelType.QlikSenseDataModel.value,
-                        serviceType=DashboardServiceType.QlikSense.value,
+                        service=self.context.get().dashboard_service,
+                        dataModelType=DataModelType.QlikDataModel.value,
+                        serviceType=self.service_connection.type.value,
                         columns=self.get_column_info(data_model),
                     )
                     yield Either(right=data_model_request)
@@ -238,12 +245,12 @@ class QliksenseSource(DashboardServiceSource):
                         )
                     )
 
-    def _get_datamodel(self, datamodel: QlikTable):
+    def _get_datamodel(self, datamodel_id: str):
         datamodel_fqn = fqn.build(
             self.metadata,
             entity_type=DashboardDataModel,
-            service_name=self.context.dashboard_service,
-            data_model_name=datamodel.id,
+            service_name=self.context.get().dashboard_service,
+            data_model_name=datamodel_id,
         )
         if datamodel_fqn:
             return self.metadata.get_by_name(
@@ -301,14 +308,20 @@ class QliksenseSource(DashboardServiceSource):
         )
         for datamodel in self.data_models or []:
             try:
-                data_model_entity = self._get_datamodel(datamodel=datamodel)
+                data_model_entity = self._get_datamodel(datamodel=datamodel.id)
                 if data_model_entity:
                     om_table = self._get_database_table(
                         db_service_entity, datamodel=datamodel
                     )
                     if om_table:
+                        columns_list = [col.name for col in datamodel.fields]
+                        column_lineage = self._get_column_lineage(
+                            om_table, data_model_entity, columns_list
+                        )
                         yield self._get_add_lineage_request(
-                            to_entity=data_model_entity, from_entity=om_table
+                            to_entity=data_model_entity,
+                            from_entity=om_table,
+                            column_lineage=column_lineage,
                         )
             except Exception as err:
                 yield Either(

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

@@ -20,6 +20,7 @@ from pydantic import BaseModel
 
 class QlikDashboardMeta(BaseModel):
     description: Optional[str]
+    published: Optional[bool]
 
 
 class QlikDashboard(BaseModel):

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

@@ -66,7 +66,9 @@ class QuicksightSource(DashboardServiceSource):
         }
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         config = WorkflowSource.parse_obj(config_dict)
         connection: QuickSightConnection = config.serviceConnection.__root__.config
         if not isinstance(connection, QuickSightConnection):
@@ -141,12 +143,12 @@ class QuicksightSource(DashboardServiceSource):
                 fqn.build(
                     self.metadata,
                     entity_type=Chart,
-                    service_name=self.context.dashboard_service,
+                    service_name=self.context.get().dashboard_service,
                     chart_name=chart,
                 )
-                for chart in self.context.charts or []
+                for chart in self.context.get().charts or []
             ],
-            service=self.context.dashboard_service,
+            service=self.context.get().dashboard_service,
             owner=self.get_owner_ref(dashboard_details=dashboard_details),
         )
         yield Either(right=dashboard_request)
@@ -178,7 +180,7 @@ class QuicksightSource(DashboardServiceSource):
                         displayName=chart["Name"],
                         chartType=ChartType.Other.value,
                         sourceUrl=self.dashboard_url,
-                        service=self.context.dashboard_service,
+                        service=self.context.get().dashboard_service,
                     )
                 )
             except Exception as exc:

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

@@ -68,7 +68,12 @@ class RedashSource(DashboardServiceSource):
         self.tags = []  # To create the tags before yielding final entities
 
     @classmethod
-    def create(cls, config_dict: dict, metadata: OpenMetadata):
+    def create(
+        cls,
+        config_dict: dict,
+        metadata: OpenMetadata,
+        pipeline_name: Optional[str] = None,
+    ):
         config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
         connection: RedashConnection = config.serviceConnection.__root__.config
         if not isinstance(connection, RedashConnection):
@@ -154,12 +159,12 @@ class RedashSource(DashboardServiceSource):
                     fqn.build(
                         self.metadata,
                         entity_type=Chart,
-                        service_name=self.context.dashboard_service,
+                        service_name=self.context.get().dashboard_service,
                         chart_name=chart,
                     )
-                    for chart in self.context.charts or []
+                    for chart in self.context.get().charts or []
                 ],
-                service=self.context.dashboard_service,
+                service=self.context.get().dashboard_service,
                 sourceUrl=self.get_dashboard_url(dashboard_details),
                 tags=get_tag_labels(
                     metadata=self.metadata,
@@ -266,7 +271,7 @@ class RedashSource(DashboardServiceSource):
                         chartType=get_standard_chart_type(
                             visualization["type"] if visualization else ""
                         ),
-                        service=self.context.dashboard_service,
+                        service=self.context.get().dashboard_service,
                         sourceUrl=self.get_dashboard_url(dashboard_details),
                         description=visualization["description"]
                         if visualization

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

@@ -77,6 +77,11 @@ class SupersetAPISource(SupersetSourceMixin):
             dashboards = self.client.fetch_dashboards(current_page, page_size)
             current_page += 1
             for dashboard in dashboards.result:
+                if (
+                    not self.source_config.includeDraftDashboard
+                    and not dashboard.published
+                ):
+                    continue
                 yield dashboard
 
     def yield_dashboard(
@@ -94,12 +99,12 @@ class SupersetAPISource(SupersetSourceMixin):
                     fqn.build(
                         self.metadata,
                         entity_type=Chart,
-                        service_name=self.context.dashboard_service,
+                        service_name=self.context.get().dashboard_service,
                         chart_name=chart,
                     )
-                    for chart in self.context.charts or []
+                    for chart in self.context.get().charts or []
                 ],
-                service=self.context.dashboard_service,
+                service=self.context.get().dashboard_service,
                 owner=self.get_owner_ref(dashboard_details=dashboard_details),
             )
             yield Either(right=dashboard_request)
@@ -140,7 +145,7 @@ class SupersetAPISource(SupersetSourceMixin):
                     description=chart_json.description,
                     chartType=get_standard_chart_type(chart_json.viz_type),
                     sourceUrl=f"{clean_uri(self.service_connection.hostPort)}{chart_json.url}",
-                    service=self.context.dashboard_service,
+                    service=self.context.get().dashboard_service,
                 )
                 yield Either(right=chart)
             except Exception as exc:  # pylint: disable=broad-except
@@ -215,7 +220,7 @@ class SupersetAPISource(SupersetSourceMixin):
                     data_model_request = CreateDashboardDataModelRequest(
                         name=datasource_json.id,
                         displayName=datasource_json.result.table_name,
-                        service=self.context.dashboard_service,
+                        service=self.context.get().dashboard_service,
                         columns=self.get_column_info(datasource_json.result.columns),
                         dataModelType=DataModelType.SupersetDataModel.value,
                     )

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

@@ -45,6 +45,7 @@ from metadata.ingestion.source.dashboard.superset.queries import (
     FETCH_ALL_CHARTS,
     FETCH_COLUMN,
     FETCH_DASHBOARDS,
+    FETCH_PUBLISHED_DASHBOARDS,
 )
 from metadata.utils import fqn
 from metadata.utils.filters import filter_by_datamodel
@@ -100,7 +101,12 @@ class SupersetDBSource(SupersetSourceMixin):
         """
         Get List of all dashboards
         """
-        dashboards = self.engine.execute(FETCH_DASHBOARDS)
+        query = (
+            FETCH_DASHBOARDS
+            if self.source_config.includeDraftDashboard
+            else FETCH_PUBLISHED_DASHBOARDS
+        )
+        dashboards = self.engine.execute(query)
         for dashboard in dashboards:
             yield FetchDashboard(**dashboard)
 
@@ -117,12 +123,12 @@ class SupersetDBSource(SupersetSourceMixin):
                     fqn.build(
                         self.metadata,
                         entity_type=Chart,
-                        service_name=self.context.dashboard_service,
+                        service_name=self.context.get().dashboard_service,
                         chart_name=chart,
                     )
-                    for chart in self.context.charts or []
+                    for chart in self.context.get().charts or []
                 ],
-                service=self.context.dashboard_service,
+                service=self.context.get().dashboard_service,
                 owner=self.get_owner_ref(dashboard_details=dashboard_details),
             )
             yield Either(right=dashboard_request)
@@ -169,7 +175,7 @@ class SupersetDBSource(SupersetSourceMixin):
                     description=chart_json.description,
                     chartType=get_standard_chart_type(chart_json.viz_type),
                     sourceUrl=f"{clean_uri(self.service_connection.hostPort)}/explore/?slice_id={chart_json.id}",
-                    service=self.context.dashboard_service,
+                    service=self.context.get().dashboard_service,
                 )
                 yield Either(right=chart)
             except Exception as exc:
@@ -234,7 +240,7 @@ class SupersetDBSource(SupersetSourceMixin):
                     data_model_request = CreateDashboardDataModelRequest(
                         name=chart_json.datasource_id,
                         displayName=chart_json.table_name,
-                        service=self.context.dashboard_service,
+                        service=self.context.get().dashboard_service,
                         columns=self.get_column_info(col_names),
                         dataModelType=DataModelType.SupersetDataModel.value,
                     )

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

@@ -11,6 +11,8 @@
 """
 Superset source module
 """
+from typing import Optional
+
 from metadata.generated.schema.entity.services.connections.dashboard.supersetConnection import (
     SupersetConnection,
 )
@@ -32,7 +34,12 @@ class SupersetSource:
     """
 
     @classmethod
-    def create(cls, config_dict: dict, metadata: OpenMetadata):
+    def create(
+        cls,
+        config_dict: dict,
+        metadata: OpenMetadata,
+        pipeline_name: Optional[str] = None,
+    ):
         config = WorkflowSource.parse_obj(config_dict)
         connection: SupersetConnection = config.serviceConnection.__root__.config
         if not isinstance(connection, SupersetConnection):