openmetadata-ingestion 1.6.7.0__py3-none-any.whl → 1.7.0.0rc1__py3-none-any.whl

metadata/ingestion/source/database/bigquery/metadata.py

@@ -8,6 +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.
+# pylint: disable=too-many-lines
 """
 Bigquery source module
 """
@@ -51,6 +52,9 @@ from metadata.generated.schema.entity.services.ingestionPipelines.status import
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
+from metadata.generated.schema.security.credentials.gcpExternalAccount import (
+    GcpExternalAccount,
+)
 from metadata.generated.schema.security.credentials.gcpValues import (
     GcpCredentialsValues,
 )
@@ -100,6 +104,7 @@ from metadata.utils import fqn
 from metadata.utils.credentials import GOOGLE_CREDENTIALS
 from metadata.utils.execution_time_tracker import calculate_execution_time
 from metadata.utils.filters import filter_by_database, filter_by_schema
+from metadata.utils.helpers import retry_with_docker_host
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.sqlalchemy_utils import (
     get_all_table_ddls,
@@ -165,12 +170,17 @@ def get_columns(bq_schema):
             "precision": field.precision,
             "scale": field.scale,
             "max_length": field.max_length,
-            "system_data_type": _array_sys_data_type_repr(col_type)
-            if str(col_type) == "ARRAY"
-            else str(col_type),
+            "system_data_type": (
+                _array_sys_data_type_repr(col_type)
+                if str(col_type) == "ARRAY"
+                else str(col_type)
+            ),
             "is_complex": is_complex_type(str(col_type)),
             "policy_tags": None,
         }
+        if getattr(field, "fields", None):
+            # Nested Columns available
+            col_obj["children"] = get_columns(field.fields)
         try:
             if field.policy_tags:
                 policy_tag_name = field.policy_tags.names[0]
@@ -226,6 +236,7 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
     Database metadata from Bigquery Source
     """
 
+    @retry_with_docker_host()
     def __init__(self, config, metadata, incremental_configuration: IncrementalConfig):
         # Check if the engine is established before setting project IDs
         # This ensures that we don't try to set project IDs when there is no engine
@@ -238,7 +249,7 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
         # Upon invoking the set_project_id method, we retrieve a comprehensive
         # list of all project IDs. Subsequently, after the invokation,
         # we proceed to test the connections for each of these project IDs
-        self.project_ids = self.set_project_id()
+        self.project_ids = self.set_project_id(self.service_connection)
         self.life_cycle_query = BIGQUERY_LIFE_CYCLE_QUERY
         self.test_connection = self._test_connection
         self.test_connection()
@@ -271,9 +282,62 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
         return cls(config, metadata, incremental_config)
 
     @staticmethod
-    def set_project_id() -> List[str]:
-        _, project_ids = auth.default()
-        return project_ids if isinstance(project_ids, list) else [project_ids]
+    def set_project_id(
+        service_connection: Optional[BigQueryConnection] = None,
+    ) -> List[str]:
+        """
+        Get the project ID from the service connection or ADC.
+
+        Args:
+            service_connection: Optional BigQuery connection config
+
+        Returns:
+            List of project IDs to scan
+
+        Raises:
+            InvalidSourceException: If unable to get project IDs from either config or ADC
+        """
+        try:
+
+            # TODO: Add support for fetching project ids from resource manager
+            # Bigquery resource manager for fetching project ids
+            # "google-cloud-resource-manager~=1.14.1",
+            # "grpc-google-iam-v1~=0.14.0",
+
+            # First check if project ID is configured in service connection
+            if (
+                service_connection
+                and hasattr(service_connection, "credentials")
+                and hasattr(service_connection.credentials, "gcpConfig")
+            ):
+                gcp_config = service_connection.credentials.gcpConfig
+                try:
+                    # Allow for multiple project IDs in the service connection
+                    if not isinstance(gcp_config, GcpExternalAccount) and getattr(
+                        gcp_config, "projectId", None
+                    ):
+                        if isinstance(gcp_config.projectId.root, list):
+                            return gcp_config.projectId.root
+                        return [gcp_config.projectId.root]
+                except Exception as exc:
+                    logger.warning(f"Error getting project ID, falling back: {exc}")
+
+            # Fallback to ADC default project
+            try:
+                _, project_id = auth.default()
+                if project_id:
+                    return [project_id] if isinstance(project_id, str) else project_id
+            except Exception as exc:
+                logger.warning(f"Error getting default project from ADC: {exc}")
+
+            raise InvalidSourceException(
+                "Unable to get project IDs. Either configure project IDs in the connection or "
+                "ensure Application Default Credentials are set up correctly."
+            )
+
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            raise InvalidSourceException(f"Error setting BigQuery project IDs: {exc}")
 
     def _test_connection(self) -> None:
         for project_id in self.project_ids:
@@ -367,6 +431,8 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
                         tag_description="Bigquery Dataset Label",
                         classification_description="BigQuery Dataset Classification",
                         include_tags=self.source_config.includeTags,
+                        metadata=self.metadata,
+                        system_tags=True,
                     )
             # Fetching policy tags on the column level
             list_project_ids = [self.context.get().database]
@@ -387,6 +453,8 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
                         tag_description="Bigquery Policy Tag",
                         classification_description="BigQuery Policy Classification",
                         include_tags=self.source_config.includeTags,
+                        metadata=self.metadata,
+                        system_tags=True,
                     )
         except Exception as exc:
             yield Either(
@@ -529,6 +597,8 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
                     tag_description="Bigquery Table Label",
                     classification_description="BigQuery Table Classification",
                     include_tags=self.source_config.includeTags,
+                    metadata=self.metadata,
+                    system_tags=True,
                 )
 
     def get_tag_labels(self, table_name: str) -> Optional[List[TagLabel]]:
@@ -751,9 +821,11 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
                 return True, TablePartition(
                     columns=[
                         PartitionColumnDetails(
-                            columnName="_PARTITIONTIME"
-                            if table.time_partitioning.type_ == "HOUR"
-                            else "_PARTITIONDATE",
+                            columnName=(
+                                "_PARTITIONTIME"
+                                if table.time_partitioning.type_ == "HOUR"
+                                else "_PARTITIONDATE"
+                            ),
                             interval=str(table.time_partitioning.type_),
                             intervalType=PartitionIntervalTypes.INGESTION_TIME,
                         )

metadata/ingestion/source/database/bigquery/queries.py

@@ -32,7 +32,8 @@ BIGQUERY_STATEMENT = textwrap.dedent(
    end_time,
    query as query_text,
    null as schema_name,
-   total_slot_ms as duration
+   total_slot_ms as duration,
+   (total_bytes_billed / POWER(2, 40)) * {cost_per_tib} as cost
 FROM `region-{region}`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
 WHERE creation_time BETWEEN "{start_time}" AND "{end_time}"
   {filters}

metadata/ingestion/source/database/bigquery/query_parser.py

@@ -66,6 +66,7 @@ class BigqueryQueryParserSource(QueryParserSource, ABC):
             region=self.service_connection.usageLocation,
             filters=self.get_filters(),
             result_limit=self.source_config.resultLimit,
+            cost_per_tib=self.service_connection.costPerTB,
         )
 
     @staticmethod

metadata/ingestion/source/database/bigtable/metadata.py

@@ -36,7 +36,10 @@ from metadata.ingestion.source.database.bigtable.models import Row
 from metadata.ingestion.source.database.common_nosql_source import (
     SAMPLE_SIZE as GLOBAL_SAMPLE_SIZE,
 )
-from metadata.ingestion.source.database.common_nosql_source import CommonNoSQLSource
+from metadata.ingestion.source.database.common_nosql_source import (
+    CommonNoSQLSource,
+    TableNameAndType,
+)
 from metadata.ingestion.source.database.multi_db_source import MultiDBSource
 from metadata.utils.logger import ingestion_logger
 
@@ -114,7 +117,9 @@ class BigtableSource(CommonNoSQLSource, MultiDBSource):
             )
             raise
 
-    def get_table_name_list(self, schema_name: str) -> List[str]:
+    def query_table_names_and_types(
+        self, schema_name: str
+    ) -> Iterable[TableNameAndType]:
         project_id = self.context.get().database
         try:
             instance = self._get_instance(project_id, schema_name)
@@ -127,7 +132,10 @@ class BigtableSource(CommonNoSQLSource, MultiDBSource):
                     [project_id, instance.instance_id, table.table_id],
                     table,
                 )
-            return list(self.tables[project_id][schema_name].keys())
+            return [
+                TableNameAndType(name=table)
+                for table in self.tables[project_id][schema_name].keys()
+            ]
         except Exception as err:
             logger.debug(traceback.format_exc())
             # add context to the error message

metadata/ingestion/source/database/cassandra/connection.py

@@ -0,0 +1,138 @@
+#  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.
+
+"""
+Source connection handler
+"""
+from functools import partial
+from typing import Optional
+
+from cassandra.auth import PlainTextAuthProvider
+from cassandra.cluster import (
+    EXEC_PROFILE_DEFAULT,
+    Cluster,
+    ExecutionProfile,
+    ProtocolVersion,
+)
+from cassandra.cluster import Session as CassandraSession
+from pydantic import BaseModel
+
+from metadata.generated.schema.entity.automations.workflow import (
+    Workflow as AutomationWorkflow,
+)
+from metadata.generated.schema.entity.services.connections.database.cassandraConnection import (
+    CassandraConnection,
+)
+from metadata.generated.schema.entity.services.connections.testConnectionResult import (
+    TestConnectionResult,
+)
+from metadata.ingestion.connections.builders import init_empty_connection_arguments
+from metadata.ingestion.connections.test_connections import test_connection_steps
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.database.cassandra.queries import (
+    CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS,
+    CASSANDRA_GET_KEYSPACE_TABLES,
+    CASSANDRA_GET_KEYSPACES,
+    CASSANDRA_GET_RELEASE_VERSION,
+)
+from metadata.utils.constants import THREE_MIN
+
+
+def get_connection(connection: CassandraConnection):
+    """
+    Create connection
+    """
+
+    cluster_config = {}
+    if hasattr(connection.authType, "cloudConfig"):
+        cloud_config = connection.authType.cloudConfig
+        cluster_cloud_config = {
+            "connect_timeout": cloud_config.connectTimeout,
+            "use_default_tempdir": True,
+            "secure_connect_bundle": cloud_config.secureConnectBundle,
+        }
+        profile = ExecutionProfile(request_timeout=cloud_config.requestTimeout)
+        auth_provider = PlainTextAuthProvider("token", cloud_config.token)
+        cluster_config.update(
+            {
+                "cloud": cluster_cloud_config,
+                "auth_provider": auth_provider,
+                "execution_profiles": {EXEC_PROFILE_DEFAULT: profile},
+                "protocol_version": ProtocolVersion.V4,
+            }
+        )
+    else:
+        host, port = connection.hostPort.split(":")
+        cluster_config.update({"contact_points": [host], "port": port})
+        if connection.username and getattr(connection.authType, "password", None):
+            cluster_config["auth_provider"] = PlainTextAuthProvider(
+                username=connection.username,
+                password=connection.authType.password.get_secret_value(),
+            )
+
+    connection.connectionArguments = (
+        connection.connectionArguments or init_empty_connection_arguments()
+    )
+
+    cluster = Cluster(
+        **cluster_config,
+        ssl_context=connection.connectionArguments.root.get("ssl_context"),
+    )
+    session = cluster.connect()
+
+    return session
+
+
+def test_connection(
+    metadata: OpenMetadata,
+    session: CassandraSession,
+    service_connection: CassandraConnection,
+    automation_workflow: Optional[AutomationWorkflow] = None,
+    timeout_seconds: Optional[int] = THREE_MIN,
+) -> TestConnectionResult:
+    """
+    Test connection. This can be executed either as part
+    of a metadata workflow or during an Automation Workflow
+    """
+
+    class SchemaHolder(BaseModel):
+        schema: Optional[str] = None
+
+    holder = SchemaHolder()
+
+    def test_get_release_version(session: CassandraConnection):
+        session.execute(CASSANDRA_GET_RELEASE_VERSION)
+
+    def test_get_schemas(session: CassandraSession, holder_: SchemaHolder):
+        for keyspace in session.execute(CASSANDRA_GET_KEYSPACES):
+            holder_.schema = keyspace.keyspace_name
+            break
+
+    def test_get_tables(session: CassandraSession, holder_: SchemaHolder):
+        session.execute(CASSANDRA_GET_KEYSPACE_TABLES, [holder_.schema])
+
+    def test_get_views(session: CassandraSession, holder_: SchemaHolder):
+        session.execute(CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS, [holder_.schema])
+
+    test_fn = {
+        "CheckAccess": partial(test_get_release_version, session),
+        "GetSchemas": partial(test_get_schemas, session, holder),
+        "GetTables": partial(test_get_tables, session, holder),
+        "GetViews": partial(test_get_views, session, holder),
+    }
+
+    return test_connection_steps(
+        metadata=metadata,
+        test_fn=test_fn,
+        service_type=service_connection.type.value,
+        automation_workflow=automation_workflow,
+        timeout_seconds=timeout_seconds,
+    )

metadata/ingestion/source/database/cassandra/helpers.py

@@ -0,0 +1,100 @@
+#  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.
+"""
+Cassandra source helpers.
+"""
+from __future__ import annotations
+
+from metadata.generated.schema.entity.data.table import Column, DataType
+
+
+class CassandraColumnParser:
+    """
+    Responsible for containing the logic to parse a column from Cassandra to OpenMetadata
+    """
+
+    datatype_mapping = {
+        "ascii": DataType.STRING,
+        "bigint": DataType.BIGINT,
+        "blob": DataType.BLOB,
+        "boolean": DataType.BOOLEAN,
+        "date": DataType.DATE,
+        "decimal": DataType.DECIMAL,
+        "double": DataType.DOUBLE,
+        "duration": DataType.INTERVAL,
+        "float": DataType.FLOAT,
+        "uuid": DataType.UUID,
+        "inet": DataType.INET,
+        "int": DataType.INT,
+        "list": DataType.ARRAY,
+        "map": DataType.MAP,
+        "set": DataType.SET,
+        "smallint": DataType.SMALLINT,
+        "text": DataType.TEXT,
+        "time": DataType.TIME,
+        "timestamp": DataType.TIMESTAMP,
+        "timeuuid": DataType.UUID,
+        "tinyint": DataType.TINYINT,
+        "tuple": DataType.TUPLE,
+        "varint": DataType.STRING,
+        "struct": DataType.STRUCT,
+    }
+
+    @classmethod
+    def parse(cls, field) -> Column:
+        """
+        Parses a Cassandra table column into an OpenMetadata column.
+        """
+
+        data_type = None
+        array_data_type = None
+        raw_data_type = ""
+
+        for letter in field.type:
+            if letter == "<":
+                if raw_data_type in ("", "frozen"):
+                    raw_data_type = ""
+                    continue
+
+                if not data_type:
+                    data_type = cls.datatype_mapping.get(
+                        raw_data_type.lower(), DataType.UNKNOWN
+                    )
+                elif not array_data_type:
+                    array_data_type = cls.datatype_mapping.get(
+                        raw_data_type.lower(), DataType.UNKNOWN
+                    )
+
+                raw_data_type = ""
+                if data_type != DataType.ARRAY or array_data_type:
+                    break
+
+            elif letter == ">":
+                if not array_data_type and data_type:
+                    array_data_type = cls.datatype_mapping.get(
+                        raw_data_type.lower(), DataType.UNKNOWN
+                    )
+                    break
+
+            else:
+                raw_data_type += letter
+
+        if not data_type:
+            data_type = cls.datatype_mapping.get(field.type.lower(), DataType.UNKNOWN)
+
+        column_def = {
+            "name": field.column_name,
+            "dataTypeDisplay": field.type,
+            "dataType": data_type,
+            "arrayDataType": array_data_type,
+        }
+
+        return Column(**column_def)

metadata/ingestion/source/database/cassandra/metadata.py

@@ -0,0 +1,138 @@
+#  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.
+"""
+Cassandra source methods.
+"""
+
+import traceback
+from typing import Iterable, List, Optional
+
+from metadata.generated.schema.entity.data.table import Column, TableType
+from metadata.generated.schema.entity.services.connections.database.cassandraConnection import (
+    CassandraConnection,
+)
+from metadata.generated.schema.metadataIngestion.workflow import (
+    Source as WorkflowSource,
+)
+from metadata.ingestion.api.steps import InvalidSourceException
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.database.cassandra.helpers import CassandraColumnParser
+from metadata.ingestion.source.database.cassandra.queries import (
+    CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS,
+    CASSANDRA_GET_KEYSPACE_TABLES,
+    CASSANDRA_GET_KEYSPACES,
+    CASSANDRA_GET_TABLE_COLUMNS,
+)
+from metadata.ingestion.source.database.common_nosql_source import (
+    CommonNoSQLSource,
+    TableNameAndType,
+)
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class CassandraSource(CommonNoSQLSource):
+    """
+    Implements the necessary methods to extract
+    Database metadata from Dynamo Source
+    """
+
+    def __init__(self, config: WorkflowSource, metadata: OpenMetadata):
+        super().__init__(config, metadata)
+        self.cassandra = self.connection_obj
+
+    @classmethod
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: CassandraConnection = config.serviceConnection.root.config
+        if not isinstance(connection, CassandraConnection):
+            raise InvalidSourceException(
+                f"Expected CassandraConnection, but got {connection}"
+            )
+        return cls(config, metadata)
+
+    def get_schema_name_list(self) -> List[str]:
+        """
+        Method to get list of schema names available within NoSQL db
+        need to be overridden by sources
+        """
+        schema_names = []
+        try:
+            schema_names = [
+                row.keyspace_name
+                for row in self.cassandra.execute(CASSANDRA_GET_KEYSPACES)
+            ]
+        except Exception as exp:
+            logger.debug(f"Failed to list keyspace names: {exp}")
+            logger.debug(traceback.format_exc())
+
+        return schema_names
+
+    def query_table_names_and_types(
+        self, schema_name: str
+    ) -> Iterable[TableNameAndType]:
+        """
+        Method to get list of table names available within schema db
+        need to be overridden by sources
+        """
+        tables = []
+        try:
+            tables = [
+                TableNameAndType(name=row.table_name)
+                for row in self.cassandra.execute(
+                    CASSANDRA_GET_KEYSPACE_TABLES, [schema_name]
+                )
+            ]
+        except Exception as exp:
+            logger.debug(
+                f"Failed to list table names for schema [{schema_name}]: {exp}"
+            )
+            logger.debug(traceback.format_exc())
+
+        return tables
+
+    def query_view_names_and_types(
+        self, schema_name: str
+    ) -> Iterable[TableNameAndType]:
+        """
+        Method to get list of materialized view names available within schema db
+        need to be overridden by sources
+        """
+        materialized_views = []
+        try:
+            materialized_views = [
+                TableNameAndType(name=row.view_name, type_=TableType.MaterializedView)
+                for row in self.cassandra.execute(
+                    CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS, [schema_name]
+                )
+            ]
+        except Exception as exp:
+            logger.debug(
+                f"Failed to list materialized view names for schema [{schema_name}]: {exp}"
+            )
+            logger.debug(traceback.format_exc())
+
+        return materialized_views
+
+    def get_table_columns(self, schema_name: str, table_name: str) -> List[Column]:
+        try:
+            data = self.cassandra.execute(
+                CASSANDRA_GET_TABLE_COLUMNS, [schema_name, table_name]
+            )
+            return [CassandraColumnParser.parse(field=field) for field in data]
+        except Exception as opf:
+            logger.debug(f"Failed to read table [{table_name}]: {opf}")
+            logger.debug(traceback.format_exc())
+
+        return []

metadata/ingestion/source/database/cassandra/queries.py

@@ -0,0 +1,45 @@
+#  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.
+"""
+SQL Queries used during ingestion
+"""
+
+import textwrap
+
+CASSANDRA_GET_RELEASE_VERSION = textwrap.dedent(
+    """
+    SELECT release_version FROM system.local;
+    """
+)
+
+CASSANDRA_GET_KEYSPACES = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.keyspaces
+    """
+)
+
+CASSANDRA_GET_KEYSPACE_TABLES = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.tables WHERE keyspace_name = %s
+    """
+)
+
+CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.views WHERE keyspace_name = %s
+    """
+)
+
+CASSANDRA_GET_TABLE_COLUMNS = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.columns WHERE keyspace_name = %s AND table_name = %s
+    """
+)

metadata/ingestion/source/database/cassandra/service_spec.py

@@ -0,0 +1,10 @@
+from metadata.ingestion.source.database.cassandra.metadata import CassandraSource
+from metadata.profiler.interface.nosql.profiler_interface import NoSQLProfilerInterface
+from metadata.sampler.nosql.sampler import NoSQLSampler
+from metadata.utils.service_spec.default import DefaultDatabaseSpec
+
+ServiceSpec = DefaultDatabaseSpec(
+    metadata_source_class=CassandraSource,
+    profiler_class=NoSQLProfilerInterface,
+    sampler_class=NoSQLSampler,
+)