openmetadata-ingestion 1.9.13.0__py3-none-any.whl → 1.10.1.0__py3-none-any.whl

metadata/ingestion/ometa/mixins/patch_mixin.py

@@ -20,6 +20,9 @@ from typing import Dict, List, Optional, Type, TypeVar, Union
 
 from pydantic import BaseModel
 
+from metadata.generated.schema.entity.automations.response.queryRunnerResponse import (
+    QueryRunnerResponse,
+)
 from metadata.generated.schema.entity.automations.workflow import (
     Workflow as AutomationWorkflow,
 )
@@ -128,6 +131,11 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
         Given an Entity type and Source entity and Destination entity,
         generate a JSON Patch and apply it.
 
+        This method provides fine-grained control over entity updates and can
+        override fields that create_or_update() cannot due to server-side restrictions
+        across various entity types. Use override_metadata=True to force updates of
+        protected metadata fields.
+
         Args
             entity (T): Entity Type
             source: Source payload which is current state of the source in OpenMetadata
@@ -135,7 +143,8 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
             allowed_fields: List of field names to filter from source and destination models
             restrict_update_fields: List of field names which will only support add operation
             array_entity_fields: List of array fields to sort for consistent patching
-            override_metadata: Whether to override existing metadata fields
+            override_metadata: Whether to override existing metadata fields. Set to True
+                to force updates of protected fields across various entity types.
             skip_on_failure: Whether to skip the patch operation on failure (default: True)
 
         Returns
@@ -188,12 +197,16 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
         """
         Given an Entity type and ID, JSON PATCH the description.
 
+        This method is useful when you need to update descriptions that cannot be
+        overridden through create_or_update() due to server-side business rules
+        across various entity types. Use force=True to override existing descriptions.
+
         Args
             entity (T): Entity Type
             source: source entity object
             description: new description to add
             force: if True, we will patch any existing description. Otherwise, we will maintain
-                the existing data.
+                the existing data. Set to True to override existing descriptions across entity types.
             skip_on_failure: if True, return None on failure instead of raising exception
         Returns
             Updated Entity
@@ -547,7 +560,9 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
     def patch_automation_workflow_response(
         self,
         automation_workflow: AutomationWorkflow,
-        result: Union[TestConnectionResult, ReverseIngestionResponse],
+        result: Union[
+            TestConnectionResult, ReverseIngestionResponse, QueryRunnerResponse
+        ],
         workflow_status: WorkflowStatus,
     ) -> None:
         """
@@ -560,17 +575,16 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
         }
 
         # for deserializing into json convert enum object to string
-        if isinstance(result, TestConnectionResult):
-            result_data[PatchField.VALUE]["status"] = result_data[PatchField.VALUE][
-                "status"
-            ].value
-        else:
+        if isinstance(result, ReverseIngestionResponse):
             # Convert UUID in string
             data = result_data[PatchField.VALUE]
             data["serviceId"] = str(data["serviceId"])
             for operation_result in data["results"]:
                 operation_result["id"] = str(operation_result["id"])
-
+        else:
+            result_data[PatchField.VALUE]["status"] = result_data[PatchField.VALUE][
+                "status"
+            ].value
         status_data: Dict = {
             PatchField.PATH: PatchPath.STATUS,
             PatchField.OPERATION: PatchOperation.ADD,

metadata/ingestion/ometa/ometa_api.py

@@ -33,6 +33,7 @@ from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.ingestion.models.custom_pydantic import BaseModel
 from metadata.ingestion.ometa.auth_provider import OpenMetadataAuthenticationProvider
 from metadata.ingestion.ometa.client import REST, APIError, ClientConfig
+from metadata.ingestion.ometa.mixins.csv_mixin import CSVMixin
 from metadata.ingestion.ometa.mixins.custom_property_mixin import (
     OMetaCustomPropertyMixin,
 )
@@ -44,6 +45,7 @@ from metadata.ingestion.ometa.mixins.es_mixin import ESMixin
 from metadata.ingestion.ometa.mixins.ingestion_pipeline_mixin import (
     OMetaIngestionPipelineMixin,
 )
+from metadata.ingestion.ometa.mixins.logs_mixin import OMetaLogsMixin
 from metadata.ingestion.ometa.mixins.mlmodel_mixin import OMetaMlModelMixin
 from metadata.ingestion.ometa.mixins.patch_mixin import OMetaPatchMixin
 from metadata.ingestion.ometa.mixins.pipeline_mixin import OMetaPipelineMixin
@@ -109,6 +111,7 @@ class OpenMetadataSettings(BaseSettings):
 
 
 class OpenMetadata(
+    CSVMixin,
     OMetaPipelineMixin,
     OMetaMlModelMixin,
     OMetaTableMixin,
@@ -123,6 +126,7 @@ class OpenMetadata(
     OMetaTestsMixin,
     DataInsightMixin,
     OMetaIngestionPipelineMixin,
+    OMetaLogsMixin,
     OMetaUserMixin,
     OMetaQueryMixin,
     OMetaRolePolicyMixin,
@@ -339,7 +343,22 @@ class OpenMetadata(
         return entity_class(**resp)
 
     def create_or_update(self, data: C) -> T:
-        """Run a PUT requesting via create request C"""
+        """
+        Run a PUT request via create request C.
+
+        Note: This method uses PUT operations with server-side business rules that may prevent
+        certain field overwrites across various entity types for data integrity reasons. If you
+        need to override existing metadata fields, consider using patch methods instead:
+
+        - For descriptions: Use patch_description(force=True)
+        - For general metadata: Use patch(override_metadata=True)
+
+        Args:
+            data: Create request object
+
+        Returns:
+            Updated or created entity
+        """
         return self._create(data=data, method="put")
 
     def create(self, data: C) -> T:

metadata/ingestion/ometa/routes.py

@@ -328,5 +328,8 @@ ROUTES = {
     # Data Contracts
     DataContract.__name__: "/dataContracts",
     CreateDataContractRequest.__name__: "/dataContracts",
+    # Drives
+    DriveService.__name__: "/services/driveServices",
+    CreateDriveServiceRequest.__name__: "/services/driveServices",
     EntityProfile.__name__: "/entity/profiles",
 }

metadata/ingestion/source/dashboard/domodashboard/metadata.py

@@ -79,6 +79,8 @@ class DomodashboardSource(DashboardServiceSource):
         return cls(config, metadata)
 
     def get_dashboards_list(self) -> Optional[List[DomoDashboardDetails]]:
+        if not self.source_config.includeOwners:
+            logger.debug("Skipping owner information as includeOwners is False")
         dashboards = self.client.domo.page_list()
         dashboard_list = []
         for dashboard in dashboards:
@@ -104,15 +106,23 @@ class DomodashboardSource(DashboardServiceSource):
     def get_owner_ref(
         self, dashboard_details: DomoDashboardDetails
     ) -> Optional[EntityReferenceList]:
-        for owner in dashboard_details.owners or []:
-            try:
-                owner_details = self.client.domo.users_get(owner.id)
-                if owner_details.get("email"):
-                    return self.metadata.get_reference_by_email(owner_details["email"])
-            except Exception as exc:
-                logger.warning(
-                    f"Error while getting details of user {owner.displayName} - {exc}"
-                )
+        try:
+            if not self.source_config.includeOwners:
+                return None
+            for owner in dashboard_details.owners or []:
+                try:
+                    owner_details = self.client.domo.users_get(owner.id)
+                    if owner_details.get("email"):
+                        return self.metadata.get_reference_by_email(
+                            owner_details["email"]
+                        )
+                except Exception as exc:
+                    logger.warning(
+                        f"Error while getting details of user {owner.displayName} - {exc}"
+                    )
+        except Exception as err:
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Could not fetch owner data due to {err}")
         return None
 
     def yield_dashboard(

metadata/ingestion/source/dashboard/looker/metadata.py

@@ -922,6 +922,8 @@ class LookerSource(DashboardServiceSource):
         """
         Get List of all dashboards
         """
+        if not self.source_config.includeOwners:
+            logger.debug("Skipping owner information as includeOwners is False")
         try:
             return list(
                 self.client.all_dashboards(fields=",".join(LIST_DASHBOARD_FIELDS))
@@ -963,6 +965,8 @@ class LookerSource(DashboardServiceSource):
             Optional[EntityReference]
         """
         try:
+            if not self.source_config.includeOwners:
+                return None
             if dashboard_details.user_id is not None:
                 dashboard_owner = self.client.user(dashboard_details.user_id)
                 if dashboard_owner.email:

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

@@ -48,6 +48,7 @@ PASSWORD_HEADER = "password"
 SESSION_HEADERS = {"Content-Type": "application/json", "Accept": "*/*"}
 DEFAULT_TIMEOUT = 30
 METABASE_SESSION_HEADER = "X-Metabase-Session"
+METABASE_API_HEADER = "X-API-KEY"
 API_VERSION = "api"
 
 
@@ -56,8 +57,13 @@ class MetabaseClient:
     Client Handling API communication with Metabase
     """
 
-    def _get_metabase_session(self) -> str:
+    def _get_metabase_session(self) -> Optional[str]:
         try:
+            # If API token is provided, return None as we don't need a session
+            if self.config.apiKey:
+                return None
+
+            # Otherwise use username/password authentication
             params = {USERNAME_HEADER: self.config.username}
             if self.config.password:
                 params[PASSWORD_HEADER] = self.config.password.get_secret_value()
@@ -82,14 +88,30 @@ class MetabaseClient:
         config: MetabaseConnection,
     ):
         self.config = config
-        session_token = self._get_metabase_session()
-        client_config: ClientConfig = ClientConfig(
-            base_url=clean_uri(str(self.config.hostPort)),
-            api_version=API_VERSION,
-            auth_header=AUTHORIZATION_HEADER,
-            auth_token=lambda: (NO_ACCESS_TOKEN, 0),
-            extra_headers={METABASE_SESSION_HEADER: session_token},
-        )
+
+        # Determine authentication method and set headers accordingly
+        if self.config.apiKey:
+            # Use API token authentication
+            client_config: ClientConfig = ClientConfig(
+                base_url=clean_uri(str(self.config.hostPort)),
+                api_version=API_VERSION,
+                auth_header=AUTHORIZATION_HEADER,
+                auth_token=lambda: (NO_ACCESS_TOKEN, 0),
+                extra_headers={
+                    METABASE_API_HEADER: self.config.apiKey.get_secret_value()
+                },
+            )
+        else:
+            # Use session-based authentication
+            session_token = self._get_metabase_session()
+            client_config: ClientConfig = ClientConfig(
+                base_url=clean_uri(str(self.config.hostPort)),
+                api_version=API_VERSION,
+                auth_header=AUTHORIZATION_HEADER,
+                auth_token=lambda: (NO_ACCESS_TOKEN, 0),
+                extra_headers={METABASE_SESSION_HEADER: session_token},
+            )
+
         self.client = REST(client_config)
 
     def get_dashboards_list(

metadata/ingestion/source/dashboard/metabase/metadata.py

@@ -108,6 +108,8 @@ class MetabaseSource(DashboardServiceSource):
         """
         Get List of all dashboards
         """
+        if not self.source_config.includeOwners:
+            logger.debug("Skipping owner information as includeOwners is False")
         self.dashboards_list = self.client.get_dashboards_list(self.collections)
         return self.dashboards_list
 
@@ -180,6 +182,8 @@ class MetabaseSource(DashboardServiceSource):
         Get dashboard owner from email
         """
         try:
+            if not self.source_config.includeOwners:
+                return None
             if dashboard_details.creator_id:
                 owner_details = self.client.get_user_details(
                     dashboard_details.creator_id

metadata/ingestion/source/dashboard/powerbi/metadata.py

@@ -54,8 +54,6 @@ from metadata.generated.schema.type.basic import (
 from metadata.generated.schema.type.entityReferenceList import EntityReferenceList
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
-from metadata.ingestion.lineage.models import Dialect
-from metadata.ingestion.lineage.parser import LineageParser
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.ometa.utils import model_str
 from metadata.ingestion.source.dashboard.dashboard_service import DashboardServiceSource
@@ -82,7 +80,6 @@ from metadata.utils.logger import ingestion_logger
 logger = ingestion_logger()
 
 OWNER_ACCESS_RIGHTS_KEYWORDS = ["owner", "write", "admin"]
-SNOWFLAKE_QUERY_EXPRESSION_KW = "Value.NativeQuery(Snowflake.Databases("
 
 
 class PowerbiSource(DashboardServiceSource):
@@ -791,7 +788,7 @@ class PowerbiSource(DashboardServiceSource):
             logger.debug(traceback.format_exc())
         return None
 
-    def _parse_redshift_source(self, source_expression: str) -> Optional[List[dict]]:
+    def _parse_redshift_source(self, source_expression: str) -> Optional[dict]:
         try:
             db_match = re.search(
                 r'AmazonRedshift\.Database\("[^"]+","([^"]+)"\)', source_expression
@@ -808,167 +805,20 @@ class PowerbiSource(DashboardServiceSource):
                 table = schema_table_match[1] if len(schema_table_match) > 1 else None
 
             if table:  # atlease table should be fetched
-                return [{"database": database, "schema": schema, "table": table}]
+                return {"database": database, "schema": schema, "table": table}
             return None
         except Exception as exc:
             logger.debug(f"Error to parse redshift table source: {exc}")
             logger.debug(traceback.format_exc())
         return None
 
-    def _parse_snowflake_query_source(
-        self, source_expression: str
-    ) -> Optional[List[dict]]:
-        """
-        Parse snowflake query source
-        source expressions like `Value.NativeQuery(Snowflake.Databases())`
-        """
-        try:
-            logger.debug(
-                f"parsing source expression through query parser: {source_expression[:100]}"
-            )
-
-            # Look for SQL query after [Data],
-            # The pattern needs to handle the concatenated strings with & operators
-            m = re.search(
-                r'\[Data\],\s*"(.+?)"(?:,\s*null|\s*\))',
-                source_expression,
-                re.IGNORECASE | re.DOTALL,
-            )
-
-            if not m:
-                logger.debug("sql query not found in source expression")
-                return None
-
-            # Extract and clean the SQL query
-            sql_query = m.group(1).replace('""', '"')
-
-            # Handle PowerBI parameter concatenation (e.g., "& Database &")
-            # For now, replace parameter references with wildcards for parsing
-            sql_query_cleaned = re.sub(r'"?\s*&\s*\w+\s*&\s*"?\.?', "%.", sql_query)
-
-            logger.debug(f"Extracted SQL query: {sql_query}")
-            logger.debug(f"Cleaned SQL query: {sql_query_cleaned}")
-
-            if not sql_query_cleaned:
-                logger.debug("Empty SQL query after extraction")
-                return None
-
-            # Clean the query for parser
-            # 1. Replace % with a placeholder database name
-            parser_query = sql_query_cleaned.replace("%", "PLACEHOLDER_DB")
-
-            # 2. Remove PowerBI line feed markers #(lf) and clean up the query
-            parser_query = parser_query.replace("#(lf)", "\n")
-
-            # 3. Remove SQL comments that might cause issues (// style comments)
-            parser_query = re.sub(r"//[^\n]*", "", parser_query)
-
-            # 4. Clean up excessive whitespace
-            parser_query = re.sub(r"\s+", " ", parser_query).strip()
-
-            logger.debug(
-                f"Attempting LineageParser with cleaned query: {parser_query[:200]}"
-            )
-
-            try:
-                parser = LineageParser(
-                    parser_query, dialect=Dialect.SNOWFLAKE, timeout_seconds=30
-                )
-            except Exception as parser_exc:
-                logger.debug(f"LineageParser failed with error: {parser_exc}")
-                logger.debug(f"Failed query was: {parser_query[:200]}...")
-                return None
-
-            if parser.source_tables:
-                logger.debug(
-                    f"LineageParser found {len(parser.source_tables)} source table(s)"
-                )
-                for table in parser.source_tables:
-                    logger.debug(
-                        f"source table: {table.raw_name}, schema: {table.schema if hasattr(table, 'schema') else 'N/A'}"
-                    )
-                lineage_tables_list = []
-                for source_table in parser.source_tables:
-                    # source_table = parser.source_tables[0]
-
-                    # Extract database from schema's parent if it exists
-                    database = None
-                    schema = None
-
-                    if hasattr(source_table, "schema") and source_table.schema:
-                        # Log what we have in the schema object
-                        logger.debug(
-                            f"Schema object type: {type(source_table.schema)}, value: {source_table.schema}"
-                        )
-
-                        # Get schema as string first
-                        schema_str = (
-                            source_table.schema.raw_name
-                            if hasattr(source_table.schema, "raw_name")
-                            else str(source_table.schema)
-                        )
-
-                        # If schema contains dots, it might be database.schema format
-                        if "." in schema_str:
-                            parts = schema_str.split(".")
-                            if len(parts) == 2:
-                                # Format: database.schema
-                                # Check for placeholder (case insensitive)
-                                database = (
-                                    parts[0]
-                                    if parts[0].upper() != "PLACEHOLDER_DB"
-                                    else None
-                                )
-                                schema = parts[1]
-                            else:
-                                # Just use as is
-                                schema = schema_str
-                        else:
-                            schema = schema_str
-                            # Check if schema has a parent (database)
-                            if (
-                                hasattr(source_table.schema, "parent")
-                                and source_table.schema.parent
-                            ):
-                                database = (
-                                    source_table.schema.parent.raw_name
-                                    if hasattr(source_table.schema.parent, "raw_name")
-                                    else str(source_table.schema.parent)
-                                )
-
-                    # Filter out placeholder values (case insensitive)
-                    if database and database.upper() == "PLACEHOLDER_DB":
-                        database = None
-
-                    table = source_table.raw_name
-
-                    if table:
-                        logger.debug(f"tables found = {database}.{schema}.{table}")
-                        lineage_tables_list.append(
-                            {
-                                "database": database,
-                                "schema": schema,
-                                "table": table,
-                            }
-                        )
-                return lineage_tables_list
-            logger.debug("tables in query not found through parser")
-            return None
-        except Exception as exc:
-            logger.debug(f"Error parsing snowflake query source: {exc}")
-            logger.debug(traceback.format_exc())
-        return None
-
     def _parse_snowflake_source(
         self, source_expression: str, datamodel_entity: DashboardDataModel
-    ) -> Optional[List[dict]]:
+    ) -> Optional[dict]:
         try:
             if "Snowflake.Databases" not in source_expression:
                 # Not a snowflake valid expression
                 return None
-            if SNOWFLAKE_QUERY_EXPRESSION_KW in source_expression:
-                # snowflake query source identified
-                return self._parse_snowflake_query_source(source_expression)
             db_match = re.search(
                 r'\[Name=(?:"([^"]+)"|([^,]+)),Kind="Database"\]', source_expression
             )
@@ -988,13 +838,11 @@ class PowerbiSource(DashboardServiceSource):
             view = self._parse_snowflake_regex_exp(view_match, datamodel_entity)
 
             if table or view:  # atlease table or view should be fetched
-                return [
-                    {
-                        "database": database,
-                        "schema": schema,
-                        "table": table if table else view,
-                    }
-                ]
+                return {
+                    "database": database,
+                    "schema": schema,
+                    "table": table if table else view,
+                }
             return None
         except Exception as exc:
             logger.debug(f"Error to parse snowflake table source: {exc}")
@@ -1003,29 +851,29 @@ class PowerbiSource(DashboardServiceSource):
 
     def _parse_table_info_from_source_exp(
         self, table: PowerBiTable, datamodel_entity: DashboardDataModel
-    ) -> Optional[List[dict]]:
+    ) -> dict:
         try:
             if not isinstance(table.source, list):
-                return None
+                return {}
             source_expression = table.source[0].expression
             if not source_expression:
                 logger.debug(f"No source expression found for table: {table.name}")
-                return None
+                return {}
             # parse snowflake source
-            table_info_list = self._parse_snowflake_source(
+            table_info = self._parse_snowflake_source(
                 source_expression, datamodel_entity
             )
-            if isinstance(table_info_list, List):
-                return table_info_list
+            if isinstance(table_info, dict):
+                return table_info
             # parse redshift source
-            table_info_list = self._parse_redshift_source(source_expression)
-            if isinstance(table_info_list, List):
-                return table_info_list
-            return None
+            table_info = self._parse_redshift_source(source_expression)
+            if isinstance(table_info, dict):
+                return table_info
+            return {}
         except Exception as exc:
             logger.debug(f"Error to parse table source: {exc}")
             logger.debug(traceback.format_exc())
-        return None
+        return {}
 
     def _get_table_and_datamodel_lineage(
         self,
@@ -1044,64 +892,60 @@ class PowerbiSource(DashboardServiceSource):
         ) = self.parse_db_service_prefix(db_service_prefix)
 
         try:
-            table_info_list = self._parse_table_info_from_source_exp(
-                table, datamodel_entity
-            )
-            if isinstance(table_info_list, List):
-                for table_info in table_info_list:
-                    table_name = table_info.get("table") or table.name
-                    schema_name = table_info.get("schema")
-                    database_name = table_info.get("database")
-                    if (
-                        prefix_table_name
-                        and table_name
-                        and prefix_table_name.lower() != table_name.lower()
-                    ):
-                        logger.debug(
-                            f"Table {table_name} does not match prefix {prefix_table_name}"
-                        )
-                        return
+            table_info = self._parse_table_info_from_source_exp(table, datamodel_entity)
+            table_name = table_info.get("table") or table.name
+            schema_name = table_info.get("schema")
+            database_name = table_info.get("database")
+            if (
+                prefix_table_name
+                and table_name
+                and prefix_table_name.lower() != table_name.lower()
+            ):
+                logger.debug(
+                    f"Table {table_name} does not match prefix {prefix_table_name}"
+                )
+                return
 
-                    if (
-                        prefix_schema_name
-                        and schema_name
-                        and prefix_schema_name.lower() != schema_name.lower()
-                    ):
-                        logger.debug(
-                            f"Schema {table_info.get('schema')} does not match prefix {prefix_schema_name}"
-                        )
-                        return
+            if (
+                prefix_schema_name
+                and schema_name
+                and prefix_schema_name.lower() != schema_name.lower()
+            ):
+                logger.debug(
+                    f"Schema {table_info.get('schema')} does not match prefix {prefix_schema_name}"
+                )
+                return
 
-                    if (
-                        prefix_database_name
-                        and database_name
-                        and prefix_database_name.lower() != database_name.lower()
-                    ):
-                        logger.debug(
-                            f"Database {table_info.get('database')} does not match prefix {prefix_database_name}"
-                        )
-                        return
+            if (
+                prefix_database_name
+                and database_name
+                and prefix_database_name.lower() != database_name.lower()
+            ):
+                logger.debug(
+                    f"Database {table_info.get('database')} does not match prefix {prefix_database_name}"
+                )
+                return
 
-                    fqn_search_string = build_es_fqn_search_string(
-                        service_name=prefix_service_name or "*",
-                        table_name=(prefix_table_name or table_name),
-                        schema_name=(prefix_schema_name or schema_name),
-                        database_name=(prefix_database_name or database_name),
-                    )
-                    table_entity = self.metadata.search_in_any_service(
-                        entity_type=Table,
-                        fqn_search_string=fqn_search_string,
-                    )
-                    if table_entity and datamodel_entity:
-                        columns_list = [column.name for column in table.columns]
-                        column_lineage = self._get_column_lineage(
-                            table_entity, datamodel_entity, columns_list
-                        )
-                        yield self._get_add_lineage_request(
-                            to_entity=datamodel_entity,
-                            from_entity=table_entity,
-                            column_lineage=column_lineage,
-                        )
+            fqn_search_string = build_es_fqn_search_string(
+                service_name=prefix_service_name or "*",
+                table_name=(prefix_table_name or table_name),
+                schema_name=(prefix_schema_name or schema_name),
+                database_name=(prefix_database_name or database_name),
+            )
+            table_entity = self.metadata.search_in_any_service(
+                entity_type=Table,
+                fqn_search_string=fqn_search_string,
+            )
+            if table_entity and datamodel_entity:
+                columns_list = [column.name for column in table.columns]
+                column_lineage = self._get_column_lineage(
+                    table_entity, datamodel_entity, columns_list
+                )
+                yield self._get_add_lineage_request(
+                    to_entity=datamodel_entity,
+                    from_entity=table_entity,
+                    column_lineage=column_lineage,
+                )
         except Exception as exc:  # pylint: disable=broad-except
             yield Either(
                 left=StackTraceError(