openmetadata-ingestion 1.9.0.0__py3-none-any.whl → 1.10.14.4__py3-none-any.whl

metadata/pii/tag_analyzer.py

@@ -0,0 +1,124 @@
+from typing import Sequence, final
+
+from presidio_analyzer import (
+    AnalyzerEngine,
+    EntityRecognizer,
+    RecognizerRegistry,
+    RecognizerResult,
+)
+from presidio_analyzer.nlp_engine import NlpEngine
+
+from metadata.generated.schema.entity.classification.tag import Tag
+from metadata.generated.schema.entity.data.table import Column, Table
+from metadata.generated.schema.type.recognizer import RecognizerException, Target
+from metadata.pii.algorithms.feature_extraction import split_column_name
+from metadata.pii.algorithms.presidio_recognizer_factory import (
+    PresidioRecognizerFactory,
+)
+from metadata.pii.constants import SUPPORTED_LANG
+from metadata.utils.entity_link import (
+    get_entity_link,  # pyright: ignore[reportUnknownVariableType]
+)
+from metadata.utils.fqn import FQN_SEPARATOR
+
+
+@final
+class TagAnalyzer:
+    """An adapter that allows easy obtention of presidio EntityRecognizers from Tag's configuration"""
+
+    tag: Tag
+
+    def __init__(self, tag: Tag, column: Column, nlp_engine: NlpEngine):
+        self.tag = tag
+        self._column = column
+        self._nlp_engine = nlp_engine
+
+    def should_skip_recognizer(self, exception_list: list[RecognizerException]):
+        blacklisted_entities = {ex.entityLink.root for ex in exception_list}
+
+        (
+            *table_fqn_parts,
+            column_name,
+        ) = self._column.fullyQualifiedName.root.split(  # pyright: ignore[reportOptionalMemberAccess]
+            FQN_SEPARATOR
+        )
+        return (
+            get_entity_link(
+                Table, FQN_SEPARATOR.join(table_fqn_parts), column_name=column_name
+            )
+            in blacklisted_entities
+        )
+
+    def get_recognizers_by(self, target: Target) -> list[EntityRecognizer]:
+        if self.tag.autoClassificationEnabled is False:
+            return []
+
+        recognizers: list[EntityRecognizer] = []
+
+        for recognizer in self.tag.recognizers or []:
+            if recognizer.target is not target or self.should_skip_recognizer(
+                recognizer.exceptionList or []
+            ):
+                continue
+
+            created = PresidioRecognizerFactory.create_recognizer(recognizer)
+            if created is not None:
+                recognizers.append(created)
+
+        return recognizers
+
+    @property
+    def content_recognizers(self) -> list[EntityRecognizer]:
+        return self.get_recognizers_by(Target.content)
+
+    @property
+    def column_recognizers(self) -> list[EntityRecognizer]:
+        return self.get_recognizers_by(Target.column_name)
+
+    @property
+    def _column_name(self) -> str:
+        return self._column.name.root
+
+    def build_analyzer_with(
+        self, recognizers: list[EntityRecognizer]
+    ) -> AnalyzerEngine:
+        recognizer_registry = RecognizerRegistry(recognizers=recognizers)
+        return AnalyzerEngine(
+            registry=recognizer_registry,
+            nlp_engine=self._nlp_engine,
+            supported_languages=[SUPPORTED_LANG],
+        )
+
+    def analyze_content(self, values: Sequence[str]) -> float:
+        recognizers = self.content_recognizers
+
+        if not recognizers:
+            return 0.0
+
+        context = split_column_name(self._column_name)
+        analyzer = self.build_analyzer_with(recognizers)
+
+        results: list[RecognizerResult] = []
+        for value in values:
+            results.extend(
+                analyzer.analyze(value, language=SUPPORTED_LANG, context=context)
+            )
+
+        if not results:
+            return 0.0
+
+        return sum(r.score for r in results) / len(results)
+
+    def analyze_column(self) -> float:
+        recognizers = self.column_recognizers
+
+        if not recognizers:
+            return 0.0
+
+        analyzer = self.build_analyzer_with(recognizers)
+        results = analyzer.analyze(self._column_name, language=SUPPORTED_LANG)
+
+        if not results:
+            return 0.0
+
+        return sum(r.score for r in results) / len(results)

metadata/pii/tag_processor.py

@@ -0,0 +1,100 @@
+from typing import Any, Callable, Generator, Iterable, List, Optional, Sequence
+
+from presidio_analyzer.nlp_engine import NlpEngine
+
+from metadata.generated.schema.entity.classification.tag import Tag
+from metadata.generated.schema.entity.data.table import Column
+from metadata.generated.schema.metadataIngestion.workflow import (
+    OpenMetadataWorkflowConfig,
+)
+from metadata.generated.schema.type.tagLabel import (
+    LabelType,
+    State,
+    TagLabel,
+    TagSource,
+)
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.pii.algorithms.classifiers import TagClassifier
+from metadata.pii.algorithms.presidio_utils import load_nlp_engine
+from metadata.pii.algorithms.utils import get_top_classes, normalize_scores
+from metadata.pii.base_processor import AutoClassificationProcessor
+from metadata.pii.constants import PII
+from metadata.pii.tag_analyzer import TagAnalyzer
+
+
+class TagAnalyzerGenerator:
+    def __init__(self, metadata: OpenMetadata, nlp_engine: Optional[NlpEngine] = None):
+        self.metadata = metadata
+        self.nlp_engine = nlp_engine or load_nlp_engine()
+        self._tags: List[Tag] = []
+
+    @property
+    def tags(self) -> List[Tag]:
+        if not self._tags:
+            self._tags = list(
+                self.metadata.list_all_entities(
+                    entity=Tag,
+                    fields=[
+                        "name",
+                        "recognizers",
+                        "fullyQualifiedName",
+                        "provider",
+                    ],
+                )
+            )
+        return self._tags
+
+    def __call__(self, column: Column) -> Generator[TagAnalyzer, None, None]:
+        for tag in self.tags:
+            yield TagAnalyzer(tag=tag, column=column, nlp_engine=self.nlp_engine)
+
+
+class TagProcessor(AutoClassificationProcessor):
+    name = "Tag Classification Processor"
+
+    def __init__(
+        self,
+        config: OpenMetadataWorkflowConfig,
+        metadata: OpenMetadata,
+        generate_tag_analyzers: Callable[[Column], Iterable[TagAnalyzer]],
+        tolerance: float = 0.7,
+    ) -> None:
+        super().__init__(config, metadata)
+        self.confidence_threshold = self.source_config.confidence / 100
+        self._tolerance = tolerance
+        self._generate_tag_analyzers = generate_tag_analyzers
+
+    @staticmethod
+    def build_tag_label(tag_fqn: str) -> TagLabel:
+        tag_label = TagLabel(
+            tagFQN=tag_fqn,
+            source=TagSource.Classification,
+            state=State.Suggested,
+            labelType=LabelType.Generated,
+        )
+
+        return tag_label
+
+    def create_column_tag_labels(
+        self, column: Column, sample_data: Sequence[Any]
+    ) -> Sequence[TagLabel]:
+        for tag in column.tags or []:
+            if PII in tag.tagFQN.root:
+                return []
+
+        classifier = TagClassifier(
+            tag_analyzers=self._generate_tag_analyzers(column),
+        )
+
+        # Get the tags and confidence
+        scores = classifier.predict_scores(
+            sample_data,
+            column_name=column.fullyQualifiedName,
+            column_data_type=column.dataType,
+        )
+
+        scores = normalize_scores(scores, tol=self._tolerance)
+
+        # winner is at most 1 tag
+        winner = get_top_classes(scores, 1, self.confidence_threshold)
+        return [self.build_tag_label(tag) for tag in winner]

metadata/profiler/interface/sqlalchemy/bigquery/profiler_interface.py

@@ -13,11 +13,13 @@
 Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
+from copy import deepcopy
 from typing import List, Type, cast
 
 from sqlalchemy import Column, inspect
 
 from metadata.generated.schema.entity.data.table import SystemProfile
+from metadata.generated.schema.security.credentials.gcpValues import SingleProjectId
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     SQAProfilerInterface,
 )
@@ -27,6 +29,7 @@ from metadata.profiler.metrics.system.bigquery.system import (
 from metadata.profiler.metrics.system.system import System
 from metadata.profiler.processor.runner import QueryRunner
 from metadata.utils.logger import profiler_interface_registry_logger
+from metadata.utils.ssl_manager import get_ssl_connection
 
 logger = profiler_interface_registry_logger()
 
@@ -34,6 +37,19 @@ logger = profiler_interface_registry_logger()
 class BigQueryProfilerInterface(SQAProfilerInterface):
     """BigQuery profiler interface"""
 
+    def create_session(self):
+        connection_config = deepcopy(self.service_connection_config)
+        # Create a modified connection for BigQuery with the correct project ID
+        if (
+            hasattr(connection_config.credentials.gcpConfig, "projectId")
+            and self.table_entity.database
+        ):
+            connection_config.credentials.gcpConfig.projectId = SingleProjectId(
+                root=self.table_entity.database.name
+            )
+            self.connection = get_ssl_connection(connection_config)
+        return super().create_session()
+
     def _compute_system_metrics(
         self,
         metrics: Type[System],
@@ -49,6 +65,7 @@ class BigQueryProfilerInterface(SQAProfilerInterface):
             session=self.session,
             runner=runner,
             usage_location=self.service_connection_config.usageLocation,
+            billing_project_id=self.service_connection_config.billingProjectId,
         )
         return instance.get_system_metrics()
 

metadata/profiler/interface/sqlalchemy/databricks/profiler_interface.py

@@ -23,6 +23,7 @@ from metadata.generated.schema.entity.data.table import (
     ColumnName,
     DataType,
     SystemProfile,
+    TableType,
 )
 from metadata.generated.schema.entity.services.databaseService import (
     DatabaseServiceType,
@@ -51,6 +52,11 @@ class DatabricksProfilerInterface(SQAProfilerInterface):
         *args,
         **kwargs,
     ) -> List[SystemProfile]:
+        if self.table_entity.tableType in (TableType.View, TableType.MaterializedView):
+            logger.debug(
+                f"Skipping {metrics.name()} metric for view {runner.table_name}"
+            )
+            return []
         logger.debug(f"Computing {metrics.name()} metric for {runner.table_name}")
         self.system_metrics_class = cast(
             Type[DatabricksSystemMetricsComputer], self.system_metrics_class
@@ -79,10 +85,28 @@ class DatabricksProfilerInterface(SQAProfilerInterface):
             result += "`.`".join(splitted_result)
         return result
 
+    def visit_table(self, *args, **kwargs):
+        result = super(  # pylint: disable=bad-super-call
+            HiveCompiler, self
+        ).visit_table(*args, **kwargs)
+        # Handle table references with hyphens in database/schema names
+        # Format: `database`.`schema`.`table` for Unity Catalog/Databricks
+        if "." in result and not result.startswith("`"):
+            parts = result.split(".")
+            quoted_parts = []
+            for part in parts:
+                if "-" in part and not (part.startswith("`") and part.endswith("`")):
+                    quoted_parts.append(f"`{part}`")
+                else:
+                    quoted_parts.append(part)
+            result = ".".join(quoted_parts)
+        return result
+
     def __init__(self, service_connection_config, **kwargs):
         super().__init__(service_connection_config=service_connection_config, **kwargs)
         self.set_catalog(self.session)
         HiveCompiler.visit_column = DatabricksProfilerInterface.visit_column
+        HiveCompiler.visit_table = DatabricksProfilerInterface.visit_table
 
     def _get_struct_columns(self, columns: List[OMColumn], parent: str):
         """Get struct columns"""

metadata/profiler/interface/sqlalchemy/unity_catalog/profiler_interface.py

@@ -14,6 +14,8 @@ Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
 
+from sqlalchemy import event
+from sqlalchemy.orm import scoped_session, sessionmaker
 
 from metadata.ingestion.source.database.databricks.connection import (
     get_connection as databricks_get_connection,
@@ -26,5 +28,17 @@ from metadata.profiler.interface.sqlalchemy.databricks.profiler_interface import
 class UnityCatalogProfilerInterface(DatabricksProfilerInterface):
     def create_session(self):
         self.connection = databricks_get_connection(self.service_connection_config)
-        super().create_session()
-        self.set_catalog(self.session)
+
+        # Create custom session factory with after_begin event to set catalog
+        session_maker = sessionmaker(bind=self.connection)
+
+        @event.listens_for(session_maker, "after_begin")
+        def set_catalog(session, transaction, connection):
+            # Safely quote the catalog name to prevent SQL injection
+            quoted_catalog = connection.dialect.identifier_preparer.quote(
+                self.service_connection_config.catalog
+            )
+            connection.execute(f"USE CATALOG {quoted_catalog};")
+
+        self.session_factory = scoped_session(session_maker)
+        self.session = self.session_factory()

metadata/profiler/metrics/hybrid/cardinality_distribution.py

@@ -0,0 +1,232 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  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.
+
+"""
+Cardinality Distribution Metric definition
+"""
+from typing import Any, Dict, Optional
+
+from sqlalchemy import case, column, func, or_
+from sqlalchemy.orm import DeclarativeMeta, Session
+
+from metadata.profiler.metrics.core import HybridMetric
+from metadata.profiler.metrics.static.count import Count
+from metadata.profiler.metrics.static.distinct_count import DistinctCount
+from metadata.profiler.orm.registry import is_concatenable, is_enum
+from metadata.utils.logger import profiler_logger
+
+logger = profiler_logger()
+
+
+class CardinalityDistribution(HybridMetric):
+    """
+    CARDINALITY_DISTRIBUTION Metric
+
+    Given a column, return the cardinality distribution showing top categories
+    with an "Others" bucket. Only works for concatenable types (strings, enums).
+    """
+
+    threshold_percentage: float = 0.02  # 2% threshold for "Others" bucket
+    min_buckets: int = 5  # Minimum number of top categories to show
+
+    @classmethod
+    def name(cls):
+        return "cardinalityDistribution"
+
+    @property
+    def metric_type(self):
+        return dict
+
+    def fn(
+        self,
+        sample: Optional[DeclarativeMeta],
+        res: Dict[str, Any],
+        session: Optional[Session] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Build the Cardinality Distribution metric query
+        """
+        if not session or self.col is None:
+            raise AttributeError(
+                f"We are missing the {'session' if not session else 'column'} attribute to compute the CardinalityDistribution."
+            )
+
+        if not (is_concatenable(self.col.type) or is_enum(self.col.type)):
+            logger.debug(
+                f"CardinalityDistribution not applicable for {self.col.name} because type {self.col.type} is not supported."
+            )
+            return None
+
+        # Get total count from other metrics if available, otherwise compute it
+        total_count = res.get(Count.name())
+        distinct_count = res.get(DistinctCount.name())
+
+        if not total_count or total_count == 0:
+            return None
+
+        if total_count == distinct_count:
+            logger.debug(
+                f"CardinalityDistribution not applicable for {self.col.name} because all values are distinct."
+            )
+            return None
+
+        col = column(self.col.name, self.col.type)
+        threshold = self.threshold_percentage * total_count
+
+        # Build a cross-database compatible query using CTEs
+        # Step 1: Get value counts
+        value_counts_cte = (
+            session.query(  # type: ignore
+                col.label("category"), func.count(col).label("category_count")
+            )
+            .select_from(sample)
+            .group_by(col)
+            .cte("value_counts")
+        )
+
+        # Step 2: Get top categories
+        top_categories_cte = (
+            session.query(value_counts_cte.c.category)  # type: ignore
+            .select_from(value_counts_cte)
+            .order_by(value_counts_cte.c.category_count.desc())
+            .limit(self.min_buckets)
+            .cte("top_categories")
+        )
+
+        # Step 3: Create categorization CTE to avoid complex GROUP BY
+        categorized_cte = (
+            session.query(  # type: ignore
+                case(
+                    (
+                        or_(
+                            value_counts_cte.c.category.in_(
+                                session.query(top_categories_cte.c.category)  # type: ignore
+                            ),
+                            value_counts_cte.c.category_count >= threshold,
+                        ),
+                        value_counts_cte.c.category,
+                    ),
+                    else_="Others",
+                ).label("category_group"),
+                value_counts_cte.c.category_count,
+            )
+            .select_from(value_counts_cte)
+            .cte("categorized")
+        )
+
+        # Step 4: Final aggregation with simple GROUP BY
+        query = (
+            session.query(  # type: ignore
+                categorized_cte.c.category_group,
+                func.sum(categorized_cte.c.category_count).label("total_count"),
+            )
+            .select_from(categorized_cte)
+            .group_by(categorized_cte.c.category_group)
+            .order_by(func.sum(categorized_cte.c.category_count).desc())
+        )
+
+        rows = query.all()
+
+        if rows:
+            return {
+                "categories": [row[0] for row in rows],
+                "counts": [int(row[1]) for row in rows],
+                "percentages": [round((row[1] / total_count) * 100, 2) for row in rows],
+            }
+        return None
+
+    def df_fn(self, res: Dict[str, Any], dfs=None):
+        """
+        Pandas implementation for dataframes
+        """
+        # pylint: disable=import-outside-toplevel
+        import pandas as pd
+
+        if self.col is None:
+            return None
+
+        if not (is_concatenable(self.col.type) or is_enum(self.col.type)):
+            logger.debug(
+                f"CardinalityDistribution not applicable for {self.col.name} because type {self.col.type} is not supported."
+            )
+            return None
+
+        # Get total count and distinct count from other metrics
+        total_count = res.get(Count.name())
+        distinct_count = res.get(DistinctCount.name())
+
+        if not total_count or total_count == 0:
+            return None
+
+        if total_count == distinct_count:
+            logger.debug(
+                f"CardinalityDistribution not applicable for {self.col.name} because all values are distinct."
+            )
+            return None
+
+        try:
+            if dfs is None:
+                return None
+
+            # Calculate threshold
+            threshold = self.threshold_percentage * total_count
+
+            # Use pandas value_counts() for efficient processing - much faster for large datasets
+            combined_value_counts = pd.Series(dtype="object")
+
+            for df in dfs:
+                # Use value_counts() directly on the column - much more memory efficient
+                df_value_counts = df[self.col.name].value_counts()
+                combined_value_counts = combined_value_counts.add(
+                    df_value_counts, fill_value=0
+                )
+
+            # Get top categories that meet the threshold OR are in the top N
+            top_categories = {}
+            others_count = 0
+
+            # Get the top N categories by count
+            top_n_categories = set(combined_value_counts.head(self.min_buckets).index)
+
+            # Process in descending order of frequency
+            for category, count in combined_value_counts.items():
+                # First check if it's in top N, then check threshold
+                if category in top_n_categories or count >= threshold:
+                    top_categories[category] = count
+                else:
+                    others_count += count
+
+            # Build result
+            categories = []
+            counts = []
+            percentages = []
+
+            for category, count in top_categories.items():
+                categories.append(str(category))
+                counts.append(int(count))
+                percentages.append(round((count / total_count) * 100, 2))
+
+            if others_count > 0:
+                categories.append("Others")
+                counts.append(int(others_count))
+                percentages.append(round((others_count / total_count) * 100, 2))
+
+            return {
+                "categories": categories,
+                "counts": counts,
+                "percentages": percentages,
+            }
+
+        except Exception as err:
+            logger.debug(
+                f"Error computing CardinalityDistribution for {self.col.name}: {err}"
+            )
+            return None

metadata/profiler/metrics/hybrid/histogram.py

@@ -151,7 +151,7 @@ class Histogram(HybridMetric):
                 "We are missing the session attribute to compute the Histogram."
             )
 
-        if not (is_quantifiable(self.col.type) or is_concatenable(self.col.type)) or (
+        if not is_quantifiable(self.col.type) or (
             is_value_non_numeric(res.get(Min.name()))
             or is_value_non_numeric(res.get(Max.name()))
         ):

metadata/profiler/metrics/registry.py

@@ -26,6 +26,9 @@ from metadata.profiler.metrics.composed.like_ratio import LikeRatio
 from metadata.profiler.metrics.composed.non_parametric_skew import NonParametricSkew
 from metadata.profiler.metrics.composed.null_ratio import NullRatio
 from metadata.profiler.metrics.composed.unique_ratio import UniqueRatio
+from metadata.profiler.metrics.hybrid.cardinality_distribution import (
+    CardinalityDistribution,
+)
 from metadata.profiler.metrics.hybrid.histogram import Histogram
 from metadata.profiler.metrics.static.column_count import ColumnCount
 from metadata.profiler.metrics.static.column_names import ColumnNames
@@ -104,6 +107,7 @@ class Metrics(MetricRegistry):
 
     # Hybrid Metrics
     HISTOGRAM = Histogram
+    CARDINALITY_DISTRIBUTION = CardinalityDistribution
 
     # Missing Count
     NULL_MISSING_COUNT = NullMissingCount

metadata/profiler/metrics/system/bigquery/system.py

@@ -1,6 +1,6 @@
 """BigQuery system metric source"""
 
-from typing import List
+from typing import List, Optional
 
 from pydantic import TypeAdapter
 from sqlalchemy.orm import Session
@@ -30,12 +30,14 @@ class BigQuerySystemMetricsComputer(SystemMetricsComputer, CacheProvider):
         session: Session,
         runner: QueryRunner,
         usage_location: str,
+        billing_project_id: Optional[str] = None,
     ):
         self.session = session
         self.table = runner.table_name
         self.project_id = runner.session.get_bind().url.host
         self.dataset_id = runner.schema_name
         self.usage_location = usage_location
+        self.billing_project_id = billing_project_id or self.project_id
 
     def get_deletes(self) -> List[SystemProfile]:
         return self.get_system_profile(
@@ -116,6 +118,7 @@ class BigQuerySystemMetricsComputer(SystemMetricsComputer, CacheProvider):
             usage_location=usage_location,
             project_id=project_id,
             dataset_id=dataset_id,
+            billing_project_id=self.billing_project_id,
         )
 
     @staticmethod

metadata/profiler/metrics/system/databricks/system.py

@@ -24,7 +24,7 @@ SYSTEM_QUERY = textwrap.dedent(
         '{database}' AS database,
         '{schema}' AS schema,
         '{table}' AS table
-    FROM (DESCRIBE HISTORY {database}.{schema}.{table})
+    FROM (DESCRIBE HISTORY `{database}`.`{schema}`.`{table}`)
     WHERE operation IN ({operations}) AND timestamp > DATEADD(day, -1, CURRENT_TIMESTAMP())
     """
 )

metadata/profiler/orm/converter/converter_registry.py

@@ -24,6 +24,7 @@ from metadata.profiler.orm.converter.mariadb.converter import MariaDBMapTypes
 from metadata.profiler.orm.converter.mssql.converter import MssqlMapTypes
 from metadata.profiler.orm.converter.redshift.converter import RedshiftMapTypes
 from metadata.profiler.orm.converter.snowflake.converter import SnowflakeMapTypes
+from metadata.profiler.orm.converter.trino import TrinoMapTypes
 
 converter_registry = defaultdict(lambda: CommonMapTypes)
 converter_registry[DatabaseServiceType.BigQuery] = BigqueryMapTypes
@@ -32,3 +33,4 @@ converter_registry[DatabaseServiceType.Redshift] = RedshiftMapTypes
 converter_registry[DatabaseServiceType.Mssql] = MssqlMapTypes
 converter_registry[DatabaseServiceType.AzureSQL] = AzureSqlMapTypes
 converter_registry[DatabaseServiceType.MariaDB] = MariaDBMapTypes
+converter_registry[DatabaseServiceType.Trino] = TrinoMapTypes

metadata/profiler/orm/converter/trino/__init__.py

@@ -0,0 +1,14 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  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.
+
+from .converter import TrinoMapTypes
+
+__all__ = ("TrinoMapTypes",)