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

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

@@ -8,6 +8,24 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.12.1(August 20,2024)
+  - Fixed a bug that logged the session token when renewing a session.
+  - Fixed a bug where disabling client telemetry did not work.
+  - Fixed a bug where passing `login_timeout` as a string raised a `TypeError` during the login retry step.
+  - Use `pathlib` instead of `os` for default config file location resolution.
+  - Removed upper `cryptogaphy` version pin.
+  - Removed reference to script `snowflake-export-certs` (its backing module was already removed long ago)
+  - Enhanced retry mechanism for handling transient network failures during query result polling when no server response is received.
+
+- 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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-connector-python
-Version: 3.11.0
+Version: 3.12.1
 Summary: Snowflake Connector for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -40,7 +40,7 @@ License-File: LICENSE.txt
 License-File: NOTICE
 Requires-Dist: asn1crypto<2.0.0,>0.24.0
 Requires-Dist: cffi<2.0.0,>=1.9
-Requires-Dist: cryptography<43.0.0,>=3.1.0
+Requires-Dist: cryptography>=3.1.0
 Requires-Dist: pyOpenSSL<25.0.0,>=16.2.0
 Requires-Dist: pyjwt<3.0.0
 Requires-Dist: pytz
@@ -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,24 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.12.1(August 20,2024)
+  - Fixed a bug that logged the session token when renewing a session.
+  - Fixed a bug where disabling client telemetry did not work.
+  - Fixed a bug where passing `login_timeout` as a string raised a `TypeError` during the login retry step.
+  - Use `pathlib` instead of `os` for default config file location resolution.
+  - Removed upper `cryptogaphy` version pin.
+  - Removed reference to script `snowflake-export-certs` (its backing module was already removed long ago)
+  - Enhanced retry mechanism for handling transient network failures during query result polling when no server response is received.
+
+- 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.1}/README.md

@@ -52,3 +52,32 @@ These tools are integrated into `tox` to allow us to easily set them up universa
 * **coverage**: Runs `coverage.py` to combine generated coverage data files. Useful when multiple categories were run
   and we would like to have an overall coverage data file created for them.
 * **flake8**: (Deprecated) Similar to `fix_lint`, but only runs `flake8` checks.
+
+## Disable telemetry
+
+By default, the Snowflake Connector for Python collects telemetry data to improve the product.
+You can disable the telemetry data collection by setting the session parameter `CLIENT_TELEMETRY_ENABLED` to `False`
+when connecting to Snowflake:
+```python
+import snowflake.connector
+conn = snowflake.connector.connect(
+    user='XXXX',
+    password='XXXX',
+    account='XXXX',
+    session_parameters={
+      "CLIENT_TELEMETRY_ENABLED": False,
+    }
+)
+```
+
+Alternatively, you can disable the telemetry data collection
+by setting the `telemetry_enabled` property to `False` on the `SnowflakeConnection` object:
+```python
+import snowflake.connector
+conn = snowflake.connector.connect(
+    user='XXXX',
+    password='XXXX',
+    account='XXXX',
+)
+conn.telemetry_enabled = False
+```

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

@@ -45,7 +45,7 @@ packages = find_namespace:
 install_requires = 
 	asn1crypto>0.24.0,<2.0.0
 	cffi>=1.9,<2.0.0
-	cryptography>=3.1.0,<43.0.0
+	cryptography>=3.1.0
 	pyOpenSSL>=16.2.0,<25.0.0
 	pyjwt<3.0.0
 	pytz
@@ -76,7 +76,6 @@ console_scripts =
 	snowflake-dump-ocsp-response = snowflake.connector.tool.dump_ocsp_response:main
 	snowflake-dump-ocsp-response-cache = snowflake.connector.tool.dump_ocsp_response_cache:main
 	snowflake-dump-certs = snowflake.connector.tool.dump_certs:main
-	snowflake-export-certs = snowflake.connector.tool.export_certs:main
 
 [options.extras_require]
 development = 
@@ -96,7 +95,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.1}/src/snowflake/connector/auth/_auth.py

@@ -198,7 +198,7 @@ class Auth:
             self._rest._connection._internal_application_name,
             self._rest._connection._internal_application_version,
             self._rest._connection._ocsp_mode(),
-            self._rest._connection._login_timeout,
+            self._rest._connection.login_timeout,
             self._rest._connection._network_timeout,
             self._rest._connection._socket_timeout,
         )

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.1}/src/snowflake/connector/auth/okta.py

@@ -170,7 +170,7 @@ class AuthByOkta(AuthByPlugin):
             conn._internal_application_name,
             conn._internal_application_version,
             conn._ocsp_mode(),
-            conn._login_timeout,
+            conn.login_timeout,
             conn._network_timeout,
         )
 

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.1}/src/snowflake/connector/auth/webbrowser.py

@@ -462,7 +462,7 @@ You can close this window now and go back where you started from.
             conn._rest._connection._internal_application_name,
             conn._rest._connection._internal_application_version,
             conn._rest._connection._ocsp_mode(),
-            conn._rest._connection._login_timeout,
+            conn._rest._connection.login_timeout,
             conn._rest._connection._network_timeout,
         )
 

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.1}/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,
@@ -60,7 +61,6 @@ from .constants import (
     PARAMETER_CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY,
     PARAMETER_CLIENT_STORE_TEMPORARY_CREDENTIAL,
     PARAMETER_CLIENT_TELEMETRY_ENABLED,
-    PARAMETER_CLIENT_TELEMETRY_OOB_ENABLED,
     PARAMETER_CLIENT_VALIDATE_DEFAULT_PARAMETERS,
     PARAMETER_ENABLE_STAGE_S3_PRIVATELINK_FOR_US_EAST_1,
     PARAMETER_QUERY_CONTEXT_CACHE_SIZE,
@@ -105,8 +105,8 @@ from .network import (
 )
 from .sqlstate import SQLSTATE_CONNECTION_NOT_EXISTS, SQLSTATE_FEATURE_NOT_SUPPORTED
 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 +181,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 +190,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
@@ -403,7 +407,8 @@ class SnowflakeConnection:
         self.messages = []
         self._async_sfqids: dict[str, None] = {}
         self._done_async_sfqids: dict[str, None] = {}
-        self.telemetry_enabled = False
+        self._client_param_telemetry_enabled = True
+        self._server_param_telemetry_enabled = False
         self._session_parameters: dict[str, str | int | bool] = {}
         logger.info(
             "Snowflake Connector for Python Version: %s, "
@@ -620,11 +625,22 @@ class SnowflakeConnection:
 
     @property
     def telemetry_enabled(self) -> bool:
-        return self._telemetry_enabled
+        return bool(
+            self._client_param_telemetry_enabled
+            and self._server_param_telemetry_enabled
+        )
 
     @telemetry_enabled.setter
     def telemetry_enabled(self, value) -> None:
-        self._telemetry_enabled = True if value else False
+        self._client_param_telemetry_enabled = True if value else False
+        if (
+            self._client_param_telemetry_enabled
+            and not self._server_param_telemetry_enabled
+        ):
+            logger.info(
+                "Telemetry has been disabled by the session parameter CLIENT_TELEMETRY_ENABLED."
+                " Set session parameter CLIENT_TELEMETRY_ENABLED to true to enable telemetry."
+            )
 
     @property
     def service_name(self) -> str | None:
@@ -714,7 +730,6 @@ class SnowflakeConnection:
         logger.debug("connect")
         if len(kwargs) > 0:
             self.__config(**kwargs)
-            TelemetryService.get_instance().update_context(kwargs)
 
         if self.enable_connection_diag:
             exceptions_dict = {}
@@ -771,7 +786,7 @@ class SnowflakeConnection:
 
             # close telemetry first, since it needs rest to send remaining data
             logger.info("closed")
-            self._telemetry.close(send_on_close=retry)
+            self._telemetry.close(send_on_close=bool(retry and self.telemetry_enabled))
             if (
                 self._all_async_queries_finished()
                 and not self._server_session_keep_alive
@@ -931,7 +946,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:
@@ -1003,7 +1018,7 @@ class SnowflakeConnection:
             elif self._authenticator == DEFAULT_AUTHENTICATOR:
                 self.auth_class = AuthByDefault(
                     password=self._password,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             elif self._authenticator == EXTERNAL_BROWSER_AUTHENTICATOR:
@@ -1023,7 +1038,7 @@ class SnowflakeConnection:
                         protocol=self._protocol,
                         host=self.host,
                         port=self.port,
-                        timeout=self._login_timeout,
+                        timeout=self.login_timeout,
                         backoff_generator=self._backoff_generator,
                     )
                 else:
@@ -1033,7 +1048,7 @@ class SnowflakeConnection:
                         protocol=self._protocol,
                         host=self.host,
                         port=self.port,
-                        timeout=self._login_timeout,
+                        timeout=self.login_timeout,
                         backoff_generator=self._backoff_generator,
                     )
 
@@ -1048,13 +1063,13 @@ class SnowflakeConnection:
 
                 self.auth_class = AuthByKeyPair(
                     private_key=private_key,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             elif self._authenticator == OAUTH_AUTHENTICATOR:
                 self.auth_class = AuthByOAuth(
                     oauth_token=self._token,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             elif self._authenticator == USR_PWD_MFA_AUTHENTICATOR:
@@ -1070,14 +1085,14 @@ class SnowflakeConnection:
                 self.auth_class = AuthByUsrPwdMfa(
                     password=self._password,
                     mfa_token=self.rest.mfa_token,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             else:
                 # okta URL, e.g., https://<account>.okta.com/
                 self.auth_class = AuthByOkta(
                     application=self.application,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
 
@@ -1178,6 +1193,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 +1306,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 +1316,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 +1692,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 +1706,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:
@@ -1702,12 +1726,7 @@ class SnowflakeConnection:
         for name, value in parameters.items():
             self._session_parameters[name] = value
             if PARAMETER_CLIENT_TELEMETRY_ENABLED == name:
-                self.telemetry_enabled = value
-            elif PARAMETER_CLIENT_TELEMETRY_OOB_ENABLED == name:
-                if value:
-                    TelemetryService.get_instance().enable()
-                else:
-                    TelemetryService.get_instance().disable()
+                self._server_param_telemetry_enabled = value
             elif PARAMETER_CLIENT_SESSION_KEEP_ALIVE == name:
                 # Only set if the local config is None.
                 # Always give preference to user config.

{snowflake_connector_python-3.11.0 → snowflake_connector_python-3.12.1}/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.1}/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.1}/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.1}/src/snowflake/connector/errors.py

@@ -15,7 +15,6 @@ from typing import TYPE_CHECKING, Any
 from .compat import BASE_EXCEPTION_CLASS
 from .secret_detector import SecretDetector
 from .telemetry import TelemetryData, TelemetryField
-from .telemetry_oob import TelemetryService
 from .time_util import get_time_millis
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -167,11 +166,6 @@ class Error(BASE_EXCEPTION_CLASS):
                 )
             except AttributeError:
                 logger.debug("Cursor failed to log to telemetry.", exc_info=True)
-        elif connection is None:
-            # Send with out-of-band telemetry
-
-            telemetry_oob = TelemetryService.get_instance()
-            telemetry_oob.log_general_exception(self.__class__.__name__, telemetry_data)
 
     def exception_telemetry(
         self,