snowflake-snowpark-python 1.53.0__tar.gz → 1.54.0__tar.gz

{snowflake_snowpark_python-1.53.0 → snowflake_snowpark_python-1.54.0}/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Release History
 
+## 1.54.0 (2026-07-29)
+
+### Snowpark Python API updates
+
+#### New Features
+
+- Added `ai_count_tokens` function to `snowflake.snowpark.functions` to estimate token counts for AI function calls.
+- Added `ai_multi_embed` function to `snowflake.snowpark.functions` to generate multimodal embeddings from text, images, audio, or video files.
+- Added `ai_redact` function to `snowflake.snowpark.functions` to detect and redact personally identifiable information (PII) from text.
+- Added `DataFrame.ai.multi_embed` method to generate multimodal embeddings via the DataFrame API.
+- Added `DataFrame.ai.redact` method to detect and redact PII from text columns via the DataFrame API.
+- Added `DataFrame.ai.translate` method to translate text columns between languages via the DataFrame API.
+
+#### Improvements
+
+- Removed the `experimental` tag from all AI SQL functions in `DataFrameAIFunctions` (`complete`, `filter`, `agg`, `classify`, `similarity`, `sentiment`, `embed`, `summarize_agg`, `transcribe`, `parse_document`, `extract`, `count_tokens`, `split_text_markdown_header`, `split_text_recursive_character`) and `RelationalGroupedDataFrame.ai_agg`.
+- Updated `DataFrame.ai.count_tokens` to match the standalone `ai_count_tokens` function: `function_name` is now the required first parameter, and `model` is optional. Also added `options` and `return_error_details` parameters.
+
+#### Bug Fixes
+
+- Fixed `DataFrame.ai.count_tokens` to call the `AI_COUNT_TOKENS` SQL function instead of the deprecated `SNOWFLAKE.CORTEX.COUNT_TOKENS`. Token counts may differ slightly due to the updated tokenizer.
+- Reverted the change introduced in 1.53.0 to eliminate unnecessary `SELECT *` from joins, which was causing performance regressions. This has no functional impact.
+
+## 1.53.1 (2026-07-14)
+
+No user-facing changes in this release.
+
 ## 1.53.0 (2026-07-09)
 
 ### Snowpark Python API Updates
@@ -19,6 +46,10 @@
 - Fixed a bug where single quotes and backslashes in `comment` (`create_or_replace_view` / dynamic table / `save_as_table`), collation specs (`Column.collate`), VARIANT/OBJECT subfield keys (`Column[...]`), and `DataFrame`/`Session.flatten` paths were not correctly escaped when generating SQL, which could produce malformed statements. Backslash sequences (e.g. `\t`, `\n`) in these values are now applied literally rather than interpreted.
 - Fixed a bug where string values in the AI functions (`ai_extract`, `ai_classify`, `ai_similarity`, `ai_parse_document`, `ai_transcribe`, `ai_complete`) configuration and `response_format` were not correctly escaped when generating the SQL object literal, which could produce malformed statements when a value contained single quotes or backslashes (for example, an apostrophe in a natural-language question).
 
+#### Improvements
+
+- Reduced the size of generated query text for repeated join operations.
+
 #### Dependency Updates
 
 - Lifted `protobuf` restriction for Python 3.14 from `==5.29.3` to `>=5.29.3,<6.34`.
@@ -41,7 +72,6 @@
 #### Improvements
 
 - Improved CTE optimization to deduplicate identical subtrees in self-joins, which were previously emitted as repeated subqueries.
-- Reduced the size of generated query text for repeated join operations.
 
 #### Deprecations
 

{snowflake_snowpark_python-1.53.0/src/snowflake_snowpark_python.egg-info → snowflake_snowpark_python-1.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-snowpark-python
-Version: 1.53.0
+Version: 1.54.0
 Summary: Snowflake Snowpark for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc

{snowflake_snowpark_python-1.53.0 → snowflake_snowpark_python-1.54.0}/src/snowflake/snowpark/_internal/analyzer/analyzer_utils.py

@@ -990,33 +990,6 @@ def lateral_join_statement(
     )
 
 
-_SELECT_STAR_FROM_PREFIX = SELECT + STAR + NEW_LINE + FROM + LEFT_PARENTHESIS + NEW_LINE
-_SELECT_STAR_FROM_SUFFIX = NEW_LINE + RIGHT_PARENTHESIS
-
-
-def _unwrap_select_star_from(sql: str) -> Optional[str]:
-    """If sql is a join-produced `SELECT * FROM (\n<join_source>\n)` (the
-    output of project_statement([], join_source)), return <join_source>.
-    Only unwraps when the inner content starts with '(' (possibly preceded
-    by UUID trace comments) which indicates a parenthesized join operand
-    rather than a wrapped SELECT statement."""
-    if sql.startswith(_SELECT_STAR_FROM_PREFIX) and sql.endswith(
-        _SELECT_STAR_FROM_SUFFIX
-    ):
-        inner = sql[len(_SELECT_STAR_FROM_PREFIX) : -len(_SELECT_STAR_FROM_SUFFIX)]
-        # In trace-SQL mode, UUID comments (\n-- <uuid>\n) may precede the
-        # opening parenthesis. Strip them before checking.
-        check = inner.lstrip("\n")
-        if check.startswith("--"):
-            # Skip the comment line and any trailing newline
-            newline_pos = check.find("\n")
-            if newline_pos != -1:
-                check = check[newline_pos + 1 :]
-        if check.startswith(LEFT_PARENTHESIS) or inner.startswith(LEFT_PARENTHESIS):
-            return inner
-    return None
-
-
 def snowflake_supported_join_statement(
     left: str,
     right: str,
@@ -1027,30 +1000,17 @@ def snowflake_supported_join_statement(
     left_uuid: Optional[str] = None,
     right_uuid: Optional[str] = None,
     directed: bool = False,
-    left_is_join: bool = False,
 ) -> str:
     LEFT_UUID = format_uuid(left_uuid)
     RIGHT_UUID = format_uuid(right_uuid)
-
-    # If left is the output of a previous join, flatten into a multi-way join
-    # by unwrapping the SELECT * FROM (...) envelope and appending the new
-    # right operand directly to the existing join source. This avoids nested
-    # SELECT * layers that inflate query text without changing semantics.
-    #
-    # Though it is technically less efficient than constructing the join sub-queries
-    # without the SELECT in the first place, the structure of our SQL processing code
-    # needs top-level projections to be wrapped by a select to be well-formed, so we
-    # must strip it here instead.
-    #
-    # We only unwrap the left side because it is simpler to deal with than unwrapping
-    # both left and right, and left-deep chains are more common, as they're produced
-    # by calls like df1.join(df2).join(df3) etc.
-    unwrapped_left = _unwrap_select_star_from(left) if left_is_join else None
+    left_alias = (
+        "SNOWPARK_LEFT"
+        if use_constant_subquery_alias
+        else random_name_for_temp_object(TempObjectType.TABLE)
+    )
     right_alias = (
         "SNOWPARK_RIGHT"
-        if use_constant_subquery_alias and unwrapped_left is None
-        # Multi-way join: right alias must be unique to avoid collisions
-        # with aliases already present in the flattened join source.
+        if use_constant_subquery_alias
         else random_name_for_temp_object(TempObjectType.TABLE)
     )
 
@@ -1086,31 +1046,18 @@ def snowflake_supported_join_statement(
 
     maybe_directed_sql = DIRECTED_JOIN if directed else JOIN
 
-    if unwrapped_left is not None:
-        # No need for additional parentheses around the left expression here, since it
-        # should already be parenthesized
-        left_expr = LEFT_UUID + unwrapped_left + NEW_LINE + LEFT_UUID
-    else:
-        left_alias = (
-            "SNOWPARK_LEFT"
-            if use_constant_subquery_alias
-            else random_name_for_temp_object(TempObjectType.TABLE)
-        )
-        left_expr = (
-            LEFT_PARENTHESIS
-            + NEW_LINE
-            + LEFT_UUID
-            + left
-            + NEW_LINE
-            + LEFT_UUID
-            + RIGHT_PARENTHESIS
-            + AS
-            + left_alias
-            + SPACE
-            + NEW_LINE
-        )
     source = (
-        left_expr
+        LEFT_PARENTHESIS
+        + NEW_LINE
+        + LEFT_UUID
+        + left
+        + NEW_LINE
+        + LEFT_UUID
+        + RIGHT_PARENTHESIS
+        + AS
+        + left_alias
+        + SPACE
+        + NEW_LINE
         + join_sql
         + maybe_directed_sql
         + NEW_LINE
@@ -1142,7 +1089,6 @@ def join_statement(
     left_uuid: Optional[str] = None,
     right_uuid: Optional[str] = None,
     directed: bool = False,
-    left_is_join: bool = False,
 ) -> str:
     if isinstance(join_type, (LeftSemi, LeftAnti)):
         return left_semi_or_anti_join_statement(
@@ -1170,7 +1116,6 @@ def join_statement(
         left_uuid=left_uuid,
         right_uuid=right_uuid,
         directed=directed,
-        left_is_join=left_is_join,
     )
 
 

{snowflake_snowpark_python-1.53.0 → snowflake_snowpark_python-1.54.0}/src/snowflake/snowpark/_internal/analyzer/expression.py

@@ -295,13 +295,22 @@ class Star(Expression):
 
 class UnresolvedAttribute(Expression, NamedExpression):
     def __init__(
-        self, name: str, is_sql_text: bool = False, df_alias: Optional[str] = None
+        self,
+        name: str,
+        is_sql_text: bool = False,
+        df_alias: Optional[str] = None,
+        is_constant: bool = False,
     ) -> None:
         super().__init__()
         self.df_alias = df_alias
         self.name = name
         self.is_sql_text = is_sql_text
-        if "$" in name:
+        self.is_constant = is_constant
+        if is_constant:
+            # Constant SQL text (e.g. object/array literals) does not reference
+            # any columns from the input relation.
+            self._dependent_column_names = COLUMN_DEPENDENCY_EMPTY
+        elif "$" in name:
             # $n refers to a column by index. We don't consider column index yet.
             # even though "$" isn't necessarily used to refer to a column by index. We're conservative here.
             self._dependent_column_names = COLUMN_DEPENDENCY_DOLLAR

{snowflake_snowpark_python-1.53.0 → snowflake_snowpark_python-1.54.0}/src/snowflake/snowpark/_internal/analyzer/select_statement.py

@@ -445,19 +445,6 @@ class Selectable(LogicalPlan, ABC):
                 # Add the last df ast id to the snowflake plan as the most recent
                 # dataframe operation to create this plan.
                 self._snowflake_plan.df_ast_ids = self.df_ast_ids
-            # Propagate join output flag through passthrough SelectStatements
-            # so chained joins can flatten into multi-way joins.
-            # Only SelectStatement has has_clause/has_projection; other
-            # Selectable subclasses (SelectSQL, SetStatement, etc.) skip this.
-            if (
-                isinstance(self, SelectStatement)
-                and not self.has_clause
-                and not self.has_projection
-                and isinstance(self.from_, SelectSnowflakePlan)
-            ):
-                self._snowflake_plan._is_join_output = (
-                    self.from_._snowflake_plan._is_join_output
-                )
         return self._snowflake_plan
 
     @property

{snowflake_snowpark_python-1.53.0 → snowflake_snowpark_python-1.54.0}/src/snowflake/snowpark/_internal/analyzer/snowflake_plan.py

@@ -458,7 +458,6 @@ class SnowflakePlan(LogicalPlan):
         self.session = session
         self.source_plan = source_plan
         self.is_ddl_on_temp_object = is_ddl_on_temp_object
-        self._is_join_output = False
         # We need to copy this list since we don't want to change it for the
         # previous SnowflakePlan objects
         self.api_calls = api_calls.copy() if api_calls else []
@@ -770,7 +769,6 @@ class SnowflakePlan(LogicalPlan):
                 referenced_ctes=self.referenced_ctes,
             )
         plan.df_ast_ids = self.df_ast_ids
-        plan._is_join_output = self._is_join_output
         return plan
 
     def __deepcopy__(self, memodict={}) -> "SnowflakePlan":  # noqa: B006
@@ -810,7 +808,6 @@ class SnowflakePlan(LogicalPlan):
         if copied_source_plan:
             copied_source_plan._is_valid_for_replacement = True
         copied_plan.df_ast_ids = self.df_ast_ids
-        copied_plan._is_join_output = self._is_join_output
 
         return copied_plan
 
@@ -1239,8 +1236,7 @@ class SnowflakePlanBuilder:
         use_constant_subquery_alias: bool,
         directed: bool = False,
     ):
-        left_is_join = left._is_join_output
-        result = self.build_binary(
+        return self.build_binary(
             lambda x, y: join_statement(
                 x,
                 y,
@@ -1257,14 +1253,11 @@ class SnowflakePlanBuilder:
                     else None
                 ),
                 directed=directed,
-                left_is_join=left_is_join,
             ),
             left,
             right,
             source_plan,
         )
-        result._is_join_output = True
-        return result
 
     def save_as_table(
         self,