openmetadata-ingestion 1.5.13.0__py3-none-any.whl → 1.6.0.0rc2__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/{mstr → microstrategy}/client.py

@@ -9,19 +9,19 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 """
-REST Auth & Client for Mstr
+REST Auth & Client for MicroStrategy
 """
 import traceback
 from typing import List, Optional
 
 import requests
 
-from metadata.generated.schema.entity.services.connections.dashboard.mstrConnection import (
-    MstrConnection,
+from metadata.generated.schema.entity.services.connections.dashboard.microStrategyConnection import (
+    MicroStrategyConnection,
 )
 from metadata.ingestion.connections.test_connections import SourceConnectionException
 from metadata.ingestion.ometa.client import REST, ClientConfig
-from metadata.ingestion.source.dashboard.mstr.models import (
+from metadata.ingestion.source.dashboard.microstrategy.models import (
     AuthHeaderCookie,
     MstrDashboard,
     MstrDashboardDetails,
@@ -37,30 +37,29 @@ from metadata.utils.logger import ingestion_logger
 logger = ingestion_logger()
 
 API_VERSION = "MicroStrategyLibrary/api"
-LOGIN_MODE_GUEST = 1
 APPLICATION_TYPE = 35
 
 
-class MSTRClient:
+class MicroStrategyClient:
     """
     Client Handling API communication with Metabase
     """
 
     def _get_base_url(self, path=None):
         if not path:
-            return f"{clean_uri(self.config.hostPort)}/{API_VERSION}"
-        return f"{clean_uri(self.config.hostPort)}/{API_VERSION}/{path}"
+            return f"{clean_uri(str(self.config.hostPort))}/{API_VERSION}"
+        return f"{clean_uri(str(self.config.hostPort))}/{API_VERSION}/{path}"
 
     def __init__(
         self,
-        config: MstrConnection,
+        config: MicroStrategyConnection,
     ):
         self.config = config
 
         self.auth_params: AuthHeaderCookie = self._get_auth_header_and_cookies()
 
         client_config = ClientConfig(
-            base_url=clean_uri(config.hostPort),
+            base_url=clean_uri(str(self.config.hostPort)),
             api_version=API_VERSION,
             extra_headers=self.auth_params.auth_header,
             allow_redirects=True,
@@ -77,31 +76,27 @@ class MSTRClient:
         To know about the data params below please visit
         https://demo.microstrategy.com/MicroStrategyLibrary/api-docs/index.html#/Authentication/postLogin
         """
-        data = {
-            "username": self.config.username,
-            "password": self.config.password.get_secret_value(),
-            "loginMode": LOGIN_MODE_GUEST,
-            "applicationType": APPLICATION_TYPE,
-        }
-        response = requests.post(
-            url=self._get_base_url("auth/login"), data=data, timeout=60
-        )
-        if not response.status_code == 204:
-            logger.error(
-                f"Auth Failed with login mode: {LOGIN_MODE_GUEST}, Error: {response.text}"
-            )
-            logger.error("Trying with login mode: 8")
-            data["loginMode"] = 8
+        try:
+            data = {
+                "username": self.config.username,
+                "password": self.config.password.get_secret_value(),
+                "loginMode": self.config.loginMode,
+                "applicationType": APPLICATION_TYPE,
+            }
             response = requests.post(
                 url=self._get_base_url("auth/login"), data=data, timeout=60
             )
-            if not response.status_code == 204:
-                raise SourceConnectionException(
-                    f"Auth Failed with login mode: 8 and {LOGIN_MODE_GUEST}, Error: {response.text}"
-                )
-        return AuthHeaderCookie(
-            auth_header=response.headers, auth_cookies=response.cookies
-        )
+            if not response:
+                raise SourceConnectionException()
+            return AuthHeaderCookie(
+                auth_header=response.headers, auth_cookies=response.cookies
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(
+                f"Failed to fetch the auth header and cookies due to [{exc}], please validate credentials"
+            )
+        return None
 
     def _set_api_session(self) -> bool:
         """

metadata/ingestion/source/dashboard/{mstr → microstrategy}/connection.py

@@ -17,31 +17,29 @@ from typing import Optional
 from metadata.generated.schema.entity.automations.workflow import (
     Workflow as AutomationWorkflow,
 )
-from metadata.generated.schema.entity.services.connections.dashboard.mstrConnection import (
-    MstrConnection,
+from metadata.generated.schema.entity.services.connections.dashboard.microStrategyConnection import (
+    MicroStrategyConnection,
 )
 from metadata.generated.schema.entity.services.connections.testConnectionResult import (
     TestConnectionResult,
 )
 from metadata.ingestion.connections.test_connections import test_connection_steps
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.ingestion.source.dashboard.mstr.client import MSTRClient
-from metadata.utils.constants import THREE_MIN
+from metadata.ingestion.source.dashboard.microstrategy.client import MicroStrategyClient
 
 
-def get_connection(connection: MstrConnection) -> MSTRClient:
+def get_connection(connection: MicroStrategyConnection) -> MicroStrategyClient:
     """
     Create connection
     """
-    return MSTRClient(connection)
+    return MicroStrategyClient(connection)
 
 
 def test_connection(
     metadata: OpenMetadata,
-    client: MSTRClient,
-    service_connection: MstrConnection,
+    client: MicroStrategyClient,
+    service_connection: MicroStrategyConnection,
     automation_workflow: Optional[AutomationWorkflow] = None,
-    timeout_seconds: Optional[int] = THREE_MIN,
 ) -> TestConnectionResult:
     """
     Test connection. This can be executed either as part
@@ -55,5 +53,4 @@ def test_connection(
         test_fn=test_fn,
         service_type=service_connection.type.value,
         automation_workflow=automation_workflow,
-        timeout_seconds=timeout_seconds,
     )

metadata/ingestion/source/dashboard/{mstr → microstrategy}/metadata.py

@@ -8,7 +8,7 @@
 #  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.
-"""Mstr source module"""
+"""MicroStrategy source module"""
 import traceback
 from typing import Iterable, List, Optional
 
@@ -16,8 +16,8 @@ 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
-from metadata.generated.schema.entity.services.connections.dashboard.mstrConnection import (
-    MstrConnection,
+from metadata.generated.schema.entity.services.connections.dashboard.microStrategyConnection import (
+    MicroStrategyConnection,
 )
 from metadata.generated.schema.entity.services.ingestionPipelines.status import (
     StackTraceError,
@@ -34,7 +34,7 @@ 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
-from metadata.ingestion.source.dashboard.mstr.models import (
+from metadata.ingestion.source.dashboard.microstrategy.models import (
     MstrDashboard,
     MstrDashboardDetails,
     MstrPage,
@@ -47,9 +47,9 @@ from metadata.utils.logger import ingestion_logger
 logger = ingestion_logger()
 
 
-class MstrSource(DashboardServiceSource):
+class MicrostrategySource(DashboardServiceSource):
     """
-    MSTR Source Class
+    Microstrategy Source Class
     """
 
     @classmethod
@@ -60,10 +60,10 @@ class MstrSource(DashboardServiceSource):
         pipeline_name: Optional[str] = None,
     ):
         config = WorkflowSource.model_validate(config_dict)
-        connection: MstrConnection = config.serviceConnection.root.config
-        if not isinstance(connection, MstrConnection):
+        connection: MicroStrategyConnection = config.serviceConnection.root.config
+        if not isinstance(connection, MicroStrategyConnection):
             raise InvalidSourceException(
-                f"Expected MstrConnection, but got {connection}"
+                f"Expected MicroStrategyConnection, but got {connection}"
             )
         return cls(config, metadata)
 
@@ -75,14 +75,18 @@ class MstrSource(DashboardServiceSource):
 
         if self.client.is_project_name():
             project = self.client.get_project_by_name()
-            dashboards.extend(self.client.get_dashboards_list(project.id, project.name))
-
-        if not self.client.is_project_name():
-            for project in self.client.get_projects_list():
+            if project:
                 dashboards.extend(
                     self.client.get_dashboards_list(project.id, project.name)
                 )
 
+        if not self.client.is_project_name():
+            for project in self.client.get_projects_list():
+                if project:
+                    dashboards.extend(
+                        self.client.get_dashboards_list(project.id, project.name)
+                    )
+
         return dashboards
 
     def get_dashboard_name(self, dashboard: MstrDashboard) -> str:
@@ -121,7 +125,7 @@ class MstrSource(DashboardServiceSource):
         if dashboard_details:
             try:
                 dashboard_url = (
-                    f"{clean_uri(self.service_connection.hostPort)}/MicroStrategyLibrary/app/"
+                    f"{clean_uri(str(self.service_connection.hostPort))}/MicroStrategyLibrary/app/"
                     f"{dashboard_details.projectId}/{dashboard_details.id}"
                 )
                 dashboard_request = CreateDashboardRequest(

metadata/ingestion/source/dashboard/{mstr → microstrategy}/models.py

@@ -9,7 +9,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 """
-MSTR Models
+MicroStrategy Models
 """
 from datetime import datetime
 from typing import Any, List, Optional