openmetadata-ingestion 1.4.8.0__py3-none-any.whl → 1.5.0.0rc2__py3-none-any.whl

metadata/ingestion/source/database/druid/metadata.py

@@ -31,8 +31,8 @@ class DruidSource(CommonDbSourceService):
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
         """Create class instance"""
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: DruidConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: DruidConnection = config.serviceConnection.root.config
         if not isinstance(connection, DruidConnection):
             raise InvalidSourceException(
                 f"Expected DruidConnection, but got {connection}"

metadata/ingestion/source/database/dynamodb/metadata.py

@@ -49,8 +49,8 @@ class DynamodbSource(CommonNoSQLSource):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: DynamoDBConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: DynamoDBConnection = config.serviceConnection.root.config
         if not isinstance(connection, DynamoDBConnection):
             raise InvalidSourceException(
                 f"Expected DynamoDBConnection, but got {connection}"
@@ -84,8 +84,8 @@ class DynamodbSource(CommonNoSQLSource):
         Method to get actual data available within table
         need to be overridden by sources
         """
+        attributes = []
         try:
-            attributes = []
             scan_kwargs = {}
             done = False
             start_key = None
@@ -93,7 +93,7 @@ class DynamodbSource(CommonNoSQLSource):
             while not done:
                 if start_key:
                     scan_kwargs["ExclusiveStartKey"] = start_key
-                response = TableResponse.parse_obj(table.scan(**scan_kwargs))
+                response = TableResponse.model_validate(table.scan(**scan_kwargs))
                 attributes.extend(response.Items)
                 start_key = response.LastEvaluatedKey
                 done = start_key is None or len(attributes) >= SAMPLE_SIZE
@@ -103,7 +103,7 @@ class DynamodbSource(CommonNoSQLSource):
             logger.warning(
                 f"Failed to read DynamoDB attributes for [{table_name}]: {err}"
             )
-        return []
+        return attributes
 
     def get_source_url(
         self,

metadata/ingestion/source/database/dynamodb/models.py

@@ -11,7 +11,7 @@
 """
 DynamoDB Models
 """
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel
 
@@ -22,4 +22,4 @@ class TableResponse(BaseModel):
     """
 
     Items: Optional[List[Dict]] = []
-    LastEvaluatedKey: Optional[str]
+    LastEvaluatedKey: Optional[Any] = None

metadata/ingestion/source/database/extended_sample_data.py

@@ -89,7 +89,7 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
         self.database_service_json = {}
         self.dashboard_service_json = {}
         self.config = config
-        self.service_connection = config.serviceConnection.__root__.config
+        self.service_connection = config.serviceConnection.root.config
         self.metadata = metadata
         self.list_policies = []
         self.store_table_fqn = set()
@@ -98,19 +98,19 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
         self.main_glossary = None
         self.glossary_term_list = []
 
-        sample_data_folder = self.service_connection.connectionOptions.__root__.get(
+        sample_data_folder = self.service_connection.connectionOptions.root.get(
             "sampleDataFolder"
         )
-        self.include_glossary = self.service_connection.connectionOptions.__root__.get(
+        self.include_glossary = self.service_connection.connectionOptions.root.get(
             "includeGlossary"
         )
         self.include_lineage_stress_testing = (
-            self.service_connection.connectionOptions.__root__.get(
+            self.service_connection.connectionOptions.root.get(
                 "includeLineageStressTesting"
             )
         )
         extneded_sample_data_folder = (
-            self.service_connection.connectionOptions.__root__.get(
+            self.service_connection.connectionOptions.root.get(
                 "extendedSampleDataFolder"
             )
         )
@@ -198,8 +198,8 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
         """Create class instance"""
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: CustomDatabaseConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: CustomDatabaseConnection = config.serviceConnection.root.config
         if not isinstance(connection, CustomDatabaseConnection):
             raise InvalidSourceException(
                 f"Expected CustomDatabaseConnection, but got {connection}"
@@ -222,14 +222,14 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
         """Create Depth Nodes"""
         from_col_list = []
         for col in from_table.columns:
-            from_col_list.append(col.fullyQualifiedName.__root__)
-        to_col = to_table.columns[0].fullyQualifiedName.__root__
+            from_col_list.append(col.fullyQualifiedName.root)
+        to_col = to_table.columns[0].fullyQualifiedName.root
         yield Either(
             right=AddLineageRequest(
                 edge=EntitiesEdge(
-                    fromEntity=EntityReference(id=from_table.id.__root__, type="table"),
+                    fromEntity=EntityReference(id=from_table.id.root, type="table"),
                     toEntity=EntityReference(
-                        id=to_table.id.__root__,
+                        id=to_table.id.root,
                         type="table",
                     ),
                     lineageDetails=LineageDetails(
@@ -270,10 +270,10 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                 downstream_node_fqn_table = fqn.build(
                     self.metadata,
                     entity_type=Table,
-                    service_name=self.database_service.name.__root__,
-                    database_name=db.name.__root__,
-                    schema_name=schema.name.__root__,
-                    table_name=table_request.name.__root__,
+                    service_name=self.database_service.name.root,
+                    database_name=db.name.root,
+                    schema_name=schema.name.root,
+                    table_name=table_request.name.root,
                 )
                 to_table = self.metadata.get_by_name(
                     entity=Table, fqn=downstream_node_fqn_table
@@ -289,10 +289,10 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                     upstream_node_fqn_table = fqn.build(
                         self.metadata,
                         entity_type=Table,
-                        service_name=self.database_service.name.__root__,
-                        database_name=db.name.__root__,
-                        schema_name=schema.name.__root__,
-                        table_name=table_request.name.__root__,
+                        service_name=self.database_service.name.root,
+                        database_name=db.name.root,
+                        schema_name=schema.name.root,
+                        table_name=table_request.name.root,
                     )
                     from_table = self.metadata.get_by_name(
                         entity=Table, fqn=upstream_node_fqn_table
@@ -310,10 +310,10 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                 upstream_node_fqn_table = fqn.build(
                     self.metadata,
                     entity_type=Table,
-                    service_name=self.database_service.name.__root__,
-                    database_name=db.name.__root__,
-                    schema_name=schema.name.__root__,
-                    table_name=table_request.name.__root__,
+                    service_name=self.database_service.name.root,
+                    database_name=db.name.root,
+                    schema_name=schema.name.root,
+                    table_name=table_request.name.root,
                 )
                 from_table = self.metadata.get_by_name(
                     entity=Table, fqn=upstream_node_fqn_table
@@ -331,10 +331,10 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                 table_entity_fqn = fqn.build(
                     self.metadata,
                     entity_type=Table,
-                    service_name=self.database_service.name.__root__,
-                    database_name=db.name.__root__,
-                    schema_name=schema.name.__root__,
-                    table_name=table_request.name.__root__,
+                    service_name=self.database_service.name.root,
+                    database_name=db.name.root,
+                    schema_name=schema.name.root,
+                    table_name=table_request.name.root,
                 )
                 from_table = self.metadata.get_by_name(
                     entity=Table, fqn=table_entity_fqn
@@ -367,8 +367,8 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                 data_model_entity_fqn = fqn.build(
                     self.metadata,
                     entity_type=DashboardDataModel,
-                    service_name=self.dashboard_service.name.__root__,
-                    data_model_name=data_model_request.name.__root__,
+                    service_name=self.dashboard_service.name.root,
+                    data_model_name=data_model_request.name.root,
                 )
                 self.store_data_model_fqn.append(data_model_entity_fqn)
 
@@ -383,10 +383,10 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                         right=AddLineageRequest(
                             edge=EntitiesEdge(
                                 fromEntity=EntityReference(
-                                    id=from_table.id.__root__, type="table"
+                                    id=from_table.id.root, type="table"
                                 ),
                                 toEntity=EntityReference(
-                                    id=to_datamodel.id.__root__,
+                                    id=to_datamodel.id.root,
                                     type="dashboardDataModel",
                                 ),
                                 lineageDetails=LineageDetails(
@@ -408,8 +408,8 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                         dashboard_fqn = fqn.build(
                             self.metadata,
                             entity_type=Dashboard,
-                            service_name=self.dashboard_service.name.__root__,
-                            dashboard_name=dashboard_request.name.__root__,
+                            service_name=self.dashboard_service.name.root,
+                            dashboard_name=dashboard_request.name.root,
                         )
                         to_dashboard = self.metadata.get_by_name(
                             entity=Dashboard, fqn=dashboard_fqn
@@ -418,11 +418,11 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
                             right=AddLineageRequest(
                                 edge=EntitiesEdge(
                                     fromEntity=EntityReference(
-                                        id=to_datamodel.id.__root__,
+                                        id=to_datamodel.id.root,
                                         type="dashboardDataModel",
                                     ),
                                     toEntity=EntityReference(
-                                        id=to_dashboard.id.__root__, type="dashboard"
+                                        id=to_dashboard.id.root, type="dashboard"
                                     ),
                                     lineageDetails=LineageDetails(
                                         source=LineageSource.DashboardLineage
@@ -484,17 +484,17 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
         db = CreateDatabaseRequest(
             name=name,
             description=text,
-            service=self.database_service.fullyQualifiedName.__root__,
+            service=self.database_service.fullyQualifiedName.root,
         )
         return db
 
     def create_database_schema_request(self, name, text, db):
-        self.db_name = db.name.__root__
+        self.db_name = db.name.root
         db_fqn = fqn.build(
             self.metadata,
             entity_type=Database,
-            service_name=self.database_service.name.__root__,
-            database_name=db.name.__root__,
+            service_name=self.database_service.name.root,
+            database_name=db.name.root,
         )
         schema = CreateDatabaseSchemaRequest(
             name=name,
@@ -507,9 +507,9 @@ class ExtendedSampleDataSource(Source):  # pylint: disable=too-many-instance-att
         dbschema_fqn = fqn.build(
             self.metadata,
             entity_type=DatabaseSchema,
-            service_name=self.database_service.name.__root__,
+            service_name=self.database_service.name.root,
             database_name=self.db_name,
-            schema_name=schema.name.__root__,
+            schema_name=schema.name.root,
         )
         table_request = CreateTableRequest(
             name=name,

metadata/ingestion/source/database/external_table_lineage_mixin.py

@@ -14,13 +14,20 @@ External Table Lineage Mixin
 
 import traceback
 from abc import ABC
-from typing import Iterable
+from typing import Iterable, List, Optional
 
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
+from metadata.generated.schema.entity.data.container import ContainerDataModel
 from metadata.generated.schema.entity.data.table import Table
-from metadata.generated.schema.type.entityLineage import EntitiesEdge
+from metadata.generated.schema.type.entityLineage import (
+    ColumnLineage,
+    EntitiesEdge,
+    LineageDetails,
+)
+from metadata.generated.schema.type.entityLineage import Source as LineageSource
 from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.ingestion.api.models import Either
+from metadata.ingestion.lineage.sql_lineage import get_column_fqn
 from metadata.utils import fqn
 from metadata.utils.logger import ingestion_logger
 
@@ -39,7 +46,7 @@ class ExternalTableLineageMixin(ABC):
         for table_qualified_tuple, location in self.external_location_map.items() or []:
             try:
                 location_entity = self.metadata.es_search_container_by_path(
-                    full_path=location
+                    full_path=location, fields="dataModel"
                 )
                 database_name, schema_name, table_name = table_qualified_tuple
 
@@ -63,6 +70,12 @@ class ExternalTableLineageMixin(ABC):
                     and table_entity
                     and table_entity[0]
                 ):
+                    columns_list = [
+                        column.name.root for column in table_entity[0].columns
+                    ]
+                    columns_lineage = self._get_column_lineage(
+                        location_entity[0].dataModel, table_entity[0], columns_list
+                    )
                     yield Either(
                         right=AddLineageRequest(
                             edge=EntitiesEdge(
@@ -74,9 +87,51 @@ class ExternalTableLineageMixin(ABC):
                                     id=table_entity[0].id,
                                     type="table",
                                 ),
+                                lineageDetails=LineageDetails(
+                                    source=LineageSource.ExternalTableLineage,
+                                    columnsLineage=columns_lineage,
+                                ),
                             )
                         )
                     )
             except Exception as exc:
                 logger.warning(f"Failed to yield external table lineage due to - {exc}")
                 logger.debug(traceback.format_exc())
+
+    def _get_data_model_column_fqn(
+        self, data_model_entity: ContainerDataModel, column: str
+    ) -> Optional[str]:
+        """
+        Get fqn of column if exist in data model entity
+        """
+        if not data_model_entity:
+            return None
+        for entity_column in data_model_entity.columns:
+            if entity_column.displayName.lower() == column.lower():
+                return entity_column.fullyQualifiedName.root
+        return None
+
+    def _get_column_lineage(
+        self,
+        data_model_entity: ContainerDataModel,
+        table_entity: Table,
+        columns_list: List[str],
+    ) -> List[ColumnLineage]:
+        """
+        Get the column lineage
+        """
+        try:
+            column_lineage = []
+            for field in columns_list or []:
+                from_column = self._get_data_model_column_fqn(
+                    data_model_entity=data_model_entity, column=field
+                )
+                to_column = get_column_fqn(table_entity=table_entity, column=field)
+                if from_column and to_column:
+                    column_lineage.append(
+                        ColumnLineage(fromColumns=[from_column], toColumn=to_column)
+                    )
+            return column_lineage
+        except Exception as exc:
+            logger.debug(f"Error to get column lineage: {exc}")
+            logger.debug(traceback.format_exc())

metadata/ingestion/source/database/glue/metadata.py

@@ -39,6 +39,7 @@ from metadata.generated.schema.metadataIngestion.databaseServiceMetadataPipeline
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
+from metadata.generated.schema.type.basic import EntityName, FullyQualifiedEntityName
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.models.ometa_classification import OMetaTagAndClassification
@@ -74,7 +75,7 @@ class GlueSource(DatabaseServiceSource):
             self.config.sourceConfig.config
         )
         self.metadata = metadata
-        self.service_connection = self.config.serviceConnection.__root__.config
+        self.service_connection = self.config.serviceConnection.root.config
         self.glue = get_connection(self.service_connection)
 
         self.connection_obj = self.glue
@@ -84,8 +85,8 @@ class GlueSource(DatabaseServiceSource):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: GlueConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: GlueConnection = config.serviceConnection.root.config
         if not isinstance(connection, GlueConnection):
             raise InvalidSourceException(
                 f"Expected GlueConnection, but got {connection}"
@@ -209,12 +210,14 @@ class GlueSource(DatabaseServiceSource):
         """
         yield Either(
             right=CreateDatabaseSchemaRequest(
-                name=schema_name,
-                database=fqn.build(
-                    metadata=self.metadata,
-                    entity_type=Database,
-                    service_name=self.context.get().database_service,
-                    database_name=self.context.get().database,
+                name=EntityName(schema_name),
+                database=FullyQualifiedEntityName(
+                    fqn.build(
+                        metadata=self.metadata,
+                        entity_type=Database,
+                        service_name=self.context.get().database_service,
+                        database_name=self.context.get().database,
+                    )
                 ),
                 sourceUrl=self.get_source_url(
                     database_name=self.context.get().database,
@@ -283,7 +286,7 @@ class GlueSource(DatabaseServiceSource):
                     )
 
     def yield_table(
-        self, table_name_and_type: Tuple[str, str]
+        self, table_name_and_type: Tuple[str, TableType]
     ) -> Iterable[Either[CreateTableRequest]]:
         """
         From topology.
@@ -296,17 +299,19 @@ class GlueSource(DatabaseServiceSource):
             columns = self.get_columns(table.StorageDescriptor)
 
             table_request = CreateTableRequest(
-                name=table_name,
+                name=EntityName(table_name),
                 tableType=table_type,
                 description=table.Description,
-                columns=columns,
+                columns=list(columns),
                 tableConstraints=table_constraints,
-                databaseSchema=fqn.build(
-                    metadata=self.metadata,
-                    entity_type=DatabaseSchema,
-                    service_name=self.context.get().database_service,
-                    database_name=self.context.get().database,
-                    schema_name=self.context.get().database_schema,
+                databaseSchema=FullyQualifiedEntityName(
+                    fqn.build(
+                        metadata=self.metadata,
+                        entity_type=DatabaseSchema,
+                        service_name=self.context.get().database_service,
+                        database_name=self.context.get().database,
+                        schema_name=self.context.get().database_schema,
+                    )
                 ),
                 sourceUrl=self.get_source_url(
                     table_name=table_name,

metadata/ingestion/source/database/glue/models.py

@@ -18,7 +18,7 @@ from pydantic import BaseModel
 
 
 class GlueSchema(BaseModel):
-    CatalogId: Optional[str]
+    CatalogId: Optional[str] = None
     Name: str
 
 
@@ -27,13 +27,13 @@ class DatabasePage(BaseModel):
 
 
 class TableParameters(BaseModel):
-    table_type: Optional[str]
+    table_type: Optional[str] = None
 
 
 class Column(BaseModel):
     Type: str
     Name: str
-    Comment: Optional[str]
+    Comment: Optional[str] = None
 
 
 class StorageDetails(BaseModel):
@@ -41,10 +41,10 @@ class StorageDetails(BaseModel):
 
 
 class GlueTable(BaseModel):
-    Parameters: Optional[TableParameters]
+    Parameters: Optional[TableParameters] = None
     Name: str
-    TableType: Optional[str]
-    Description: Optional[str]
+    TableType: Optional[str] = None
+    Description: Optional[str] = None
     StorageDescriptor: Optional[StorageDetails] = StorageDetails()
     PartitionKeys: Optional[List[Column]] = []
 

metadata/ingestion/source/database/greenplum/metadata.py

@@ -124,8 +124,8 @@ class GreenplumSource(CommonDbSourceService, MultiDBSource):
         metadata: OpenMetadataConnection,
         pipeline_name: Optional[str] = None,
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: GreenplumConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: GreenplumConnection = config.serviceConnection.root.config
         if not isinstance(connection, GreenplumConnection):
             raise InvalidSourceException(
                 f"Expected GreenplumConnection, but got {connection}"
@@ -160,8 +160,8 @@ class GreenplumSource(CommonDbSourceService, MultiDBSource):
         yield from self._execute_database_query(GREENPLUM_GET_DB_NAMES)
 
     def get_database_names(self) -> Iterable[str]:
-        if not self.config.serviceConnection.__root__.config.ingestAllDatabases:
-            configured_db = self.config.serviceConnection.__root__.config.database
+        if not self.config.serviceConnection.root.config.ingestAllDatabases:
+            configured_db = self.config.serviceConnection.root.config.database
             self.set_inspector(database_name=configured_db)
             yield configured_db
         else:

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

@@ -100,12 +100,12 @@ def get_connection(connection: HiveConnection) -> Engine:
             in {HiveScheme.hive, HiveScheme.hive_http, HiveScheme.hive_https}
             else "auth_mechanism"
         )
-        connection.connectionArguments.__root__[auth_key] = connection.auth.value
+        connection.connectionArguments.root[auth_key] = connection.auth.value
 
     if connection.kerberosServiceName:
         if not connection.connectionArguments:
             connection.connectionArguments = init_empty_connection_arguments()
-        connection.connectionArguments.__root__[
+        connection.connectionArguments.root[
             "kerberos_service_name"
         ] = connection.kerberosServiceName
 

metadata/ingestion/source/database/hive/metadata.py

@@ -60,8 +60,8 @@ class HiveSource(CommonDbSourceService):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config = WorkflowSource.parse_obj(config_dict)
-        connection: HiveConnection = config.serviceConnection.__root__.config
+        config = WorkflowSource.model_validate(config_dict)
+        connection: HiveConnection = config.serviceConnection.root.config
         if not isinstance(connection, HiveConnection):
             raise InvalidSourceException(
                 f"Expected HiveConnection, but got {connection}"

metadata/ingestion/source/database/iceberg/catalog/hive.py

@@ -39,7 +39,7 @@ class IcebergHiveCatalog(IcebergCatalogBase):
 
         parameters = {
             "warehouse": catalog.warehouseLocation,
-            "uri": catalog.connection.uri,
+            "uri": str(catalog.connection.uri),
         }
 
         if catalog.connection.fileSystem:

metadata/ingestion/source/database/iceberg/catalog/rest.py

@@ -37,7 +37,7 @@ class IcebergRestCatalog(IcebergCatalogBase):
                 "'connection' is not an instance of 'RestCatalogConnection'"
             )
 
-        if catalog.connection.credential:
+        if catalog.connection.credential and catalog.connection.credential.clientSecret:
             client_id = catalog.connection.credential.clientId.get_secret_value()
             client_secret = (
                 catalog.connection.credential.clientSecret.get_secret_value()

metadata/ingestion/source/database/iceberg/fs/__init__.py

@@ -46,7 +46,7 @@ class IcebergFileSystemFactory:
 
         if not file_system_type:
             raise NotImplementedError(
-                f"Iceberg File System otype ['{fs_config.__class__.__name__}'] Not Implemented."
+                f"Iceberg File System type ['{fs_config.__class__.__name__}'] Not Implemented."
             )
 
         return file_system_type.get_fs_params(fs_config)

metadata/ingestion/source/database/iceberg/fs/s3.py

@@ -56,7 +56,7 @@ class S3FileSystem(IcebergFileSystemBase):
 
         unused_keys = []
 
-        for key, value in fs_config.dict().items():
+        for key, value in fs_config.model_dump().items():
             if key not in SUPPORTED_KEYS and value:
                 unused_keys.append(key)
 

metadata/ingestion/source/database/iceberg/helper.py

@@ -37,14 +37,14 @@ def namespace_to_str(namespace: tuple[str]) -> str:
     return ".".join(namespace)
 
 
-def get_table_name_as_str(table: pyiceberg.table.Table) -> str:
-    """Returns the Table Name as Tring from a PyIceberg Table.
+def get_table_name_as_str(table: Tuple[str]) -> str:
+    """Returns the Table Name as String from a PyIceberg table identifier tuple.
 
     The PyIceberg table name is returned as tuple and we turn them into a String
     concatenating the items with a '.' in between.
     """
     # We are skipping the first item because it is the schema name.
-    return ".".join(table.name()[1:])
+    return ".".join(table[1:])
 
 
 def get_column_from_partition(
@@ -94,7 +94,7 @@ def get_column_partition_type(
 def get_owner_from_table(
     table: pyiceberg.table.Table, property_key: str
 ) -> Optional[str]:
-    """Retrives the owner information from given Table Property."""
+    """Retrieves the owner information from given Table Property."""
     return table.properties.get(property_key)