snowpark-connect 0.20.2__py3-none-any.whl

snowflake/snowpark_connect/relation/map_stats.py

@@ -0,0 +1,324 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+import ast
+
+import numpy as np
+import pandas
+import pyspark.sql.connect.proto.relations_pb2 as relation_proto
+
+import snowflake.snowpark.functions as fn
+import snowflake.snowpark.types as snowpark_types
+from snowflake import snowpark
+from snowflake.snowpark.exceptions import SnowparkSQLException
+from snowflake.snowpark_connect.column_name_handler import with_column_map
+from snowflake.snowpark_connect.relation.map_relation import map_relation
+from snowflake.snowpark_connect.utils.session import get_or_create_snowpark_session
+
+
+def map_corr(
+    rel: relation_proto.Relation,
+) -> snowpark.DataFrame:
+    """
+    Find the correlation of two columns in the input DataFrame.
+
+    Returns a pandas DataFrame because the correlation of two columns produces
+    a scalar value.
+    """
+    input_df: snowpark.DataFrame = map_relation(rel.corr.input)
+    col1 = input_df._column_map.get_snowpark_column_name_from_spark_column_name(
+        rel.corr.col1
+    )
+    col2 = input_df._column_map.get_snowpark_column_name_from_spark_column_name(
+        rel.corr.col2
+    )
+    # TODO: Handle method, Snowpark does not support this yet.
+    # if rel.corr.HasField("method"):
+    #     method = rel.corr.method
+    # else:
+    #     method = "pearson"
+    result: float = input_df.corr(col1, col2)
+    return pandas.DataFrame({"corr": [result]})
+
+
+def map_cov(
+    rel: relation_proto.Relation,
+) -> snowpark.DataFrame:
+    """
+    Find the covariance of two columns in the input DataFrame.
+
+    Returns a pandas DataFrame because the corvariance of two columns produces
+    a scalar value.
+    """
+    input_df: snowpark.DataFrame = map_relation(rel.cov.input)
+    col1 = input_df._column_map.get_snowpark_column_name_from_spark_column_name(
+        rel.cov.col1
+    )
+    col2 = input_df._column_map.get_snowpark_column_name_from_spark_column_name(
+        rel.cov.col2
+    )
+    result: float = input_df.cov(col1, col2)
+    return pandas.DataFrame({"cov": [result]})
+
+
+def map_approx_quantile(
+    rel: relation_proto.Relation,
+) -> snowpark.DataFrame:
+    """
+    Find one or more approximate quantiles in the input DataFrame.
+
+    Returns a pandas DataFrame because the approximate quantile produces a
+    list of scalar values.
+    """
+    input_df: snowpark.DataFrame = map_relation(rel.approx_quantile.input)
+    cols = input_df._column_map.get_snowpark_column_names_from_spark_column_names(
+        list(rel.approx_quantile.cols)
+    )
+    quantile = list(rel.approx_quantile.probabilities)
+    # TODO: Handle relative_error, Snowpark does not support this yet.
+    result: list[float] = input_df.approxQuantile(cols, quantile)
+    # Wrap result in list here to pack the result into a single cell
+    return pandas.DataFrame({"approx_quantile": [result]})
+
+
+def map_describe(
+    rel: relation_proto.Relation,
+) -> snowpark.DataFrame:
+    """
+    Computes basic statistics for numeric columns, which includes count, mean, stddev, min, and max.
+    If no columns are provided, this function computes statistics for all numerical or string columns.
+    Non-numeric and non-string columns will be ignored.
+
+    Returns a new DataFrame that provides basic statistics for the given DataFrame
+    """
+    session = get_or_create_snowpark_session()
+    input_df: snowpark.DataFrame = map_relation(rel.describe.input)
+    spark_cols = (
+        list(rel.describe.cols)
+        if rel.describe.cols
+        else input_df._column_map.get_spark_columns()
+    )
+    cols = [
+        input_df._column_map.get_snowpark_column_name_from_spark_column_name(column)
+        for column in spark_cols
+    ]
+
+    ordered_statistics = []
+    statistics = ["count", "mean", "stddev", "min", "max"]
+    # TODO: there's a bug in Snowpark where strings can either all cast to numbers and then
+    # stddev and mean will be computed correctly, try_cast will need to be used in snowpark when
+    # strings_include_math_stats=True, this is the workaround for now
+    try:
+        df_rows = input_df.describe(cols, strings_include_math_stats=True).collect()
+    except SnowparkSQLException as e:
+        if "Numeric value" not in str(e) or "is not recognized" not in str(e):
+            # Re-raise the exception if it's not a casting error
+            raise
+        df_rows = input_df.describe(cols, strings_include_math_stats=False).collect()
+    for stat in statistics:
+        for row in df_rows:
+            if stat == row.SUMMARY:
+                ordered_statistics.append(row)
+    ordered_desc_df = session.create_dataframe(ordered_statistics)
+    return _build_column_map_helper(ordered_desc_df, input_df)
+
+
+# TODO: track missing Snowpark feature
+def map_summary(
+    rel: relation_proto.Relation,
+) -> snowpark.DataFrame:
+    """
+    Computes specified statistics for numeric or string columns. Available statistics are: count, mean, stddev, min,
+    max, arbitrary approximate percentiles specified as a percentage (e.g., 75%), count_distinct, and
+    approx_count_distinct. If no statistics are given, this function computes count, mean, stddev, min, approximate
+    quartiles (percentiles at 25%, 50%, and 75%), and max.
+
+    Returns a new DataFrame that provides specified statistics for the given DataFrame.
+    """
+    session = get_or_create_snowpark_session()
+    input_df: snowpark.DataFrame = map_relation(rel.summary.input)
+
+    numeric_and_string_spark_cols = [
+        column
+        for field, column in zip(
+            input_df.schema.fields, input_df._column_map.get_spark_columns()
+        )
+        if isinstance(
+            field.datatype, (snowpark_types._NumericType, snowpark_types.StringType)
+        )
+    ]
+
+    # this is intentional to trigger ambigous column name is two columns of same name are provided
+    numeric_and_string_snowpark_cols = [
+        input_df._column_map.get_snowpark_column_name_from_spark_column_name(column)
+        for column in numeric_and_string_spark_cols
+    ]
+
+    # Select only those columns
+    input_df = input_df.select(*numeric_and_string_snowpark_cols)
+
+    # retrieve 5 statistics from describe
+    desc_df: snowpark.DataFrame = input_df.describe([])
+    quantiles = []
+    percentages = []
+    if rel.summary.statistics:
+        statistics = list(rel.summary.statistics)
+    else:
+        # default statistics
+        statistics = ["count", "mean", "stddev", "min", "25%", "50%", "75%", "max"]
+
+    # filter out non-requested statistics
+    summary_df = desc_df.filter(desc_df.SUMMARY.isin(statistics))
+
+    summary_df = summary_df.select(
+        [fn.col(col).cast("string") for col in summary_df.columns]
+    )
+
+    # convert percentages into decimal
+    for stat in statistics:
+        if stat[-1] == "%":
+            quantiles.append(int(stat[:-1]) / 100)
+            percentages.append(stat)
+        elif stat == "count_distinct":
+            # include "count_distinct" as it's the row name
+            distinct_list_values = ["count_distinct"] + [
+                str(input_df.select(column).distinct().count())
+                for column in input_df.columns
+            ]
+            summary_df = add_stat_to_df(session, summary_df, [distinct_list_values])
+        elif stat == "approx_count_distinct":
+            approx_count_distinct_list_values = [
+                fn.approx_count_distinct(column) for column in input_df.columns
+            ]
+            approx_count_distinct_df = input_df.select(
+                *approx_count_distinct_list_values
+            )
+            approx_count_distinct_df_rows = approx_count_distinct_df.collect()
+            # convert approx_count_distinct rows into values
+            approx_count_distinct_list_values = [
+                str(value)
+                for row in approx_count_distinct_df_rows
+                for value in row.as_dict().values()
+            ]
+            # insert "approx_count_distinct" as it's the row name
+            approx_count_distinct_list_values.insert(0, "approx_count_distinct")
+            summary_df = add_stat_to_df(
+                session, summary_df, [approx_count_distinct_list_values]
+            )
+
+    if len(quantiles) > 0:
+        eligible_columns = []
+        for i, col in enumerate(input_df.columns):
+            if not isinstance(
+                input_df.schema.fields[i].datatype, snowpark_types.StringType
+            ):
+                eligible_columns.append(col)
+        approx_quantile_values = input_df.approx_quantile(
+            eligible_columns, percentile=quantiles
+        )
+
+        # Modified quantile results, inserting [None, None, None] for string columns
+        numeric_index = iter(approx_quantile_values)
+        approx_quantile_values_including_string_columns = [
+            [str(value) for value in next(numeric_index)]
+            if col in eligible_columns
+            else [None] * len(quantiles)
+            for col in input_df.columns
+        ]
+
+        approx_quantile_values_transposed = np.transpose(
+            approx_quantile_values_including_string_columns
+        )
+        # the first parameter includes each percentage as the row name
+        approx_quantile_list_values = np.hstack(
+            (np.array(percentages).reshape(-1, 1), approx_quantile_values_transposed)
+        ).tolist()
+        summary_df = add_stat_to_df(session, summary_df, approx_quantile_list_values)
+
+    # return the statistics in the requested order
+    ordered_statistics = []
+    df_rows = summary_df.collect()
+    for stat in statistics:
+        for row in df_rows:
+            if stat == row[0]:
+                ordered_statistics.append(row)
+    ordered_summary_df = session.create_dataframe(ordered_statistics)
+
+    spark_col_names = ["summary"]
+    spark_col_names.extend(numeric_and_string_spark_cols)
+
+    return with_column_map(
+        ordered_summary_df,
+        spark_col_names,
+        snowpark_column_names=ordered_summary_df.columns,
+    )
+
+
+def map_freq_items(rel: relation_proto.Relation) -> snowpark.DataFrame:
+    """
+    Returns an approximation of the most frequent values in the input, along with their approximate frequencies.
+    """
+    session = get_or_create_snowpark_session()
+    input_df: snowpark.DataFrame = map_relation(rel.freq_items.input)
+    support = rel.freq_items.support
+    spark_col_names = []
+    cols = input_df._column_map.get_snowpark_column_names_from_spark_column_names(
+        list(rel.freq_items.cols)
+    )
+    approx_top_k_df = input_df.select(
+        *[
+            fn.function("approx_top_k")(fn.col(col), round(input_df.count() / support))
+            for col in cols
+        ]
+    )
+    approx_top_k_df_rows = approx_top_k_df.collect()
+    approx_top_k_values = [
+        ast.literal_eval(value)
+        for row in approx_top_k_df_rows
+        for value in row.as_dict().values()
+    ]
+    filtered_values = [
+        [
+            entry[0]
+            for entry in value
+            if entry[1] >= support * sum(count for _, count in value)
+        ]
+        for value in approx_top_k_values
+    ]
+
+    for sp_col_name in cols:
+        spark_col_names.append(
+            f"{input_df._column_map.get_spark_column_name_from_snowpark_column_name(sp_col_name)}_freqItems"
+        )
+    approx_top_k_df = session.createDataFrame([filtered_values], spark_col_names)
+    return with_column_map(
+        approx_top_k_df, spark_col_names, snowpark_column_names=spark_col_names
+    )
+
+
+def add_stat_to_df(
+    session,
+    summary_df,
+    stat_values,
+) -> snowpark.DataFrame:
+    df_data = [tuple(row) for row in stat_values]
+    return summary_df.union(session.createDataFrame(df_data, summary_df.schema))
+
+
+def _build_column_map_helper(
+    desc_df: snowpark.DataFrame,
+    input_df: snowpark.DataFrame,
+) -> snowpark.DataFrame:
+    spark_col_names = ["summary"]
+    for i, sp_col_name in enumerate(desc_df.columns):
+        if i != 0:
+            spark_col_names.append(
+                input_df._column_map.get_spark_column_name_from_snowpark_column_name(
+                    sp_col_name
+                )
+            )
+
+    return with_column_map(
+        desc_df, spark_col_names, snowpark_column_names=desc_df.columns
+    )

snowflake/snowpark_connect/relation/map_subquery_alias.py

@@ -0,0 +1,32 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+import pyspark.sql.connect.proto.relations_pb2 as relation_proto
+
+from snowflake import snowpark
+from snowflake.snowpark_connect.column_name_handler import with_column_map
+from snowflake.snowpark_connect.relation.map_relation import map_relation
+
+
+def map_alias(rel: relation_proto.Relation) -> snowpark.DataFrame:
+    """
+    Returns an aliased dataframe in which the columns can now be referenced to using col(<df alias>, <column name>).
+    """
+    alias: str = rel.subquery_alias.alias
+    # we set reuse_parsed_plan=False because we need new expr_id for the attributes (output columns) in aliased snowpark dataframe
+    # reuse_parsed_plan will lead to ambiguous column name for operations like joining two dataframes that are aliased from the same dataframe
+    input_df: snowpark.DataFrame = map_relation(
+        rel.subquery_alias.input, reuse_parsed_plan=False
+    )
+    input_df._alias = alias
+    qualifiers = [[alias]] * len(input_df._column_map.columns)
+
+    return with_column_map(
+        input_df,
+        input_df._column_map.get_spark_columns(),
+        input_df._column_map.get_snowpark_columns(),
+        column_metadata=input_df._column_map.column_metadata,
+        column_qualifiers=qualifiers,
+        parent_column_name_map=input_df._column_map.get_parent_column_name_map(),
+    )

snowflake/snowpark_connect/relation/map_udtf.py

@@ -0,0 +1,288 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+from typing import Any, List, Tuple
+
+import pyspark.sql.connect.proto.relations_pb2 as relation_proto
+import pyspark.sql.connect.proto.types_pb2 as types_proto
+from pyspark.errors.exceptions.base import PySparkTypeError, PythonException
+
+from snowflake import snowpark
+from snowflake.snowpark.functions import col, parse_json
+from snowflake.snowpark.types import (
+    ArrayType,
+    DataType,
+    MapType,
+    StructType,
+    VariantType,
+)
+from snowflake.snowpark_connect.column_name_handler import (
+    ColumnNameMap,
+    with_column_map,
+)
+from snowflake.snowpark_connect.config import (
+    get_boolean_session_config_param,
+    global_config,
+)
+from snowflake.snowpark_connect.expression.map_expression import (
+    map_single_column_expression,
+)
+from snowflake.snowpark_connect.expression.typer import ExpressionTyper
+from snowflake.snowpark_connect.type_mapping import (
+    parse_ddl_string,
+    proto_to_snowpark_type,
+)
+from snowflake.snowpark_connect.utils.context import push_udtf_context
+from snowflake.snowpark_connect.utils.session import (
+    get_or_create_snowpark_session,
+    get_python_udxf_import_files,
+)
+from snowflake.snowpark_connect.utils.udtf_helper import (
+    SnowparkUDTF,
+    create_udtf_in_sproc,
+    require_creating_udtf_in_sproc,
+    udtf_check,
+)
+from snowflake.snowpark_connect.utils.udtf_utils import create_udtf
+
+
+def build_expected_types_from_parsed(
+    parsed_return: types_proto.DataType,
+) -> List[Tuple[str, Any]]:
+    """
+    Recursively build expected_types from a PySpark StructType schema.
+    Each entry is a tuple: (kind, type_marker)
+    kind: "scalar", "array", or "struct"
+    type_marker: for scalar, a tuple (python_type, marker_dict); for array, (python_type, marker_dict); for struct, dict of fields
+    """
+
+    def parse_type_marker(
+        typ: types_proto.DataType,
+    ) -> Tuple[str, Any]:
+        match typ.WhichOneof("kind"):
+            case "map":
+                key_type = parse_type_marker(typ.map.key_type)
+                value_type = parse_type_marker(typ.map.value_type)
+                return "scalar", ("dict", {"dict": (key_type, value_type)})
+            case "array":
+                element_type = parse_type_marker(typ.array.element_type)
+                return "array", element_type
+            case "struct":
+                struct_fields = {
+                    sf.name: parse_type_marker(sf.data_type) for sf in typ.struct.fields
+                }
+                return "struct", struct_fields
+            case "string":
+                return "scalar", ("str", "string")
+            case "integer" | "short" | "long":
+                return "scalar", ("int", "int")
+            case "float" | "double":
+                return "scalar", ("float", "float")
+            case "boolean":
+                return "scalar", ("bool", "bool")
+            case "date":
+                return "scalar", ("datetime.date", "date")
+            case "timestamp":
+                return "scalar", ("datetime.datetime", "timestamp")
+            case "binary":
+                return "scalar", ("bytes", "binary")
+            case "byte":
+                # ByteType in Spark represents an 8-bit signed integer (values from -128 to 127), not a bytes type
+                return "scalar", ("int", "byte")
+            case "decimal":
+                # Use Spark's default precision (10) and scale (0) if not specified in the proto
+                precision = (
+                    typ.decimal.precision if typ.decimal.HasField("precision") else 10
+                )
+                scale = typ.decimal.scale if typ.decimal.HasField("scale") else 0
+                marker = {"type": "decimal", "precision": precision, "scale": scale}
+                return "scalar", ("decimal.Decimal", marker)
+            case _:
+                return "scalar", ("object", "unknown")
+
+    return [parse_type_marker(field.data_type) for field in parsed_return.struct.fields]
+
+
+def convert_maptype_to_variant(schema: StructType) -> StructType:
+    """
+    Recursively convert all MapType fields in a StructType (or ArrayType of StructType) to VariantType.
+    """
+    if isinstance(schema, StructType):
+        for field in schema.fields:
+            if isinstance(field.datatype, MapType):
+                field.datatype = VariantType()
+            elif isinstance(field.datatype, StructType):
+                convert_maptype_to_variant(field.datatype)
+            elif isinstance(field.datatype, ArrayType):
+                # If array of struct/map, recurse
+                if isinstance(field.datatype.element_type, MapType):
+                    field.datatype.element_type = VariantType()
+                elif isinstance(field.datatype.element_type, StructType):
+                    convert_maptype_to_variant(field.datatype.element_type)
+    return schema
+
+
+def process_return_type(
+    return_type: types_proto.DataType,
+) -> tuple[list[tuple[str, Any]], DataType, StructType, list[str]]:
+    try:
+        if return_type.HasField("unparsed"):
+            parsed_return = parse_ddl_string(return_type.unparsed.data_type_string)
+        else:
+            parsed_return = return_type
+    except ValueError as e:
+        raise PythonException(
+            f"[UDTF_ARROW_TYPE_CAST_ERROR] Error parsing UDTF return type DDL: {e}"
+        )
+    original_output_schema = proto_to_snowpark_type(parsed_return)
+    output_schema = proto_to_snowpark_type(parsed_return)
+    # Snowflake UDTF does not support MapType, so we convert it to VariantType.
+    output_schema = convert_maptype_to_variant(output_schema)
+    if not isinstance(output_schema, StructType):
+        raise PySparkTypeError(
+            f"Invalid Python user-defined table function return type. Expect a struct type, but got {parsed_return}"
+        )
+
+    expected_types = None
+    if is_arrow_enabled_in_udtf() or is_spark_compatible_udtf_mode_enabled():
+        expected_types = build_expected_types_from_parsed(parsed_return)
+
+    spark_column_names = [f.name for f in parsed_return.struct.fields]
+    return expected_types, original_output_schema, output_schema, spark_column_names
+
+
+def register_udtf(
+    udtf_proto: relation_proto.CommonInlineUserDefinedTableFunction,
+) -> SnowparkUDTF:
+    udtf_check(udtf_proto)
+    session = get_or_create_snowpark_session()
+    python_udft = udtf_proto.python_udtf
+    (
+        expected_types,
+        original_output_schema,
+        output_schema,
+        spark_column_names,
+    ) = process_return_type(python_udft.return_type)
+    function_name = udtf_proto.function_name
+
+    kwargs = {
+        "session": session,
+        "udtf_proto": udtf_proto,
+        "expected_types": expected_types,
+        "output_schema": output_schema,
+        "packages": global_config.get("snowpark.connect.udf.packages", ""),
+        "imports": get_python_udxf_import_files(session),
+        "called_from": "register_udtf",
+        "is_arrow_enabled": is_arrow_enabled_in_udtf(),
+        "is_spark_compatible_udtf_mode_enabled": is_spark_compatible_udtf_mode_enabled(),
+    }
+
+    if require_creating_udtf_in_sproc(udtf_proto):
+        snowpark_udtf = create_udtf_in_sproc(**kwargs)
+    else:
+        udtf = create_udtf(**kwargs)
+        snowpark_udtf = SnowparkUDTF(
+            name=udtf.name, input_types=udtf._input_types, output_schema=output_schema
+        )
+
+    session._udtfs[function_name.lower()] = (snowpark_udtf, spark_column_names)
+    return snowpark_udtf
+
+
+def is_spark_compatible_udtf_mode_enabled() -> bool:
+    return get_boolean_session_config_param("snowpark.connect.udtf.compatibility_mode")
+
+
+def is_arrow_enabled_in_udtf() -> bool:  # REINSTATED
+    """Check if Arrow is enabled for UDTFs"""
+    return get_boolean_session_config_param(
+        "spark.sql.execution.pythonUDTF.arrow.enabled"
+    )
+
+
+def map_common_inline_user_defined_table_function(
+    rel: relation_proto.CommonInlineUserDefinedTableFunction,
+) -> snowpark.DataFrame:
+    udtf_check(rel)
+    session = get_or_create_snowpark_session()
+    python_udft = rel.python_udtf
+    (
+        expected_types,
+        original_output_schema,
+        output_schema,
+        spark_column_names,
+    ) = process_return_type(python_udft.return_type)
+
+    kwargs = {
+        "session": session,
+        "udtf_proto": rel,
+        "expected_types": expected_types,
+        "output_schema": output_schema,
+        "packages": global_config.get("snowpark.connect.udf.packages", ""),
+        "imports": get_python_udxf_import_files(session),
+        "called_from": "map_common_inline_user_defined_table_function",
+        "is_arrow_enabled": is_arrow_enabled_in_udtf(),
+        "is_spark_compatible_udtf_mode_enabled": is_spark_compatible_udtf_mode_enabled(),
+    }
+
+    if require_creating_udtf_in_sproc(rel):
+        snowpark_udtf_or_error = create_udtf_in_sproc(**kwargs)
+        if isinstance(snowpark_udtf_or_error, str):
+            raise PythonException(snowpark_udtf_or_error)
+        snowpark_udtf = snowpark_udtf_or_error
+    else:
+        udtf_or_error = create_udtf(**kwargs)
+        if isinstance(udtf_or_error, str):
+            raise PythonException(udtf_or_error)
+        udtf = udtf_or_error
+        snowpark_udtf = SnowparkUDTF(
+            name=udtf.name, input_types=udtf._input_types, output_schema=output_schema
+        )
+
+    column_map = ColumnNameMap([], [])
+    snowpark_udtf_args = []
+
+    # Set UDTF context when processing arguments to enable struct markers
+    with push_udtf_context():
+        for arg_exp in rel.arguments:
+            (_, snowpark_udtf_arg_tc) = map_single_column_expression(
+                arg_exp, column_map, ExpressionTyper.dummy_typer(session)
+            )
+            snowpark_udtf_arg = snowpark_udtf_arg_tc.col
+            snowpark_udtf_args.append(snowpark_udtf_arg)
+
+    df = session.table_function(
+        snowpark_udtf.name, *[arg.cast(VariantType()) for arg in snowpark_udtf_args]
+    )
+
+    original_types = {}
+    for field in original_output_schema.fields:
+        original_types[field.name] = field.datatype
+
+    snowpark_column_types = []
+    # Replace JSON strings with Python dicts for map columns
+    for field in output_schema.fields:
+        if isinstance(field.datatype, VariantType):
+            col_name = field.name
+            if col_name in original_types and isinstance(
+                original_types[col_name], MapType
+            ):
+                original_map_type = original_types[col_name]
+                parsed_col = parse_json(col(col_name))
+                df = df.with_column(col_name, parsed_col.cast(original_map_type))
+                snowpark_column_types.append(original_map_type)
+            else:
+                df = df.with_column(col_name, parse_json(col(col_name)))
+                snowpark_column_types.append(field.datatype)
+        else:
+            snowpark_column_types.append(field.datatype)
+
+    snowpark_columns = [f.name for f in output_schema.fields]
+
+    return with_column_map(
+        df,
+        spark_column_names,
+        snowpark_column_names=snowpark_columns,
+        snowpark_column_types=snowpark_column_types,
+    )

snowflake/snowpark_connect/relation/read/__init__.py

@@ -0,0 +1,7 @@
+#
+# Copyright (c) 2012-2025 Snowflake Computing Inc. All rights reserved.
+#
+
+from .map_read import map_read
+
+__all__ = ["map_read"]