snowflake-ml-python 1.43.0__tar.gz → 1.44.0__tar.gz

{snowflake_ml_python-1.43.0 → snowflake_ml_python-1.44.0}/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Release History
 
-## 1.43.0
+## 1.44.0
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.43.0 (2026-06-16)
 
 ### New Features
 

{snowflake_ml_python-1.43.0 → snowflake_ml_python-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.43.0
+Version: 1.44.0
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -241,7 +241,6 @@ Requires-Dist: fsspec[http]<2026,>=2024.6.1
 Requires-Dist: h2<5,>=4.3.0
 Requires-Dist: importlib_resources<7,>=6.1.1
 Requires-Dist: numpy<3,>=1.23
-Requires-Dist: orjson<4,>=3.11.0
 Requires-Dist: packaging<26,>=20.9
 Requires-Dist: pandas<3,>=2.1.4
 Requires-Dist: platformdirs<5
@@ -261,14 +260,14 @@ Requires-Dist: tqdm<5
 Requires-Dist: typing-extensions<5,>=4.1.0
 Requires-Dist: xgboost<4
 Provides-Extra: all
-Requires-Dist: altair<6,>=5; extra == "all"
+Requires-Dist: altair<7,>=5; extra == "all"
 Requires-Dist: catboost<2,>=1.2.0; extra == "all"
 Requires-Dist: keras<4,>=2.0.0; extra == "all"
 Requires-Dist: lightgbm<5,>=4.1.0; extra == "all"
-Requires-Dist: mlflow<3,>=2.16.0; extra == "all"
+Requires-Dist: mlflow<4,>=2.16.0; extra == "all"
 Requires-Dist: prophet<2,>=1.1.0; extra == "all"
 Requires-Dist: sentence-transformers<6,>=2.7.0; extra == "all"
-Requires-Dist: sentencepiece<0.2.0,>=0.1.95; extra == "all"
+Requires-Dist: sentencepiece<0.3,>=0.1.95; extra == "all"
 Requires-Dist: streamlit<2,>=1.30.0; extra == "all"
 Requires-Dist: tensorflow<3,>=2.17.0; extra == "all"
 Requires-Dist: tokenizers<1,>=0.15.1; extra == "all"
@@ -276,7 +275,7 @@ Requires-Dist: torch<3,>=2.0.1; extra == "all"
 Requires-Dist: torchdata<1,>=0.4; extra == "all"
 Requires-Dist: transformers!=4.51.3,<6,>=4.39.3; extra == "all"
 Provides-Extra: altair
-Requires-Dist: altair<6,>=5; extra == "altair"
+Requires-Dist: altair<7,>=5; extra == "altair"
 Provides-Extra: catboost
 Requires-Dist: catboost<2,>=1.2.0; extra == "catboost"
 Provides-Extra: keras
@@ -286,15 +285,15 @@ Requires-Dist: torch<3,>=2.0.1; extra == "keras"
 Provides-Extra: lightgbm
 Requires-Dist: lightgbm<5,>=4.1.0; extra == "lightgbm"
 Provides-Extra: llm
-Requires-Dist: mlflow<3,>=2.16.0; extra == "llm"
+Requires-Dist: mlflow<4,>=2.16.0; extra == "llm"
 Requires-Dist: sentence-transformers<6,>=2.7.0; extra == "llm"
-Requires-Dist: sentencepiece<0.2.0,>=0.1.95; extra == "llm"
+Requires-Dist: sentencepiece<0.3,>=0.1.95; extra == "llm"
 Requires-Dist: tokenizers<1,>=0.15.1; extra == "llm"
 Requires-Dist: torch<3,>=2.0.1; extra == "llm"
 Requires-Dist: torchdata<1,>=0.4; extra == "llm"
 Requires-Dist: transformers!=4.51.3,<6,>=4.39.3; extra == "llm"
 Provides-Extra: mlflow
-Requires-Dist: mlflow<3,>=2.16.0; extra == "mlflow"
+Requires-Dist: mlflow<4,>=2.16.0; extra == "mlflow"
 Provides-Extra: prophet
 Requires-Dist: prophet<2,>=1.1.0; extra == "prophet"
 Provides-Extra: streamlit
@@ -306,7 +305,7 @@ Requires-Dist: torch<3,>=2.0.1; extra == "torch"
 Requires-Dist: torchdata<1,>=0.4; extra == "torch"
 Provides-Extra: transformers
 Requires-Dist: sentence-transformers<6,>=2.7.0; extra == "transformers"
-Requires-Dist: sentencepiece<0.2.0,>=0.1.95; extra == "transformers"
+Requires-Dist: sentencepiece<0.3,>=0.1.95; extra == "transformers"
 Requires-Dist: tokenizers<1,>=0.15.1; extra == "transformers"
 Requires-Dist: torch<3,>=2.0.1; extra == "transformers"
 Requires-Dist: transformers!=4.51.3,<6,>=4.39.3; extra == "transformers"
@@ -417,7 +416,17 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.43.0
+## 1.44.0
+
+### New Features
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.43.0 (2026-06-16)
 
 ### New Features
 

{snowflake_ml_python-1.43.0 → snowflake_ml_python-1.44.0}/pyproject.toml

@@ -8,7 +8,7 @@ description = "The machine learning client library that is used for interacting
 classifiers = [ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Environment :: Other Environment", "Intended Audience :: Developers", "Intended Audience :: Education", "Intended Audience :: Information Technology", "Intended Audience :: System Administrators", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Topic :: Database", "Topic :: Software Development", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Application Frameworks", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Scientific/Engineering :: Information Analysis",]
 requires-python = ">=3.9, <3.14"
 dynamic = [ "version", "readme",]
-dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "orjson>=3.11.0,<4", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
+dependencies = [ "anyio>=3.5.0,<5", "cachetools>=3.1.1,<6", "cloudpickle>=2.0.0", "cryptography", "fsspec[http]>=2024.6.1,<2026", "h2>=4.3.0,<5", "importlib_resources>=6.1.1, <7", "numpy>=1.23,<3", "packaging>=20.9,<26", "pandas>=2.1.4,<3", "platformdirs<5", "pyarrow", "pydantic>=2.8.2, <3", "pyjwt>=2.0.0, <3", "pytimeparse>=1.1.8,<2", "pyyaml>=6.0,<7", "retrying>=1.3.3,<2", "scikit-learn<1.8", "scipy>=1.9,<2", "shap>=0.46.0,<1", "snowflake-connector-python[pandas]>=3.17.3,<5", "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0", "sqlparse>=0.4,<1", "tqdm<5", "typing-extensions>=4.1.0,<5", "xgboost<4",]
 [[project.authors]]
 name = "Snowflake, Inc"
 email = "support@snowflake.com"
@@ -24,18 +24,18 @@ Issues = "https://github.com/snowflakedb/snowflake-ml-python/issues"
 Changelog = "https://github.com/snowflakedb/snowflake-ml-python/blob/master/CHANGELOG.md"
 
 [project.optional-dependencies]
-all = [ "altair>=5,<6", "catboost>=1.2.0, <2", "keras>=2.0.0,<4", "lightgbm>=4.1.0, <5", "mlflow>=2.16.0, <3", "prophet>=1.1.0, <2", "sentence-transformers>=2.7.0,<6", "sentencepiece>=0.1.95,<0.2.0", "streamlit>=1.30.0,<2", "tensorflow>=2.17.0,<3", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "torchdata>=0.4,<1", "transformers>=4.39.3,!=4.51.3,<6",]
-altair = [ "altair>=5,<6",]
+all = [ "altair>=5,<7", "catboost>=1.2.0, <2", "keras>=2.0.0,<4", "lightgbm>=4.1.0, <5", "mlflow>=2.16.0, <4", "prophet>=1.1.0, <2", "sentence-transformers>=2.7.0,<6", "sentencepiece>=0.1.95,<0.3", "streamlit>=1.30.0,<2", "tensorflow>=2.17.0,<3", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "torchdata>=0.4,<1", "transformers>=4.39.3,!=4.51.3,<6",]
+altair = [ "altair>=5,<7",]
 catboost = [ "catboost>=1.2.0, <2",]
 keras = [ "keras>=2.0.0,<4", "tensorflow>=2.17.0,<3", "torch>=2.0.1,<3",]
 lightgbm = [ "lightgbm>=4.1.0, <5",]
-llm = [ "mlflow>=2.16.0, <3", "sentence-transformers>=2.7.0,<6", "sentencepiece>=0.1.95,<0.2.0", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "torchdata>=0.4,<1", "transformers>=4.39.3,!=4.51.3,<6",]
-mlflow = [ "mlflow>=2.16.0, <3",]
+llm = [ "mlflow>=2.16.0, <4", "sentence-transformers>=2.7.0,<6", "sentencepiece>=0.1.95,<0.3", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "torchdata>=0.4,<1", "transformers>=4.39.3,!=4.51.3,<6",]
+mlflow = [ "mlflow>=2.16.0, <4",]
 prophet = [ "prophet>=1.1.0, <2",]
 streamlit = [ "streamlit>=1.30.0,<2",]
 tensorflow = [ "tensorflow>=2.17.0,<3",]
 torch = [ "torch>=2.0.1,<3", "torchdata>=0.4,<1",]
-transformers = [ "sentence-transformers>=2.7.0,<6", "sentencepiece>=0.1.95,<0.2.0", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "transformers>=4.39.3,!=4.51.3,<6",]
+transformers = [ "sentence-transformers>=2.7.0,<6", "sentencepiece>=0.1.95,<0.3", "tokenizers>=0.15.1,<1", "torch>=2.0.1,<3", "transformers>=4.39.3,!=4.51.3,<6",]
 
 [tool.setuptools.package-data]
 "*" = [ "*",]

{snowflake_ml_python-1.43.0 → snowflake_ml_python-1.44.0}/snowflake/ml/_internal/exceptions/error_codes.py

@@ -63,6 +63,8 @@ METHOD_NOT_ALLOWED = "2102"
 NOT_IMPLEMENTED = "2103"
 # User needs to opt in to use a feature.
 OPT_IN_REQUIRED = "2104"
+# Caller's current role lacks the required ownership/privilege to perform the operation.
+INSUFFICIENT_PRIVILEGES = "2105"
 
 # Calling an API with unsupported keywords/values.
 INVALID_ARGUMENT = "2110"

{snowflake_ml_python-1.43.0 → snowflake_ml_python-1.44.0}/snowflake/ml/feature_store/feature_store.py

@@ -692,6 +692,18 @@ class FeatureStore:
         self._check_database_exists_or_throw()
         if creation_mode == CreationMode.FAIL_IF_NOT_EXIST:
             self._check_internal_objects_exist_or_throw()
+            # Best-effort: ensure the snapshot status table exists even in connect-only mode.
+            # The table is an internal implementation object (not user-visible) that must be
+            # present for scheduled snapshot tasks to succeed. Swallow any error — the caller
+            # may lack CREATE TABLE privilege, and the absence of the table does not prevent
+            # non-append_only feature store operations from working.
+            try:
+                self._ensure_snapshot_status_table_exists()
+            except Exception:
+                logger.debug(
+                    "feature store: could not ensure snapshot status table exists "
+                    "(insufficient privilege or schema not writable); skipping."
+                )
 
         else:
             try:
@@ -720,7 +732,7 @@ class FeatureStore:
     ) -> online_service_http_client.OnlineServiceHttpClient:
         """Return the FeatureStore-scoped HTTP client, creating it on first use."""
         if self._online_http_client is None:
-            self._online_http_client = online_service_http_client.OnlineServiceHttpClient()
+            self._online_http_client = online_service_http_client.OnlineServiceHttpClient(session=self._session)
         return self._online_http_client
 
     def close(self) -> None:
@@ -7777,6 +7789,14 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
         is_tiled = agg_metadata is not None
         # Restored from the FEATURE_SPECS row; None when no tiling metadata.
         aggregation_secondary_keys = agg_metadata.aggregation_secondary_keys if agg_metadata else None
+        # The persisted aggregation method must be known before _construct_feature_view runs
+        # validation: reconstruction routes through the batch path, where window/offset alignment
+        # is enforced for TILES but relaxed for CONTINUOUS. Setting it afterward would be too late.
+        feature_aggregation_method = (
+            FeatureAggregationMethod(agg_metadata.feature_aggregation_method)
+            if agg_metadata and agg_metadata.feature_aggregation_method
+            else (FeatureAggregationMethod.TILES if is_tiled else None)
+        )
 
         # Rehydrate the authored source-ref list onto the reconstructed
         # FV when a ``FV_SOURCE_REFS`` row was persisted at register time.
@@ -7843,6 +7863,7 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
                 feature_granularity=feature_granularity,
                 aggregation_specs=aggregation_specs,
                 aggregation_secondary_keys=aggregation_secondary_keys,
+                feature_aggregation_method=feature_aggregation_method,
                 is_streaming=fv_metadata.is_streaming,
                 append_only=fv_metadata.is_append_only,
                 backup_source=backup_source,
@@ -7856,11 +7877,6 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
                 fv_meta_config = self._metadata_manager.get_feature_view_metadata_config(name.identifier(), version)
                 fv._authoring_pkg_version = fv_meta_config.authoring_pkg_version if fv_meta_config else None
 
-            if agg_metadata and agg_metadata.feature_aggregation_method:
-                fv._feature_aggregation_method = FeatureAggregationMethod(agg_metadata.feature_aggregation_method)
-            elif is_tiled:
-                fv._feature_aggregation_method = FeatureAggregationMethod.TILES
-
             # For streaming FVs, attach the function source from metadata
             if fv_metadata.is_streaming:
                 streaming_meta = self._metadata_manager.get_streaming_metadata(name.identifier(), version)
@@ -7905,6 +7921,7 @@ FROM {batch_cte_names[0]}{''.join(merge_join_parts)}
                 feature_granularity=feature_granularity,
                 aggregation_specs=aggregation_specs,
                 aggregation_secondary_keys=aggregation_secondary_keys,
+                feature_aggregation_method=feature_aggregation_method,
                 storage_config=storage_config,
                 is_streaming=fv_metadata.is_streaming,
                 source_refs=restored_source_refs,

{snowflake_ml_python-1.43.0 → snowflake_ml_python-1.44.0}/snowflake/ml/feature_store/feature_view.py

@@ -971,6 +971,10 @@ class FeatureView(lineage_node.LineageNode):
         else:
             if feature_aggregation_method is not None:
                 raise ValueError("feature_aggregation_method is only supported for streaming feature views.")
+            # Reconstructed streaming FVs come through this batch path (via _is_streaming_marker)
+            # and carry their persisted aggregation method so that validation (e.g. window/offset
+            # alignment, which is relaxed for CONTINUOUS) matches the original registration.
+            self._feature_aggregation_method = _kwargs.pop("_feature_aggregation_method", None)
             self._timestamp_col = SqlIdentifier(timestamp_col) if timestamp_col is not None else None
             self._feature_granularity = feature_granularity
             self._aggregation_specs = _kwargs.pop("_aggregation_specs", None)
@@ -2073,10 +2077,17 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
 
         This ensures clean tile boundaries for aggregations.
         Lifetime windows are exempt from this validation as they aggregate all tiles.
+        CONTINUOUS aggregations are also exempt: feature_granularity is only an internal
+        tile size there, so any lookback window and offset are allowed.
 
         Raises:
             ValueError: If window or offset is not a multiple of feature_granularity.
         """
+        # Window/offset alignment only matters for TILES, where features are assembled
+        # from whole tiles. CONTINUOUS aggregation allows any lookback window/offset.
+        if self._feature_aggregation_method == FeatureAggregationMethod.CONTINUOUS:
+            return
+
         from snowflake.ml.feature_store.interval_utils import interval_to_seconds
 
         granularity_seconds = interval_to_seconds(self._feature_granularity)  # type: ignore[arg-type]
@@ -2345,6 +2356,11 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
         if json_dict.get("_aggregation_specs"):
             aggregation_specs = [AggregationSpec.from_dict(s) for s in json_dict["_aggregation_specs"]]
 
+        # Restore the aggregation method before reconstruction so validation (e.g. window/offset
+        # alignment, relaxed for CONTINUOUS) matches the original registration.
+        agg_method_raw = json_dict.get("_feature_aggregation_method")
+        feature_aggregation_method = FeatureAggregationMethod(agg_method_raw) if agg_method_raw else None
+
         fv = FeatureView._construct_feature_view(
             name=json_dict["_name"],
             entities=entities,
@@ -2369,6 +2385,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
             ),
             feature_granularity=json_dict.get("_feature_granularity"),
             aggregation_specs=aggregation_specs,
+            feature_aggregation_method=feature_aggregation_method,
             storage_config=(
                 StorageConfig.from_json(json_dict["_storage_config"]) if json_dict.get("_storage_config") else None
             ),
@@ -2470,6 +2487,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
         feature_granularity: Optional[str] = None,
         aggregation_specs: Optional[list[AggregationSpec]] = None,
         aggregation_secondary_keys: Optional[list[str]] = None,
+        feature_aggregation_method: Optional[FeatureAggregationMethod] = None,
         storage_config: Optional[StorageConfig] = None,
         is_streaming: bool = False,
         append_only: bool = False,
@@ -2510,6 +2528,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
                 feature_granularity=feature_granularity,
                 _aggregation_specs=aggregation_specs,
                 aggregation_secondary_keys=aggregation_secondary_keys,
+                _feature_aggregation_method=feature_aggregation_method,
                 storage_config=storage_config,
                 _is_streaming_marker=is_streaming,
                 _source_refs=source_refs,

{snowflake_ml_python-1.43.0 → snowflake_ml_python-1.44.0}/snowflake/ml/feature_store/online_service.py

@@ -697,20 +697,12 @@ def stream_ingest_records(
             original_exception=ValueError("records must be non-empty for stream ingest."),
         )
     resolved = online_service_http_client.ingest_api_url(ingest_base_url)
-    logger.debug(
-        "Ingest API: url=%r stream_source=%r num_records=%d",
-        resolved,
-        stream_source_name,
-        len(records),
-    )
     serializable = [{k: _json_serialize_value(v) for k, v in row.items()} for row in records]
     body: dict[str, Any] = {"records": {stream_source_name: serializable}}
-    # PAT is validated up-front (caller may not have a pooled client yet).
-    _ = online_service_http_client.auth_headers(session)
     owned_client: Optional[online_service_http_client.OnlineServiceHttpClient] = None
     client = http_client
     if client is None:
-        owned_client = online_service_http_client.OnlineServiceHttpClient()
+        owned_client = online_service_http_client.OnlineServiceHttpClient(session=session)
         client = owned_client
     try:
         status, raw = client.post_json(resolved, body, timeout_sec)
@@ -1376,14 +1368,11 @@ def read_postgres_online_features(
             )
 
     resolved_query_url = online_service_http_client.query_api_url(query_url)
-    logger.debug("Query API url=%r", resolved_query_url)
     url = resolved_query_url
-    # PAT is validated eagerly so callers fail fast even with an empty key batch.
-    _ = online_service_http_client.auth_headers()
     owned_client: Optional[online_service_http_client.OnlineServiceHttpClient] = None
     client = http_client
     if client is None:
-        owned_client = online_service_http_client.OnlineServiceHttpClient()
+        owned_client = online_service_http_client.OnlineServiceHttpClient(session=session)
         client = owned_client
 
     out: list[dict[str, Any]] = []

snowflake_ml_python-1.44.0/snowflake/ml/feature_store/online_service_http_client.py

@@ -0,0 +1,300 @@
+"""HTTP client for the Online Service REST APIs (Query + Ingest).
+
+HTTP/2 ``httpx`` client cached per ``(scheme://host, proxy)``. Auth resolution order:
+in-session PAT (``authenticator='PROGRAMMATIC_ACCESS_TOKEN'``) → ``SNOWFLAKE_PAT`` env var → raise.
+
+NOTE: We intentionally do NOT issue a session token from the Snowpark connection.
+A session token reuses the caller's existing GS session; when that session was created
+by the Python connector (``clientAppId=PythonSnowpark``), GS encodes the
+``system$snowservices_resolve_ingress`` result in ARROW format, which the SPCS ingress
+proxy cannot parse (it only reads ``rowset``, null for ARROW) → "empty data" → HTTP 500.
+A real PAT forces a fresh GS session (``clientAppId=SnowServices Ingress``) → JSON → works.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import urllib.parse
+import urllib.request
+from typing import Any, Callable, Optional
+
+from snowflake.ml._internal.exceptions import (
+    error_codes,
+    exceptions as snowml_exceptions,
+)
+from snowflake.snowpark import Session
+
+logger = logging.getLogger(__name__)
+
+_QUERY_API_REL_PATH = "api/v1/query"
+_INGEST_API_REL_PATH = "api/v1/ingest"
+
+
+def query_api_url(query_base_url: str) -> str:
+    """Append ``api/v1/query`` to the Online Service ``query`` endpoint URL from status JSON."""
+    base = query_base_url.strip().rstrip("/") + "/"
+    return urllib.parse.urljoin(base, _QUERY_API_REL_PATH)
+
+
+def ingest_api_url(ingest_base_url: str) -> str:
+    """Append ``api/v1/ingest`` to the Online Service ``ingest`` endpoint URL from status JSON."""
+    base = ingest_base_url.strip().rstrip("/") + "/"
+    return urllib.parse.urljoin(base, _INGEST_API_REL_PATH)
+
+
+def online_service_pat_from_env() -> str:
+    """Read PAT from ``SNOWFLAKE_PAT``; legacy lookup used by the env-var fallback path.
+
+    Returns:
+        PAT string from ``SNOWFLAKE_PAT``.
+
+    Raises:
+        SnowflakeMLException: When ``SNOWFLAKE_PAT`` is unset or empty.
+    """
+    pat = os.environ.get("SNOWFLAKE_PAT", "").strip()
+    if pat:
+        return pat
+    raise snowml_exceptions.SnowflakeMLException(
+        error_code=error_codes.INVALID_ARGUMENT,
+        original_exception=RuntimeError(
+            "Online Service requires a Snowflake Programmatic Access Token (PAT). "
+            "Set the SNOWFLAKE_PAT environment variable "
+            "(export in your shell or set os.environ in your notebook)."
+        ),
+    )
+
+
+def _pat_token_from_session(session: Session) -> Optional[str]:
+    """Pull a PAT from the session when ``authenticator='PROGRAMMATIC_ACCESS_TOKEN'``.
+
+    Args:
+        session: Snowpark session.
+
+    Returns:
+        PAT string, or ``None`` if the session isn't PAT-authed.
+    """
+    try:
+        from snowflake.connector.auth.pat import AuthByPAT
+
+        auth_cls = session.connection.auth_class
+        if not isinstance(auth_cls, AuthByPAT):
+            return None
+        pat = auth_cls.assertion_content
+        if isinstance(pat, str) and pat.strip():
+            return pat.strip()
+    except Exception:
+        logger.debug("PAT extraction from session failed", exc_info=True)
+    return None
+
+
+_NO_AUTH_MESSAGE = (
+    "Online Service requires a Programmatic Access Token (PAT). Either create the "
+    "Snowpark Session with authenticator='PROGRAMMATIC_ACCESS_TOKEN' (PAT in password), "
+    "or set the SNOWFLAKE_PAT environment variable. A session token cannot be used: it "
+    "reuses the caller's GS session and triggers an ARROW response the ingress proxy "
+    "cannot parse."
+)
+
+
+def auth_headers(session: Optional[Session] = None) -> dict[str, str]:
+    """Build HTTP headers via a one-shot auth resolution; per-request and not cached.
+
+    Prefer :class:`OnlineServiceHttpClient` for the hot path — it captures the session
+    once at construction time and reuses it. This standalone helper is for callers
+    that need a quick auth-validation pre-flight.
+
+    Resolution: in-session PAT (if ``authenticator='PROGRAMMATIC_ACCESS_TOKEN'``) \u2192
+    ``SNOWFLAKE_PAT`` env var. A session token is intentionally never used (see module docstring).
+
+    Args:
+        session: Snowpark session for the resolution chain; ``None`` falls through to env var.
+
+    Returns:
+        Dict with ``Authorization``, ``Content-Type``, and ``Accept`` headers.
+
+    Raises:
+        SnowflakeMLException: When no auth path resolves a token.
+    """
+    token: Optional[str] = None
+    if session is not None:
+        token = _pat_token_from_session(session)
+    if not token:
+        token = os.environ.get("SNOWFLAKE_PAT", "").strip() or None
+    if not token:
+        raise snowml_exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=RuntimeError(_NO_AUTH_MESSAGE),
+        )
+    return {
+        "Authorization": f'Snowflake Token="{token}"',
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+
+
+def _proxy_for_url(url: str) -> Optional[str]:
+    """Proxy URL for ``url`` per ``NO_PROXY`` and the env-derived proxy table; ``None`` for direct."""
+    parsed = urllib.parse.urlparse(url)
+    host = parsed.hostname or ""
+    if host and urllib.request.proxy_bypass(host):
+        return None
+    proxies = urllib.request.getproxies()
+    return proxies.get(parsed.scheme) or proxies.get("all")
+
+
+class OnlineServiceHttpClient:
+    """HTTP/2-enabled httpx client for the Online Service, cached per origin+proxy.
+
+    Caches one ``httpx.Client(http2=True)`` per ``(scheme://host, proxy)`` so concurrent reads
+    share a single multiplexed connection per origin. Falls back to HTTP/1.1 transparently if
+    the server's ALPN does not advertise h2. Honors ``HTTPS_PROXY`` / ``HTTP_PROXY`` /
+    ``NO_PROXY`` via :func:`_proxy_for_url`.
+
+    When ``session`` is provided and was created with
+    ``authenticator='PROGRAMMATIC_ACCESS_TOKEN'``, the in-session PAT is used. Otherwise
+    falls back to the ``SNOWFLAKE_PAT`` env var. A session token is intentionally never
+    used — it reuses the caller's GS session and triggers an ARROW response the ingress
+    proxy cannot parse (see module docstring).
+    """
+
+    def __init__(
+        self,
+        *,
+        session: Optional[Session] = None,
+        max_connections: int = 8,
+        _transport_factory: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        self._max_connections = max_connections
+        self._clients_by_key: dict[tuple[str, Optional[str]], Any] = {}
+        self._http2_logged_for_origin: set[str] = set()
+        self._transport_factory = _transport_factory
+        self._closed = False
+        self._session: Optional[Session] = session
+        self._session_pat: Optional[str] = _pat_token_from_session(session) if session is not None else None
+
+    def _resolve_token(self, url: str) -> str:
+        """Resolve the bearer token: in-session PAT → ``SNOWFLAKE_PAT`` env var.
+
+        A session token is intentionally never used — it reuses the caller's GS session
+        and triggers an ARROW response the ingress proxy cannot parse (see module docstring).
+
+        Args:
+            url: Online Service URL (unused; kept for signature symmetry).
+
+        Returns:
+            Token string for the ``Authorization`` header.
+
+        Raises:
+            SnowflakeMLException: when no auth path can produce a token.
+        """
+        del url
+        if self._session_pat:
+            logger.info("Online Service auth: resolved via session PAT (len=%d)", len(self._session_pat))
+            return self._session_pat
+        env_pat = os.environ.get("SNOWFLAKE_PAT", "").strip()
+        if env_pat:
+            logger.info("Online Service auth: resolved via SNOWFLAKE_PAT env var (len=%d)", len(env_pat))
+            return env_pat
+        raise snowml_exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=RuntimeError(_NO_AUTH_MESSAGE),
+        )
+
+    def _build_auth_headers(self, url: str) -> dict[str, str]:
+        return {
+            "Authorization": f'Snowflake Token="{self._resolve_token(url)}"',
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+    def _client_for_url(self, url: str) -> Any:
+        """Cached ``httpx.Client(http2=True)`` keyed by (scheme://host, proxy)."""
+        import httpx
+
+        parsed = urllib.parse.urlparse(url)
+        proxy = _proxy_for_url(url)
+        key = (f"{parsed.scheme}://{parsed.hostname or ''}", proxy)
+        client = self._clients_by_key.get(key)
+        if client is not None:
+            return client
+
+        limits = httpx.Limits(
+            max_keepalive_connections=self._max_connections,
+            max_connections=self._max_connections,
+        )
+        kwargs: dict[str, Any] = {
+            "http2": True,
+            "limits": limits,
+            "timeout": None,  # per-request timeout passed to .post()
+            "trust_env": False,  # proxy resolution handled by _proxy_for_url
+        }
+        if proxy:
+            kwargs["proxy"] = proxy
+        if self._transport_factory is not None:
+            kwargs["transport"] = self._transport_factory(proxy=proxy)
+        client = httpx.Client(**kwargs)
+        self._clients_by_key[key] = client
+        return client
+
+    def post_json(
+        self,
+        url: str,
+        body: dict[str, Any],
+        timeout: float,
+    ) -> tuple[int, bytes]:
+        """POST ``body`` as JSON and return ``(status_code, body_bytes)``; only network errors raise.
+
+        Args:
+            url: Online Service endpoint URL.
+            body: JSON-serializable payload.
+            timeout: Per-request timeout in seconds.
+
+        Returns:
+            ``(status_code, body_bytes)`` from the server response.
+
+        Raises:
+            RuntimeError: When the client has been closed.
+            SnowflakeMLException: On transport errors or unresolvable authentication.
+        """
+        if self._closed:
+            raise RuntimeError("OnlineServiceHttpClient is closed")
+
+        import httpx
+
+        payload = json.dumps(body).encode("utf-8")
+        headers = self._build_auth_headers(url)
+        client = self._client_for_url(url)
+
+        try:
+            resp = client.post(url, content=payload, headers=headers, timeout=httpx.Timeout(timeout))
+        except (httpx.HTTPError, OSError) as e:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INTERNAL_SNOWFLAKE_API_ERROR,
+                original_exception=RuntimeError(f"Online Service is unreachable: {e}"),
+            ) from e
+
+        parsed = urllib.parse.urlparse(url)
+        origin = f"{parsed.scheme}://{parsed.hostname or ''}"
+        if origin not in self._http2_logged_for_origin:
+            self._http2_logged_for_origin.add(origin)
+            logger.info(
+                "Online Service HTTP negotiated %s for origin %s",
+                getattr(resp, "http_version", "unknown"),
+                origin,
+            )
+
+        return int(resp.status_code), resp.content
+
+    def close(self) -> None:
+        """Close all underlying ``httpx.Client`` instances. Idempotent."""
+        if self._closed:
+            return
+        self._closed = True
+        for client in self._clients_by_key.values():
+            try:
+                client.close()
+            except Exception:  # noqa: BLE001 - best-effort close, never raise from cleanup
+                logger.debug("OnlineServiceHttpClient close suppressed", exc_info=True)
+        self._clients_by_key.clear()