snowflake-connector-python 3.11.0__tar.gz → 3.12.0__tar.gz

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/DESCRIPTION.md

@@ -8,6 +8,15 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.12.0(July 24,2024)
+  - Set default connection timeout of 10 seconds and socket read timeout of 10 minutes for HTTP calls in file transfer.
+  - Optimized `to_pandas()` performance by fully parallel downloading logic.
+  - Fixed a bug that specifying client_session_keep_alive_heartbeat_frequency in snowflake-sqlalchemy could crash the connector.
+  - Fixed incorrect type hint of connection parameter `private_key`.
+  - Added support for connectivity to multiple domains.
+  - Bumped keyring dependency from >=23.1.0,<25.0.0 to >=23.1.0,<26.0.0.
+  - Disabled OOB Telemetry.
+
 - v3.11.0(June 17,2024)
   - Added support for `token_file_path` connection parameter to read an OAuth token from a file when connecting to Snowflake.
   - Added support for `debug_arrow_chunk` connection parameter to allow debugging raw arrow data in case of arrow data parsing failure.

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-connector-python
-Version: 3.11.0
+Version: 3.12.0
 Summary: Snowflake Connector for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -73,7 +73,7 @@ Provides-Extra: pandas
 Requires-Dist: pandas<3.0.0,>=1.0.0; extra == "pandas"
 Requires-Dist: pyarrow; extra == "pandas"
 Provides-Extra: secure-local-storage
-Requires-Dist: keyring<25.0.0,>=23.1.0; extra == "secure-local-storage"
+Requires-Dist: keyring<26.0.0,>=23.1.0; extra == "secure-local-storage"
 
 This package includes the Snowflake Connector for Python, which conforms to the Python DB API 2.0 specification:
 https://www.python.org/dev/peps/pep-0249/
@@ -85,6 +85,15 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.12.0(July 24,2024)
+  - Set default connection timeout of 10 seconds and socket read timeout of 10 minutes for HTTP calls in file transfer.
+  - Optimized `to_pandas()` performance by fully parallel downloading logic.
+  - Fixed a bug that specifying client_session_keep_alive_heartbeat_frequency in snowflake-sqlalchemy could crash the connector.
+  - Fixed incorrect type hint of connection parameter `private_key`.
+  - Added support for connectivity to multiple domains.
+  - Bumped keyring dependency from >=23.1.0,<25.0.0 to >=23.1.0,<26.0.0.
+  - Disabled OOB Telemetry.
+
 - v3.11.0(June 17,2024)
   - Added support for `token_file_path` connection parameter to read an OAuth token from a file when connecting to Snowflake.
   - Added support for `debug_arrow_chunk` connection parameter to allow debugging raw arrow data in case of arrow data parsing failure.

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/setup.cfg

@@ -96,7 +96,7 @@ pandas =
 	pandas>=1.0.0,<3.0.0
 	pyarrow
 secure-local-storage = 
-	keyring>=23.1.0,<25.0.0
+	keyring>=23.1.0,<26.0.0
 
 [egg_info]
 tag_build = 

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/connection.py

@@ -52,6 +52,7 @@ from .compat import IS_LINUX, IS_WINDOWS, quote, urlencode
 from .config_manager import CONFIG_MANAGER, _get_default_connection_params
 from .connection_diagnostic import ConnectionDiagnostic
 from .constants import (
+    _DOMAIN_NAME_MAP,
     ENV_VAR_PARTNER,
     PARAMETER_AUTOCOMMIT,
     PARAMETER_CLIENT_PREFETCH_THREADS,
@@ -107,6 +108,7 @@ from .sqlstate import SQLSTATE_CONNECTION_NOT_EXISTS, SQLSTATE_FEATURE_NOT_SUPPO
 from .telemetry import TelemetryClient, TelemetryData, TelemetryField
 from .telemetry_oob import TelemetryService
 from .time_util import HeartBeatTimer, get_time_millis
+from .url_util import extract_top_level_domain_from_hostname
 from .util_text import construct_hostname, parse_account, split_statements
 
 DEFAULT_CLIENT_PREFETCH_THREADS = 4
@@ -181,7 +183,7 @@ DEFAULT_CONFIGURATION: dict[str, tuple[Any, type | tuple[type, ...]]] = {
     "backoff_policy": (DEFAULT_BACKOFF_POLICY, Callable),
     "passcode_in_password": (False, bool),  # Snowflake MFA
     "passcode": (None, (type(None), str)),  # Snowflake MFA
-    "private_key": (None, (type(None), str, RSAPrivateKey)),
+    "private_key": (None, (type(None), bytes, RSAPrivateKey)),
     "private_key_file": (None, (type(None), str)),
     "private_key_file_pwd": (None, (type(None), str, bytes)),
     "token": (None, (type(None), str)),  # OAuth or JWT Token
@@ -190,6 +192,10 @@ DEFAULT_CONFIGURATION: dict[str, tuple[Any, type | tuple[type, ...]]] = {
     "password_callback": (None, (type(None), Callable)),
     "auth_class": (None, (type(None), AuthByPlugin)),
     "application": (CLIENT_NAME, (type(None), str)),
+    # internal_application_name/version is used to tell the server the type of client connecting to
+    # Snowflake. There are some functionalities (e.g., MFA, Arrow result format) that
+    # Snowflake server doesn't support for new client types, which requires developers to
+    # add the new client type to the server to support these features.
     "internal_application_name": (CLIENT_NAME, (type(None), str)),
     "internal_application_version": (CLIENT_VERSION, (type(None), str)),
     "insecure_mode": (False, bool),  # Error security fix requirement
@@ -931,7 +937,7 @@ class SnowflakeConnection:
                 os.environ["SF_OCSP_RESPONSE_CACHE_SERVER_URL"],
             )
 
-        if self.host.endswith(".privatelink.snowflakecomputing.com"):
+        if ".privatelink.snowflakecomputing." in self.host:
             SnowflakeConnection.setup_ocsp_privatelink(self.application, self.host)
         else:
             if "SF_OCSP_RESPONSE_CACHE_SERVER_URL" in os.environ:
@@ -1178,6 +1184,10 @@ class SnowflakeConnection:
             if "protocol" not in kwargs:
                 self._protocol = "https"
 
+        logger.info(
+            f"Connecting to {_DOMAIN_NAME_MAP.get(extract_top_level_domain_from_hostname(self._host), 'GLOBAL')} Snowflake domain"
+        )
+
         # If using a custom auth class, we should set the authenticator
         # type to be the same as the custom auth class
         if self._auth_class:
@@ -1287,6 +1297,7 @@ class SnowflakeConnection:
         _update_current_object: bool = True,
         _no_retry: bool = False,
         timeout: int | None = None,
+        dataframe_ast: str | None = None,
     ) -> dict[str, Any]:
         """Executes a query with a sequence counter."""
         logger.debug("_cmd_query")
@@ -1296,6 +1307,8 @@ class SnowflakeConnection:
             "sequenceId": sequence_counter,
             "querySubmissionTime": get_time_millis(),
         }
+        if dataframe_ast is not None:
+            data["dataframeAst"] = dataframe_ast
         if statement_params is not None:
             data["parameters"] = statement_params
         if is_internal:
@@ -1670,6 +1683,12 @@ class SnowflakeConnection:
         """Validate and return heartbeat frequency in seconds."""
         real_max = int(self.rest.master_validity_in_seconds / 4)
         real_min = int(real_max / 4)
+
+        # ensure the type is integer
+        self._client_session_keep_alive_heartbeat_frequency = int(
+            self.client_session_keep_alive_heartbeat_frequency
+        )
+
         if self.client_session_keep_alive_heartbeat_frequency is None:
             # This is an unlikely scenario but covering it just in case.
             self._client_session_keep_alive_heartbeat_frequency = real_min
@@ -1678,10 +1697,6 @@ class SnowflakeConnection:
         elif self.client_session_keep_alive_heartbeat_frequency < real_min:
             self._client_session_keep_alive_heartbeat_frequency = real_min
 
-        # ensure the type is integer
-        self._client_session_keep_alive_heartbeat_frequency = int(
-            self.client_session_keep_alive_heartbeat_frequency
-        )
         return self.client_session_keep_alive_heartbeat_frequency
 
     def _validate_client_prefetch_threads(self) -> int:

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/connection_diagnostic.py

@@ -23,6 +23,7 @@ import OpenSSL
 
 from .compat import IS_WINDOWS, urlparse
 from .cursor import SnowflakeCursor
+from .url_util import extract_top_level_domain_from_hostname
 from .vendored import urllib3
 
 logger = getLogger(__name__)
@@ -89,15 +90,21 @@ class ConnectionDiagnostic:
         self.__append_message(
             host_type, f"Host based on specified account: {self.host}"
         )
-        if ".com.snowflakecomputing.com" in self.host:
-            self.host = host.split(".com.snow", 1)[0] + ".com"
+
+        top_level_domain = extract_top_level_domain_from_hostname(host)
+        if (
+            f".{top_level_domain}.snowflakecomputing.{top_level_domain}" in self.host
+        ):  # repeated domain name pattern
+            self.host = (
+                host.split(f".{top_level_domain}.snow", 1)[0] + f".{top_level_domain}"
+            )
             logger.warning(
-                f"Account should not have snowflakecomputing.com in it. You provided {host}.  "
+                f"Account should not have snowflakecomputing.{top_level_domain} in it. You provided {host}.  "
                 f"Continuing with fixed host."
             )
             self.__append_message(
                 host_type,
-                f"We removed extra .snowflakecomputing.com and will continue with host: "
+                f"We removed extra .snowflakecomputing.{top_level_domain} and will continue with host: "
                 f"{self.host}",
             )
         else:
@@ -183,7 +190,7 @@ class ConnectionDiagnostic:
             self.ocsp_urls.append(f"ocsp.{self.host}")
             self.allowlist_sql = "select system$allowlist_privatelink();"
         else:
-            self.ocsp_urls.append("ocsp.snowflakecomputing.com")
+            self.ocsp_urls.append(f"ocsp.snowflakecomputing.{top_level_domain}")
 
         self.allowlist_retrieval_success: bool = False
         self.cursor: SnowflakeCursor | None = None

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/constants.py

@@ -36,6 +36,11 @@ DBAPI_TYPE_BINARY = 1
 DBAPI_TYPE_NUMBER = 2
 DBAPI_TYPE_TIMESTAMP = 3
 
+_DEFAULT_HOSTNAME_TLD = "com"
+_CHINA_HOSTNAME_TLD = "cn"
+_TOP_LEVEL_DOMAIN_REGEX = r"\.[a-zA-Z]{1,63}$"
+_SNOWFLAKE_HOST_SUFFIX_REGEX = r"snowflakecomputing(\.[a-zA-Z]{1,63}){1,2}$"
+
 
 class FieldType(NamedTuple):
     name: str
@@ -399,6 +404,7 @@ class IterUnit(Enum):
     TABLE_UNIT = "table"
 
 
+# File Transfer
 # Amazon S3 multipart upload limits
 # https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html
 S3_DEFAULT_CHUNK_SIZE = 8 * 1024**2
@@ -410,8 +416,15 @@ S3_MAX_PARTS = 10000
 S3_CHUNK_SIZE = 8388608  # boto3 default
 AZURE_CHUNK_SIZE = 4 * megabyte
 
+# https://requests.readthedocs.io/en/latest/user/advanced/#timeouts
+REQUEST_CONNECTION_TIMEOUT = 10
+REQUEST_READ_TIMEOUT = 600
+
 DAY_IN_SECONDS = 60 * 60 * 24
 
 # TODO: all env variables definitions should be here
 ENV_VAR_PARTNER = "SF_PARTNER"
 ENV_VAR_TEST_MODE = "SNOWFLAKE_TEST_MODE"
+
+
+_DOMAIN_NAME_MAP = {_DEFAULT_HOSTNAME_TLD: "GLOBAL", _CHINA_HOSTNAME_TLD: "CHINA"}

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/cursor.py

@@ -601,6 +601,7 @@ class SnowflakeCursor:
         _no_results: bool = False,
         _is_put_get=None,
         _no_retry: bool = False,
+        dataframe_ast: str | None = None,
     ) -> dict[str, Any]:
         del self.messages[:]
 
@@ -704,6 +705,7 @@ class SnowflakeCursor:
                 _no_results=_no_results,
                 _no_retry=_no_retry,
                 timeout=real_timeout,
+                dataframe_ast=dataframe_ast,
             )
         finally:
             try:
@@ -809,6 +811,7 @@ class SnowflakeCursor:
         _skip_upload_on_content_match: bool = False,
         file_stream: IO[bytes] | None = None,
         num_statements: int | None = None,
+        _dataframe_ast: str | None = None,
     ) -> Self | None: ...
 
     @overload
@@ -838,6 +841,7 @@ class SnowflakeCursor:
         _skip_upload_on_content_match: bool = False,
         file_stream: IO[bytes] | None = None,
         num_statements: int | None = None,
+        _dataframe_ast: str | None = None,
     ) -> dict[str, Any] | None: ...
 
     def execute(
@@ -866,6 +870,7 @@ class SnowflakeCursor:
         _skip_upload_on_content_match: bool = False,
         file_stream: IO[bytes] | None = None,
         num_statements: int | None = None,
+        _dataframe_ast: str | None = None,
     ) -> Self | dict[str, Any] | None:
         """Executes a command/query.
 
@@ -900,6 +905,7 @@ class SnowflakeCursor:
             file_stream: File-like object to be uploaded with PUT
             num_statements: Query level parameter submitted in _statement_params constraining exact number of
             statements being submitted (or 0 if submitting an uncounted number) when using a multi-statement query.
+            _dataframe_ast: Base64-encoded dataframe request abstract syntax tree.
 
         Returns:
             The cursor itself, or None if some error happened, or the response returned
@@ -941,6 +947,7 @@ class SnowflakeCursor:
             "_no_results": _no_results,
             "_is_put_get": _is_put_get,
             "_no_retry": _no_retry,
+            "dataframe_ast": _dataframe_ast,
         }
 
         if self._connection.is_pyformat:

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/network.py

@@ -11,6 +11,7 @@ import gzip
 import itertools
 import json
 import logging
+import re
 import time
 import traceback
 import uuid
@@ -46,6 +47,7 @@ from .compat import (
     urlparse,
 )
 from .constants import (
+    _SNOWFLAKE_HOST_SUFFIX_REGEX,
     HTTP_HEADER_ACCEPT,
     HTTP_HEADER_CONTENT_TYPE,
     HTTP_HEADER_SERVICE_NAME,
@@ -156,6 +158,7 @@ REQUEST_ID = "requestId"
 REQUEST_GUID = "request_guid"
 SNOWFLAKE_HOST_SUFFIX = ".snowflakecomputing.com"
 
+
 SNOWFLAKE_CONNECTOR_VERSION = SNOWFLAKE_CONNECTOR_VERSION
 PYTHON_VERSION = PYTHON_VERSION
 OPERATING_SYSTEM = OPERATING_SYSTEM
@@ -487,6 +490,12 @@ class SnowflakeRestful:
             HTTP_HEADER_ACCEPT: accept_type,
             HTTP_HEADER_USER_AGENT: PYTHON_CONNECTOR_USER_AGENT,
         }
+        try:
+            from opentelemetry.propagate import inject
+
+            inject(headers)
+        except ModuleNotFoundError as e:
+            logger.debug(f"Opentelemtry otel injection failed because of: {e}")
         if self._connection.service_name:
             headers[HTTP_HEADER_SERVICE_NAME] = self._connection.service_name
         if method == "post":
@@ -850,7 +859,7 @@ class SnowflakeRestful:
     def add_request_guid(full_url: str) -> str:
         """Adds request_guid parameter for HTTP request tracing."""
         parsed_url = urlparse(full_url)
-        if not parsed_url.hostname.endswith(SNOWFLAKE_HOST_SUFFIX):
+        if not re.search(_SNOWFLAKE_HOST_SUFFIX_REGEX, parsed_url.hostname):
             return full_url
         request_guid = str(uuid.uuid4())
         suffix = urlencode({REQUEST_GUID: request_guid})

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/ocsp_snowflake.py

@@ -62,7 +62,7 @@ from . import constants
 from .backoff_policies import exponential_backoff
 from .cache import SFDictCache, SFDictFileCache
 from .telemetry import TelemetryField, generate_telemetry_data_dict
-from .url_util import url_encode_str
+from .url_util import extract_top_level_domain_from_hostname, url_encode_str
 
 
 class OCSPResponseValidationResult(NamedTuple):
@@ -268,15 +268,20 @@ class OCSPTelemetryData:
 class OCSPServer:
     MAX_RETRY = int(os.getenv("OCSP_MAX_RETRY", "3"))
 
-    def __init__(self) -> None:
-        self.DEFAULT_CACHE_SERVER_URL = "http://ocsp.snowflakecomputing.com"
+    def __init__(self, **kwargs) -> None:
+        top_level_domain = kwargs.pop(
+            "top_level_domain", constants._DEFAULT_HOSTNAME_TLD
+        )
+        self.DEFAULT_CACHE_SERVER_URL = (
+            f"http://ocsp.snowflakecomputing.{top_level_domain}"
+        )
         """
         The following will change to something like
         http://ocspssd.snowflakecomputing.com/ocsp/
         once the endpoint is up in the backend
         """
         self.NEW_DEFAULT_CACHE_SERVER_BASE_URL = (
-            "https://ocspssd.snowflakecomputing.com/ocsp/"
+            f"https://ocspssd.snowflakecomputing.{top_level_domain}/ocsp/"
         )
         if not OCSPServer.is_enabled_new_ocsp_endpoint():
             self.CACHE_SERVER_URL = os.getenv(
@@ -307,12 +312,13 @@ class OCSPServer:
         on the hostname the customer is trying to connect to. The deployment or in case of client failover, the
         replication ID is copied from the hostname.
         """
-        if hname.endswith("privatelink.snowflakecomputing.com"):
+        top_level_domain = extract_top_level_domain_from_hostname(hname)
+        if "privatelink.snowflakecomputing." in hname:
             temp_ocsp_endpoint = "".join(["https://ocspssd.", hname, "/ocsp/"])
-        elif hname.endswith("global.snowflakecomputing.com"):
+        elif "global.snowflakecomputing." in hname:
             rep_id_begin = hname[hname.find("-") :]
             temp_ocsp_endpoint = "".join(["https://ocspssd", rep_id_begin, "/ocsp/"])
-        elif not hname.endswith("snowflakecomputing.com"):
+        elif not hname.endswith(f"snowflakecomputing.{top_level_domain}"):
             temp_ocsp_endpoint = self.NEW_DEFAULT_CACHE_SERVER_BASE_URL
         else:
             hname_wo_acc = hname[hname.find(".") :]
@@ -832,8 +838,8 @@ class SnowflakeOCSP:
 
     OCSP_WHITELIST = re.compile(
         r"^"
-        r"(.*\.snowflakecomputing\.com$"
-        r"|(?:|.*\.)s3.*\.amazonaws\.com$"  # start with s3 or .s3 in the middle
+        r"(.*\.snowflakecomputing(\.[a-zA-Z]{1,63}){1,2}$"
+        r"|(?:|.*\.)s3.*\.amazonaws(\.[a-zA-Z]{1,63}){1,2}$"  # start with s3 or .s3 in the middle
         r"|.*\.okta\.com$"
         r"|(?:|.*\.)storage\.googleapis\.com$"
         r"|.*\.blob\.core\.windows\.net$"
@@ -881,6 +887,7 @@ class SnowflakeOCSP:
         use_ocsp_cache_server=None,
         use_post_method: bool = True,
         use_fail_open: bool = True,
+        **kwargs,
     ) -> None:
         self.test_mode = os.getenv("SF_OCSP_TEST_MODE", None)
 
@@ -888,7 +895,11 @@ class SnowflakeOCSP:
             logger.debug("WARNING - DRIVER CONFIGURED IN TEST MODE")
 
         self._use_post_method = use_post_method
-        self.OCSP_CACHE_SERVER = OCSPServer()
+        self.OCSP_CACHE_SERVER = OCSPServer(
+            top_level_domain=extract_top_level_domain_from_hostname(
+                kwargs.pop("hostname", None)
+            )
+        )
 
         self.debug_ocsp_failure_url = None
 

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/result_set.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import inspect
 from collections import deque
-from concurrent.futures import Future
+from concurrent.futures import ALL_COMPLETED, Future, wait
 from concurrent.futures.thread import ThreadPoolExecutor
 from logging import getLogger
 from typing import (
@@ -61,45 +61,64 @@ def result_set_iterator(
     Just like ``ResultBatch`` iterator, this might yield an ``Exception`` to allow users
     to continue iterating through the rest of the ``ResultBatch``.
     """
-
-    with ThreadPoolExecutor(prefetch_thread_num) as pool:
-        # Fill up window
-
-        logger.debug("beginning to schedule result batch downloads")
-
-        for _ in range(min(prefetch_thread_num, len(unfetched_batches))):
-            logger.debug(
-                f"queuing download of result batch id: {unfetched_batches[0].id}"
-            )
-            unconsumed_batches.append(
-                pool.submit(unfetched_batches.popleft().create_iter, **kw)
-            )
-
-        yield from first_batch_iter
-
-        i = 1
-        while unconsumed_batches:
-            logger.debug(f"user requesting to consume result batch {i}")
-
-            # Submit the next un-fetched batch to the pool
-            if unfetched_batches:
+    is_fetch_all = kw.pop("is_fetch_all", False)
+    if is_fetch_all:
+        with ThreadPoolExecutor(prefetch_thread_num) as pool:
+            logger.debug("beginning to schedule result batch downloads")
+            yield from first_batch_iter
+            while unfetched_batches:
                 logger.debug(
                     f"queuing download of result batch id: {unfetched_batches[0].id}"
                 )
                 future = pool.submit(unfetched_batches.popleft().create_iter, **kw)
                 unconsumed_batches.append(future)
+            _, _ = wait(unconsumed_batches, return_when=ALL_COMPLETED)
+            i = 1
+            while unconsumed_batches:
+                logger.debug(f"user began consuming result batch {i}")
+                yield from unconsumed_batches.popleft().result()
+                logger.debug(f"user began consuming result batch {i}")
+                i += 1
+        final()
+    else:
+        with ThreadPoolExecutor(prefetch_thread_num) as pool:
+            # Fill up window
+
+            logger.debug("beginning to schedule result batch downloads")
+
+            for _ in range(min(prefetch_thread_num, len(unfetched_batches))):
+                logger.debug(
+                    f"queuing download of result batch id: {unfetched_batches[0].id}"
+                )
+                unconsumed_batches.append(
+                    pool.submit(unfetched_batches.popleft().create_iter, **kw)
+                )
 
-            future = unconsumed_batches.popleft()
+            yield from first_batch_iter
 
-            # this will raise an exception if one has occurred
-            batch_iterator = future.result()
+            i = 1
+            while unconsumed_batches:
+                logger.debug(f"user requesting to consume result batch {i}")
 
-            logger.debug(f"user began consuming result batch {i}")
-            yield from batch_iterator
-            logger.debug(f"user finished consuming result batch {i}")
+                # Submit the next un-fetched batch to the pool
+                if unfetched_batches:
+                    logger.debug(
+                        f"queuing download of result batch id: {unfetched_batches[0].id}"
+                    )
+                    future = pool.submit(unfetched_batches.popleft().create_iter, **kw)
+                    unconsumed_batches.append(future)
 
-            i += 1
-    final()
+                future = unconsumed_batches.popleft()
+
+                # this will raise an exception if one has occurred
+                batch_iterator = future.result()
+
+                logger.debug(f"user began consuming result batch {i}")
+                yield from batch_iterator
+                logger.debug(f"user finished consuming result batch {i}")
+
+                i += 1
+        final()
 
 
 class ResultSet(Iterable[list]):
@@ -202,7 +221,7 @@ class ResultSet(Iterable[list]):
         """Fetches a single Pandas dataframe."""
         concat_args = list(inspect.signature(pandas.concat).parameters)
         concat_kwargs = {k: kwargs.pop(k) for k in dict(kwargs) if k in concat_args}
-        dataframes = list(self._fetch_pandas_batches(**kwargs))
+        dataframes = list(self._fetch_pandas_batches(is_fetch_all=True, **kwargs))
         if dataframes:
             return pandas.concat(
                 dataframes,
@@ -238,6 +257,9 @@ class ResultSet(Iterable[list]):
         This function is a helper function to ``__iter__`` and it was introduced for the
         cases where we need to propagate some values to later ``_download`` calls.
         """
+        # pop is_fetch_all and pass it to result_set_iterator
+        is_fetch_all = kwargs.pop("is_fetch_all", False)
+
         # add connection so that result batches can use sessions
         kwargs["connection"] = self._cursor.connection
 
@@ -257,6 +279,7 @@ class ResultSet(Iterable[list]):
             unfetched_batches,
             self._finish_iterating,
             self.prefetch_thread_num,
+            is_fetch_all=is_fetch_all,
             **kwargs,
         )
 

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/ssl_wrap_socket.py

@@ -87,6 +87,7 @@ def ssl_wrap_socket_with_ocsp(*args: Any, **kwargs: Any) -> WrappedSocket:
         v = SFOCSP(
             ocsp_response_cache_uri=FEATURE_OCSP_RESPONSE_CACHE_FILE_NAME,
             use_fail_open=FEATURE_OCSP_MODE == OCSPMode.FAIL_OPEN,
+            hostname=server_hostname,
         ).validate(server_hostname, ret.connection)
         if not v:
             raise OperationalError(

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/storage_client.py

@@ -19,7 +19,13 @@ from typing import TYPE_CHECKING, Any, Callable, NamedTuple
 
 import OpenSSL
 
-from .constants import HTTP_HEADER_CONTENT_ENCODING, FileHeader, ResultStatus
+from .constants import (
+    HTTP_HEADER_CONTENT_ENCODING,
+    REQUEST_CONNECTION_TIMEOUT,
+    REQUEST_READ_TIMEOUT,
+    FileHeader,
+    ResultStatus,
+)
 from .encryption_util import EncryptionMetadata, SnowflakeEncryptionUtil
 from .errors import RequestExceedMaxRetryError
 from .file_util import SnowflakeFileUtil
@@ -280,6 +286,7 @@ class SnowflakeStorageClient(ABC):
         while self.retry_count[retry_id] < self.max_retry:
             cur_timestamp = self.credentials.timestamp
             url, rest_kwargs = get_request_args()
+            rest_kwargs["timeout"] = (REQUEST_CONNECTION_TIMEOUT, REQUEST_READ_TIMEOUT)
             try:
                 if conn:
                     with conn._rest._use_requests_session(url) as session:

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/telemetry_oob.py

@@ -172,7 +172,7 @@ class TelemetryService:
             raise Exception("This class is a singleton!")
         else:
             TelemetryService.__instance = self
-        self._enabled = True
+        self._enabled = False
         self._queue = Queue()
         self.batch_size = DEFAULT_BATCH_SIZE
         self.num_of_retry_to_trigger_telemetry = (
@@ -192,11 +192,11 @@ class TelemetryService:
     @property
     def enabled(self) -> bool:
         """Whether the Telemetry service is enabled or not."""
-        return self._enabled
+        return False
 
     def enable(self) -> None:
         """Enable Telemetry Service."""
-        self._enabled = True
+        self._enabled = False
 
     def disable(self) -> None:
         """Disable Telemetry Service."""

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/url_util.py

@@ -8,6 +8,8 @@ import re
 import urllib.parse
 from logging import getLogger
 
+from .constants import _TOP_LEVEL_DOMAIN_REGEX
+
 logger = getLogger(__name__)
 
 
@@ -41,3 +43,11 @@ def url_encode_str(target: str | None) -> str:
         logger.debug("The string to be URL encoded is None")
         return ""
     return urllib.parse.quote_plus(target, safe="")
+
+
+def extract_top_level_domain_from_hostname(hostname: str | None = None) -> str:
+    if not hostname:
+        return "com"
+    # RFC1034 for TLD spec, and https://data.iana.org/TLD/tlds-alpha-by-domain.txt for full TLD list
+    match = re.search(_TOP_LEVEL_DOMAIN_REGEX, hostname)
+    return (match.group(0)[1:] if match else "com").lower()

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/util_text.py

@@ -240,7 +240,12 @@ def construct_hostname(region: str | None, account: str) -> str:
     if region:
         if account.find(".") > 0:
             account = account[0 : account.find(".")]
-        host = f"{account}.{region}.snowflakecomputing.com"
+        top_level_domain = (
+            "com"
+            if not any(substring in region for substring in ["cn-", "CN-"])
+            else "cn"
+        )
+        host = f"{account}.{region}.snowflakecomputing.{top_level_domain}"
     else:
         host = f"{account}.snowflakecomputing.com"
     return host

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.0}/src/snowflake/connector/version.py

@@ -1,3 +1,3 @@
 # Update this for the versions
 # Don't change the forth version number from None
-VERSION = (3, 11, 0, None)
+VERSION = (3, 12, 0, None)