openmetadata-ingestion 1.2.5.2__py3-none-any.whl → 1.3.0.0__py3-none-any.whl

metadata/ingestion/ometa/mixins/user_mixin.py

@@ -13,12 +13,15 @@ Mixin class containing User specific methods
 
 To be used by OpenMetadata class
 """
-import traceback
 from functools import lru_cache
-from typing import Optional
+from typing import Optional, Type
 
+from metadata.generated.schema.entity.teams.team import Team
 from metadata.generated.schema.entity.teams.user import User
+from metadata.generated.schema.type.entityReference import EntityReference
+from metadata.ingestion.api.common import T
 from metadata.ingestion.ometa.client import REST
+from metadata.utils.constants import ENTITY_REFERENCE_TYPE_MAP
 from metadata.utils.elasticsearch import ES_INDEX_MAP
 from metadata.utils.logger import ometa_logger
 
@@ -34,42 +37,134 @@ class OMetaUserMixin:
 
     client: REST
 
-    email_search = (
-        "/search/query?q=email.keyword:{email}&from={from_}&size={size}&index="
-        + ES_INDEX_MAP[User.__name__]
-    )
+    @staticmethod
+    def email_search_query_es(entity: Type[T]) -> str:
+        return (
+            "/search/query?q=email.keyword:{email}&from={from_}&size={size}&index="
+            + ES_INDEX_MAP[entity.__name__]
+        )
 
-    @lru_cache(maxsize=None)
-    def get_user_by_email(
+    @staticmethod
+    def name_search_query_es(entity: Type[T]) -> str:
+        """
+        Allow for more flexible lookup following what the UI is doing when searching users.
+
+        We don't want to stick to `q=name:{name}` since in case a user is named `random.user`
+        but looked as `Random User`, we want to find this match.
+        """
+        return (
+            "/search/query?q={name}&from={from_}&size={size}&index="
+            + ES_INDEX_MAP[entity.__name__]
+        )
+
+    def _search_by_email(
         self,
+        entity: Type[T],
         email: Optional[str],
         from_count: int = 0,
         size: int = 1,
         fields: Optional[list] = None,
-    ) -> Optional[User]:
+    ) -> Optional[T]:
         """
-        GET user entity by name
+        GET user or team entity by mail
 
         Args:
             email: user email to search
             from_count: records to expect
             size: number of records
+            fields: Optional field list to pass to ES request
         """
         if email:
-            query_string = self.email_search.format(
+            query_string = self.email_search_query_es(entity=entity).format(
                 email=email, from_=from_count, size=size
             )
+            return self._get_entity_from_es(
+                entity=entity, query_string=query_string, fields=fields
+            )
+
+        return None
+
+    def _search_by_name(
+        self,
+        entity: Type[T],
+        name: Optional[str],
+        from_count: int = 0,
+        size: int = 1,
+        fields: Optional[list] = None,
+    ) -> Optional[T]:
+        """
+        GET entity by name
+
+        Args:
+            name: user name to search
+            from_count: records to expect
+            size: number of records
+            fields: Optional field list to pass to ES request
+        """
+        if name:
+            query_string = self.name_search_query_es(entity=entity).format(
+                name=name, from_=from_count, size=size
+            )
+            return self._get_entity_from_es(
+                entity=entity, query_string=query_string, fields=fields
+            )
 
-            try:
-                entity_list = self._search_es_entity(
-                    entity_type=User, query_string=query_string, fields=fields
-                )
-                for user in entity_list or []:
-                    return user
-            except Exception as err:
-                logger.debug(traceback.format_exc())
-                logger.warning(
-                    f"Could not get user info from ES for user email {email} due to {err}"
-                )
+        return None
+
+    @lru_cache(maxsize=None)
+    def get_reference_by_email(
+        self,
+        email: Optional[str],
+        from_count: int = 0,
+        size: int = 1,
+        fields: Optional[list] = None,
+    ) -> Optional[EntityReference]:
+        """
+        Get a User or Team Entity Reference by searching by its mail
+        """
+        maybe_user = self._search_by_email(
+            entity=User, email=email, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_user:
+            return EntityReference(
+                id=maybe_user.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[User.__name__]
+            )
+
+        maybe_team = self._search_by_email(
+            entity=Team, email=email, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_team:
+            return EntityReference(
+                id=maybe_team.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__]
+            )
+
+        return None
+
+    @lru_cache(maxsize=None)
+    def get_reference_by_name(
+        self,
+        name: Optional[str],
+        from_count: int = 0,
+        size: int = 1,
+        fields: Optional[list] = None,
+    ) -> Optional[EntityReference]:
+        """
+        Get a User or Team Entity Reference by searching by its name
+        """
+        maybe_user = self._search_by_name(
+            entity=User, name=name, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_user:
+            return EntityReference(
+                id=maybe_user.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[User.__name__]
+            )
+
+        maybe_team = self._search_by_name(
+            entity=Team, name=name, from_count=from_count, size=size, fields=fields
+        )
+        if maybe_team:
+            return EntityReference(
+                id=maybe_team.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__]
+            )
 
         return None

metadata/ingestion/ometa/ometa_api.py

@@ -31,7 +31,7 @@ from metadata.generated.schema.type.basic import FullyQualifiedEntityName
 from metadata.generated.schema.type.entityHistory import EntityVersionHistory
 from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.ingestion.models.encoders import show_secrets_encoder
-from metadata.ingestion.ometa.auth_provider import AuthenticationProvider
+from metadata.ingestion.ometa.auth_provider import OpenMetadataAuthenticationProvider
 from metadata.ingestion.ometa.client import REST, APIError, ClientConfig
 from metadata.ingestion.ometa.mixins.custom_property_mixin import (
     OMetaCustomPropertyMixin,
@@ -39,7 +39,6 @@ from metadata.ingestion.ometa.mixins.custom_property_mixin import (
 from metadata.ingestion.ometa.mixins.dashboard_mixin import OMetaDashboardMixin
 from metadata.ingestion.ometa.mixins.data_insight_mixin import DataInsightMixin
 from metadata.ingestion.ometa.mixins.es_mixin import ESMixin
-from metadata.ingestion.ometa.mixins.glossary_mixin import GlossaryMixin
 from metadata.ingestion.ometa.mixins.ingestion_pipeline_mixin import (
     OMetaIngestionPipelineMixin,
 )
@@ -51,16 +50,13 @@ from metadata.ingestion.ometa.mixins.role_policy_mixin import OMetaRolePolicyMix
 from metadata.ingestion.ometa.mixins.search_index_mixin import OMetaSearchIndexMixin
 from metadata.ingestion.ometa.mixins.server_mixin import OMetaServerMixin
 from metadata.ingestion.ometa.mixins.service_mixin import OMetaServiceMixin
+from metadata.ingestion.ometa.mixins.suggestions_mixin import OMetaSuggestionsMixin
 from metadata.ingestion.ometa.mixins.table_mixin import OMetaTableMixin
 from metadata.ingestion.ometa.mixins.tests_mixin import OMetaTestsMixin
 from metadata.ingestion.ometa.mixins.topic_mixin import OMetaTopicMixin
 from metadata.ingestion.ometa.mixins.user_mixin import OMetaUserMixin
 from metadata.ingestion.ometa.mixins.version_mixin import OMetaVersionMixin
 from metadata.ingestion.ometa.models import EntityList
-from metadata.ingestion.ometa.provider_registry import (
-    InvalidAuthProviderException,
-    auth_provider_registry,
-)
 from metadata.ingestion.ometa.routes import ROUTES
 from metadata.ingestion.ometa.utils import get_entity_type, model_str
 from metadata.utils.logger import ometa_logger
@@ -100,7 +96,6 @@ class OpenMetadata(
     OMetaTableMixin,
     OMetaTopicMixin,
     OMetaVersionMixin,
-    GlossaryMixin,
     OMetaServiceMixin,
     ESMixin,
     OMetaServerMixin,
@@ -114,6 +109,7 @@ class OpenMetadata(
     OMetaRolePolicyMixin,
     OMetaSearchIndexMixin,
     OMetaCustomPropertyMixin,
+    OMetaSuggestionsMixin,
     Generic[T, C],
 ):
     """
@@ -125,7 +121,7 @@ class OpenMetadata(
     """
 
     client: REST
-    _auth_provider: AuthenticationProvider
+    _auth_provider: OpenMetadataAuthenticationProvider
     config: OpenMetadataConnection
 
     class_root = ".".join(["metadata", "generated", "schema"])
@@ -146,16 +142,7 @@ class OpenMetadata(
             config.secretsManagerLoader,
         ).get_secrets_manager()
 
-        # Load the auth provider init from the registry
-        auth_provider_fn = auth_provider_registry.registry.get(
-            self.config.authProvider.value
-        )
-        if not auth_provider_fn:
-            raise InvalidAuthProviderException(
-                f"Cannot find {self.config.authProvider.value} in {auth_provider_registry.registry}"
-            )
-
-        self._auth_provider = auth_provider_fn(self.config)
+        self._auth_provider = OpenMetadataAuthenticationProvider.create(self.config)
 
         get_verify_ssl = get_verify_ssl_fn(self.config.verifySSL)
 
@@ -261,11 +248,9 @@ class OpenMetadata(
         )
         return entity_class
 
-    def create_or_update(self, data: C) -> T:
+    def _create(self, data: C, method: str) -> T:
         """
-        We allow CreateEntity for PUT, so we expect a type C.
-
-        We PUT to the endpoint and return the Entity generated result
+        Internal logic to run POST vs. PUT
         """
         entity = data.__class__
         is_create = "create" in data.__class__.__name__.lower()
@@ -277,15 +262,23 @@ class OpenMetadata(
             raise InvalidEntityException(
                 f"PUT operations need a CreateEntity, not {entity}"
             )
-        resp = self.client.put(
-            self.get_suffix(entity), data=data.json(encoder=show_secrets_encoder)
-        )
+
+        fn = getattr(self.client, method)
+        resp = fn(self.get_suffix(entity), data=data.json(encoder=show_secrets_encoder))
         if not resp:
             raise EmptyPayloadException(
                 f"Got an empty response when trying to PUT to {self.get_suffix(entity)}, {data.json()}"
             )
         return entity_class(**resp)
 
+    def create_or_update(self, data: C) -> T:
+        """Run a PUT requesting via create request C"""
+        return self._create(data=data, method="put")
+
+    def create(self, data: C) -> T:
+        """Run a POST requesting via create request C"""
+        return self._create(data=data, method="post")
+
     def get_by_name(
         self,
         entity: Type[T],

metadata/ingestion/ometa/routes.py

@@ -50,6 +50,7 @@ from metadata.generated.schema.api.domains.createDataProduct import (
     CreateDataProductRequest,
 )
 from metadata.generated.schema.api.domains.createDomain import CreateDomainRequest
+from metadata.generated.schema.api.feed.createSuggestion import CreateSuggestionRequest
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
 from metadata.generated.schema.api.policies.createPolicy import CreatePolicyRequest
 from metadata.generated.schema.api.services.createDashboardService import (
@@ -90,6 +91,7 @@ from metadata.generated.schema.api.tests.createTestSuite import CreateTestSuiteR
 from metadata.generated.schema.dataInsight.dataInsightChart import DataInsightChart
 from metadata.generated.schema.dataInsight.kpi.kpi import Kpi
 from metadata.generated.schema.entity.automations.workflow import Workflow
+from metadata.generated.schema.entity.bot import Bot
 from metadata.generated.schema.entity.classification.classification import (
     Classification,
 )
@@ -113,6 +115,7 @@ from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.data.topic import Topic
 from metadata.generated.schema.entity.domains.dataProduct import DataProduct
 from metadata.generated.schema.entity.domains.domain import Domain
+from metadata.generated.schema.entity.feed.suggestion import Suggestion
 from metadata.generated.schema.entity.policies.policy import Policy
 from metadata.generated.schema.entity.services.connections.testConnectionDefinition import (
     TestConnectionDefinition,
@@ -181,6 +184,7 @@ ROUTES = {
     User.__name__: "/users",
     CreateUserRequest.__name__: "/users",
     AuthenticationMechanism.__name__: "/users/auth-mechanism",
+    Bot.__name__: "/bots",  # We won't allow bot creation from the client
     # Roles
     Role.__name__: "/roles",
     CreateRoleRequest.__name__: "/roles",
@@ -225,4 +229,7 @@ ROUTES = {
     CreateDomainRequest.__name__: "/domains",
     DataProduct.__name__: "/dataProducts",
     CreateDataProductRequest.__name__: "/dataProducts",
+    # Suggestions
+    Suggestion.__name__: "/suggestions",
+    CreateSuggestionRequest.__name__: "/suggestions",
 }

metadata/ingestion/processor/query_parser.py

@@ -17,10 +17,13 @@ import traceback
 from typing import Optional
 
 from metadata.config.common import ConfigModel
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.type.basic import DateTime
 from metadata.generated.schema.type.queryParserData import ParsedData, QueryParserData
 from metadata.generated.schema.type.tableQuery import TableQueries, TableQuery
-from metadata.ingestion.api.models import Either, StackTraceError
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import Processor
 from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper, Dialect
 from metadata.ingestion.lineage.parser import LineageParser
@@ -84,6 +87,10 @@ class QueryParserProcessor(Processor):
         self.metadata = metadata
         self.connection_type = connection_type
 
+    @property
+    def name(self) -> str:
+        return "Query Parser"
+
     @classmethod
     def create(cls, config_dict: dict, metadata: OpenMetadata, **kwargs):
         config = ConfigModel.parse_obj(config_dict)
@@ -106,7 +113,7 @@ class QueryParserProcessor(Processor):
                         left=StackTraceError(
                             name="Query",
                             error=f"Error processing query [{table_query.query}]: {exc}",
-                            stack_trace=traceback.format_exc(),
+                            stackTrace=traceback.format_exc(),
                         )
                     )
 

metadata/ingestion/sink/metadata_rest.py

@@ -47,6 +47,9 @@ from metadata.generated.schema.entity.teams.team import Team
 from metadata.generated.schema.entity.teams.user import User
 from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase
+from metadata.generated.schema.tests.testCaseResolutionStatus import (
+    TestCaseResolutionStatus,
+)
 from metadata.generated.schema.tests.testSuite import TestSuite
 from metadata.generated.schema.type.schema import Topic
 from metadata.ingestion.api.models import Either, Entity, StackTraceError
@@ -60,6 +63,7 @@ from metadata.ingestion.models.ometa_topic_data import OMetaTopicSampleData
 from metadata.ingestion.models.patch_request import (
     ALLOWED_COMMON_PATCH_FIELDS,
     RESTRICT_UPDATE_LIST,
+    PatchedEntity,
     PatchRequest,
 )
 from metadata.ingestion.models.pipeline_status import OMetaPipelineStatus
@@ -67,6 +71,7 @@ from metadata.ingestion.models.profile_data import OMetaTableProfileSampleData
 from metadata.ingestion.models.search_index_data import OMetaIndexSampleData
 from metadata.ingestion.models.tests_data import (
     OMetaLogicalTestSuiteSample,
+    OMetaTestCaseResolutionStatus,
     OMetaTestCaseResultsSample,
     OMetaTestCaseSample,
     OMetaTestSuiteSample,
@@ -115,6 +120,10 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         config = MetadataRestSinkConfig.parse_obj(config_dict)
         return cls(config, metadata)
 
+    @property
+    def name(self) -> str:
+        return "OpenMetadata"
+
     @singledispatchmethod
     def _run_dispatch(self, record: Entity) -> Either[Any]:
         logger.debug(f"Processing Create request {type(record)}")
@@ -132,14 +141,14 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             error = f"Failed to ingest {log} due to api request failure: {err}"
             return Either(
                 left=StackTraceError(
-                    name=log, error=error, stack_trace=traceback.format_exc()
+                    name=log, error=error, stackTrace=traceback.format_exc()
                 )
             )
         except Exception as exc:
             error = f"Failed to ingest {log}: {exc}"
             return Either(
                 left=StackTraceError(
-                    name=log, error=error, stack_trace=traceback.format_exc()
+                    name=log, error=error, stackTrace=traceback.format_exc()
                 )
             )
 
@@ -155,7 +164,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         error = f"Failed to ingest {type(entity_request).__name__}"
         return Either(
             left=StackTraceError(
-                name=type(entity_request).__name__, error=error, stack_trace=None
+                name=type(entity_request).__name__, error=error, stackTrace=None
             )
         )
 
@@ -171,7 +180,8 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             allowed_fields=ALLOWED_COMMON_PATCH_FIELDS,
             restrict_update_fields=RESTRICT_UPDATE_LIST,
         )
-        return Either(right=entity)
+        patched_entity = PatchedEntity(new_entity=entity) if entity else None
+        return Either(right=patched_entity)
 
     @_run_dispatch.register
     def write_custom_properties(self, record: OMetaCustomProperties) -> Either[Dict]:
@@ -200,7 +210,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             left=StackTraceError(
                 name="Data Model",
                 error="Sink did not receive a table. We cannot ingest the data model.",
-                stack_trace=None,
+                stackTrace=None,
             )
         )
 
@@ -275,7 +285,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             for role in record.roles:
                 try:
                     role_entity = self.metadata.get_by_name(
-                        entity=Role, fqn=str(role.name.__root__.__root__)
+                        entity=Role, fqn=str(role.name.__root__)
                     )
                 except APIError:
                     role_entity = self._create_role(role)
@@ -411,6 +421,15 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         )
         return Either(right=res)
 
+    @_run_dispatch.register
+    def write_test_case_resolution_status(
+        self, record: OMetaTestCaseResolutionStatus
+    ) -> TestCaseResolutionStatus:
+        """For sample data"""
+        res = self.metadata.create_test_case_resolution(record.test_case_resolution)
+
+        return Either(right=res)
+
     @_run_dispatch.register
     def write_data_insight_sample(
         self, record: OMetaDataInsightSample

metadata/ingestion/source/dashboard/dashboard_service.py

@@ -34,7 +34,6 @@ from metadata.generated.schema.entity.services.dashboardService import (
     DashboardConnection,
     DashboardService,
 )
-from metadata.generated.schema.entity.teams.user import User
 from metadata.generated.schema.metadataIngestion.dashboardServiceMetadataPipeline import (
     DashboardServiceMetadataPipeline,
 )
@@ -55,8 +54,8 @@ from metadata.ingestion.models.patch_request import PatchRequest
 from metadata.ingestion.models.topology import (
     NodeStage,
     ServiceTopology,
+    TopologyContext,
     TopologyNode,
-    create_source_context,
 )
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.connections import get_connection, get_test_connection_fn
@@ -105,7 +104,7 @@ class DashboardServiceTopology(ServiceTopology):
             ),
             NodeStage(
                 type_=OMetaTagAndClassification,
-                processor="yield_tag",
+                processor="yield_bulk_tags",
                 nullable=True,
             ),
         ],
@@ -133,14 +132,19 @@ class DashboardServiceTopology(ServiceTopology):
     dashboard = TopologyNode(
         producer="get_dashboard",
         stages=[
+            NodeStage(
+                type_=OMetaTagAndClassification,
+                processor="yield_tags",
+                nullable=True,
+            ),
             NodeStage(
                 type_=Chart,
                 context="charts",
                 processor="yield_dashboard_chart",
                 consumer=["dashboard_service"],
                 nullable=True,
-                cache_all=True,
-                clear_cache=True,
+                store_all_in_context=True,
+                clear_context=True,
                 use_cache=True,
             ),
             NodeStage(
@@ -149,8 +153,8 @@ class DashboardServiceTopology(ServiceTopology):
                 processor="yield_datamodel",
                 consumer=["dashboard_service"],
                 nullable=True,
-                cache_all=True,
-                clear_cache=True,
+                store_all_in_context=True,
+                clear_context=True,
                 use_cache=True,
             ),
             NodeStage(
@@ -160,12 +164,6 @@ class DashboardServiceTopology(ServiceTopology):
                 consumer=["dashboard_service"],
                 use_cache=True,
             ),
-            NodeStage(
-                type_=User,
-                context="owner",
-                processor="process_owner",
-                consumer=["dashboard_service"],
-            ),
             NodeStage(
                 type_=AddLineageRequest,
                 processor="yield_dashboard_lineage",
@@ -196,7 +194,7 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
     service_connection: DashboardConnection.__fields__["config"].type_
 
     topology = DashboardServiceTopology()
-    context = create_source_context(topology)
+    context = TopologyContext.create(topology)
     dashboard_source_state: Set = set()
     datamodel_source_state: Set = set()
 
@@ -218,6 +216,10 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
         self.connection_obj = self.client
         self.test_connection()
 
+    @property
+    def name(self) -> str:
+        return self.service_connection.type.name
+
     @abstractmethod
     def yield_dashboard(
         self, dashboard_details: Any
@@ -333,7 +335,16 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
                 dashboard_details, db_service_name
             ) or []
 
-    def yield_tag(self, *args, **kwargs) -> Iterable[Either[OMetaTagAndClassification]]:
+    def yield_bulk_tags(
+        self, *args, **kwargs
+    ) -> Iterable[Either[OMetaTagAndClassification]]:
+        """
+        Method to bulk fetch dashboard tags
+        """
+
+    def yield_tags(
+        self, dashboard_details
+    ) -> Iterable[Either[OMetaTagAndClassification]]:
         """
         Method to fetch dashboard tags
         """
@@ -386,34 +397,16 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
                 params={"service": self.context.dashboard_service},
             )
 
-    def process_owner(self, dashboard_details):
+    def get_owner_ref(  # pylint: disable=unused-argument, useless-return
+        self, dashboard_details
+    ) -> Optional[EntityReference]:
         """
-        Method to process the dashboard onwers
+        Method to process the dashboard owners
         """
-        try:
-            if self.source_config.includeOwners:
-                owner = self.get_owner_details(  # pylint: disable=assignment-from-none
-                    dashboard_details=dashboard_details
-                )
-                if owner:
-                    dashboard_fqn = fqn.build(
-                        self.metadata,
-                        entity_type=Dashboard,
-                        service_name=self.context.dashboard_service,
-                        dashboard_name=self.context.dashboard,
-                    )
-                    dashboard_entity = self.metadata.get_by_name(
-                        entity=Dashboard, fqn=dashboard_fqn
-                    )
-                    self.metadata.patch_owner(
-                        entity=Dashboard,
-                        source=dashboard_entity,
-                        owner=owner,
-                        force=False,
-                    )
-        except Exception as exc:
-            logger.debug(traceback.format_exc())
-            logger.warning(f"Error processing owner for {dashboard_details}: {exc}")
+        logger.debug(
+            f"Processing ownership is not supported for {self.service_connection.type.name}"
+        )
+        return None
 
     def register_record(self, dashboard_request: CreateDashboardRequest) -> None:
         """
@@ -429,7 +422,7 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
         self.dashboard_source_state.add(dashboard_fqn)
 
     def register_record_datamodel(
-        self, datamodel_requst: CreateDashboardDataModelRequest
+        self, datamodel_request: CreateDashboardDataModelRequest
     ) -> None:
         """
         Mark the datamodel record as scanned and update the datamodel_source_state
@@ -437,27 +430,12 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
         datamodel_fqn = fqn.build(
             self.metadata,
             entity_type=DashboardDataModel,
-            service_name=datamodel_requst.service.__root__,
-            data_model_name=datamodel_requst.name.__root__,
+            service_name=datamodel_request.service.__root__,
+            data_model_name=datamodel_request.name.__root__,
         )
 
         self.datamodel_source_state.add(datamodel_fqn)
 
-    def get_owner_details(  # pylint: disable=useless-return
-        self, dashboard_details  # pylint: disable=unused-argument
-    ) -> Optional[EntityReference]:
-        """Get dashboard owner
-
-        Args:
-            dashboard_details:
-        Returns:
-            Optional[EntityReference]
-        """
-        logger.debug(
-            f"Processing ownership is not supported for {self.service_connection.type.name}"
-        )
-        return None
-
     @staticmethod
     def _get_add_lineage_request(
         to_entity: Union[Dashboard, DashboardDataModel],
@@ -505,7 +483,7 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
                 self.context.project_name = (  # pylint: disable=assignment-from-none
                     self.get_project_name(dashboard_details=dashboard_details)
                 )
-                if self.context.project_name and filter_by_project(
+                if filter_by_project(
                     self.source_config.projectFilterPattern,
                     self.context.project_name,
                 ):
@@ -553,7 +531,6 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
         )
 
     def check_database_schema_name(self, database_schema_name: str):
-
         """
         Check if the input database schema name is equal to "<default>" and return the input name if it is not.