snowflake-ml-python 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

snowflake/cortex/_classify_text.py

@@ -6,24 +6,23 @@ from typing_extensions import deprecated
 from snowflake import snowpark
 from snowflake.cortex._util import (
     CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
-    call_sql_function,
+    SnowflakeAuthenticationException,
     warn_cortex_deprecated,
 )
 from snowflake.ml._internal import telemetry
-from snowflake.snowpark import functions
+from snowflake.snowpark import context, functions
 
 _AI_CLASSIFY_FUNCTION_NAME = "AI_CLASSIFY"
-# Legacy CLASSIFY_TEXT always returned exactly one label. AI_CLASSIFY defaults to single-label mode, but
-# we set output_mode explicitly so the single-label contract can't drift and multi-label results can
-# never leak through.
-_AI_CLASSIFY_SINGLE_LABEL_CONFIG = {"output_mode": "single"}
+# AI_CLASSIFY requires its config argument to be a constant object literal. A Python dict is rendered by
+# Snowpark as PARSE_JSON('...')::OBJECT, which the server rejects ("... is not a constant"), so emit the
+# config as a SQL object constant via sql_expr -- this mirrors snowflake.snowpark.functions.ai_classify.
+# Legacy CLASSIFY_TEXT was always single-label, so set output_mode explicitly to keep that contract.
+_AI_CLASSIFY_SINGLE_LABEL_CONFIG_SQL = "{'output_mode': 'single'}"
 
 
 def _adapt_ai_classify_result(result: Any) -> str:
     """Map an AI_CLASSIFY result to the legacy CLASSIFY_TEXT {"label": ...} JSON string."""
-    # Legacy classify_text returned the raw CLASSIFY_TEXT OBJECT, which the immediate (non-Column) path
-    # collects as a JSON string such as '{"label": "positive"}'. We reproduce that exact shape so
-    # existing callers that json.loads the result and read ["label"] keep working.
+    # Used for non-Column results (e.g. a dict/JSON string): reproduce the legacy single-label object shape.
     parsed: Any = result
     if isinstance(result, str):
         try:
@@ -40,6 +39,20 @@ def _adapt_ai_classify_result(result: Any) -> str:
     return json.dumps({"label": label})
 
 
+def _ai_classify_label_column(
+    str_input: str | snowpark.Column,
+    categories: list[str] | snowpark.Column,
+) -> snowpark.Column:
+    """Call AI_CLASSIFY in single-label mode and re-wrap to the legacy CLASSIFY_TEXT {"label": ...} OBJECT."""
+    result = functions.builtin(_AI_CLASSIFY_FUNCTION_NAME)(
+        str_input, categories, functions.sql_expr(_AI_CLASSIFY_SINGLE_LABEL_CONFIG_SQL)
+    )
+    # AI_CLASSIFY returns {"labels": [...]}; collapse to the legacy single {"label": ...}. Subscript access
+    # (not functions.get with a bare string, which Snowpark treats as a column identifier) uses literal keys.
+    label = functions.coalesce(result["labels"][0], result["label"])
+    return functions.object_construct(functions.lit("label"), label)
+
+
 @telemetry.send_api_usage_telemetry(
     project=CORTEX_FUNCTIONS_TELEMETRY_PROJECT,
 )
@@ -56,32 +69,25 @@ def classify_text(
         session: The snowpark session to use. Will be inferred by context if not specified.
 
     Returns:
-        A column of classification responses.
+        A column of classification responses (legacy CLASSIFY_TEXT {"label": ...} shape).
+
+    Raises:
+        SnowflakeAuthenticationException: if no session is provided and none is active.
     """
     warn_cortex_deprecated("classify_text", "ai_classify")
-    result = _classify_text_impl(
-        _AI_CLASSIFY_FUNCTION_NAME, str_input, categories, _AI_CLASSIFY_SINGLE_LABEL_CONFIG, session=session
-    )
-    if isinstance(result, snowpark.Column):
-        # AI_CLASSIFY returns {"labels": [...]}; re-wrap as the legacy CLASSIFY_TEXT {"label": ...} OBJECT
-        # so downstream SQL that reads col["label"] is unchanged. Subscript access (not functions.get with
-        # a bare string, which Snowpark treats as a column identifier) extracts the field by literal key.
-        label = functions.coalesce(result["labels"][0], result["label"])
-        return functions.object_construct(functions.lit("label"), label)
-    return _adapt_ai_classify_result(result)
-
+    column = _ai_classify_label_column(str_input, categories)
+    if isinstance(str_input, snowpark.Column) or isinstance(categories, snowpark.Column):
+        return column
 
-def _classify_text_impl(
-    function: str,
-    str_input: str | snowpark.Column,
-    categories: list[str] | snowpark.Column,
-    config: dict[str, Any] | None = None,
-    session: snowpark.Session | None = None,
-) -> str | snowpark.Column:
-    args: list[Any] = [str_input, categories]
-    if config is not None:
-        args.append(config)
-    return cast(str | snowpark.Column, call_sql_function(function, session, *args))
+    # Immediate (literal) path: evaluate and return the collected OBJECT as a JSON string, exactly as the
+    # legacy CLASSIFY_TEXT immediate path did.
+    session = session or context.get_active_session()
+    if session is None:
+        raise SnowflakeAuthenticationException(
+            """Session required. Provide the session through a session=... argument or ensure an active session is
+            available in your environment."""
+        )
+    return cast(str, session.create_dataframe([snowpark.Row()]).select(column).collect()[0][0])
 
 
 ClassifyText = deprecated(

snowflake/ml/_internal/platform_capabilities.py

@@ -93,7 +93,7 @@ class PlatformCapabilities:
         return self._get_bool_feature(ENABLE_MODEL_METHOD_SIGNATURE_PARAMETERS, False)
 
     def is_lora_adapters_enabled(self) -> bool:
-        return False
+        return self._get_bool_feature(ENABLE_LORA_ADAPTERS, False)
 
     def is_single_output_native_type_enabled(self) -> bool:
         """Whether a single, non-OBJECT model FUNCTION output is registered with its native SQL type.

snowflake/ml/dataset/dataset.py

@@ -341,7 +341,7 @@ class Dataset(lineage_node.LineageNode):
         metadata = dataset_metadata.DatasetMetadata(
             source_query=source_query,
             owner=self._session.sql("SELECT CURRENT_USER()").collect(statement_params=_TELEMETRY_STATEMENT_PARAMS)[0][
-                "CURRENT_USER()"
+                0
             ],
             exclude_cols=exclude_cols,
             label_cols=label_cols,

snowflake/ml/feature_store/decl/__init__.py

@@ -0,0 +1,168 @@
+"""Public API for the declarative feature store library.
+
+Import the key functions and types from this package:
+
+    from snowflake.ml.feature_store.decl import (
+        load_specs,
+        validate_specs,
+        generate_plan,
+        fetch_applied_state,
+        SpecBatch,
+        AppliedState,
+        Plan,
+        PlanOptions,
+        ValidationResult,
+        PlanOp,
+        AppliedObject,
+        SpecLoadError,
+        ValidationError,
+        DependencyError,
+        StateDriftError,
+        FSBaseType,
+        FeatureViewKind,
+        SourceType,
+        FeatureAggregationMethod,
+        OpKind,
+        TYPE_ALIASES,
+        normalize_type,
+        FSColumn,
+        SpecBase,
+        Entity,
+        StreamingSource,
+        BatchSource,
+        SourceRef,
+        UDF,
+        Feature,
+        FeatureView,
+        FeatureViewRef,
+        FeatureGroup,
+    )
+"""
+
+try:
+    from snowflake.ml.feature_store.decl.api import (
+        discover_project,
+        fetch_applied_state,
+        generate_plan,
+        load_manifest,
+        load_project,
+        load_specs,
+        resolve_datasource_columns,
+        resolve_target,
+        validate_specs,
+    )
+except ModuleNotFoundError:  # lower-layer BUILD targets omit api.py
+    pass
+from snowflake.ml.feature_store.decl.enums import (
+    TYPE_ALIASES,
+    FeatureAggregationMethod,
+    FeatureViewKind,
+    FSBaseType,
+    OpKind,
+    SourceType,
+    normalize_type,
+)
+from snowflake.ml.feature_store.decl.errors import (
+    DependencyError,
+    SpecLoadError,
+    StateDriftError,
+    ValidationError,
+)
+from snowflake.ml.feature_store.decl.manifest import (
+    FSManifest,
+    FSTarget,
+    FSTemplating,
+    InvalidManifestError,
+    ManifestConfigurationError,
+    ManifestNotFoundError,
+    TargetContext,
+)
+from snowflake.ml.feature_store.decl.project_paths import FSProjectPaths
+from snowflake.ml.feature_store.decl.spec_models import (
+    UDF,
+    Backfill,
+    BatchFeatureView,
+    BatchSource,
+    Entity,
+    Feature,
+    FeatureGroup,
+    FeatureView,
+    FeatureViewRef,
+    FSColumn,
+    RealtimeFeatureView,
+    SourceRef,
+    SpecBase,
+    StorageConfig,
+    StreamingFeatureView,
+    StreamingSource,
+)
+from snowflake.ml.feature_store.decl.types import (
+    AppliedObject,
+    AppliedState,
+    Plan,
+    PlanOp,
+    PlanOptions,
+    SpecBatch,
+    ValidationResult,
+)
+
+__all__ = [
+    # api.py
+    "load_specs",
+    "validate_specs",
+    "generate_plan",
+    "fetch_applied_state",
+    "resolve_datasource_columns",
+    "load_manifest",
+    "discover_project",
+    "resolve_target",
+    "load_project",
+    # enums.py
+    "FSBaseType",
+    "FeatureViewKind",
+    "SourceType",
+    "FeatureAggregationMethod",
+    "OpKind",
+    "TYPE_ALIASES",
+    "normalize_type",
+    # errors.py
+    "SpecLoadError",
+    "ValidationError",
+    "DependencyError",
+    "StateDriftError",
+    # manifest.py
+    "FSManifest",
+    "FSTarget",
+    "FSTemplating",
+    "TargetContext",
+    "ManifestNotFoundError",
+    "InvalidManifestError",
+    "ManifestConfigurationError",
+    # project_paths.py
+    "FSProjectPaths",
+    # spec_models.py
+    "FSColumn",
+    "SpecBase",
+    "Entity",
+    "StreamingSource",
+    "BatchSource",
+    "SourceRef",
+    "UDF",
+    "Feature",
+    "FeatureView",
+    "StreamingFeatureView",
+    "BatchFeatureView",
+    "RealtimeFeatureView",
+    "FeatureViewRef",
+    "FeatureGroup",
+    "Backfill",
+    "StorageConfig",
+    # types.py
+    "AppliedObject",
+    "AppliedState",
+    "PlanOp",
+    "Plan",
+    "ValidationResult",
+    "PlanOptions",
+    "SpecBatch",
+]