snowflake-connector-python 3.6.0__tar.gz → 3.7.0__tar.gz

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/DESCRIPTION.md

@@ -8,6 +8,17 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.7.0(January 25,2024)
+
+  - Added a new boolean parameter `force_return_table` to `SnowflakeCursor.fetch_arrow_all` to force returning `pyarrow.Table` in case of zero rows.
+  - Cleanup some C++ code warnings and performance issues.
+  - Added support for Python 3.12
+  - Make local testing more robust against implicit assumptions.
+  - Fixed PyArrow Table type hinting
+  - Added support for connecting using an existing connection via the session and master token.
+  - Added support for connecting to Snowflake by authenticating with multiple SAML IDP using external browser.
+  - Fixed compilation issue due to missing cstdint header on gcc13.
+  - Improved config permissions warning message.
 
 - v3.6.0(December 09,2023)
 

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/MANIFEST.in

@@ -18,6 +18,7 @@ exclude .pre-commit-config.yaml
 exclude license_header.txt
 exclude tox.ini
 exclude mypy.ini
+exclude .clang-format
 
 prune ci
 prune benchmark

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-connector-python
-Version: 3.6.0
+Version: 3.7.0
 Summary: Snowflake Connector for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -26,6 +26,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: SQL
 Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
@@ -84,6 +85,17 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.7.0(January 25,2024)
+
+  - Added a new boolean parameter `force_return_table` to `SnowflakeCursor.fetch_arrow_all` to force returning `pyarrow.Table` in case of zero rows.
+  - Cleanup some C++ code warnings and performance issues.
+  - Added support for Python 3.12
+  - Make local testing more robust against implicit assumptions.
+  - Fixed PyArrow Table type hinting
+  - Added support for connecting using an existing connection via the session and master token.
+  - Added support for connecting to Snowflake by authenticating with multiple SAML IDP using external browser.
+  - Fixed compilation issue due to missing cstdint header on gcc13.
+  - Improved config permissions warning message.
 
 - v3.6.0(December 09,2023)
 

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/setup.cfg

@@ -24,6 +24,7 @@ classifiers =
 	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
 	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
 	Programming Language :: SQL
 	Topic :: Database
 	Topic :: Scientific/Engineering :: Information Analysis

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/setup.py

@@ -75,6 +75,8 @@ if _ABLE_TO_COMPILE_EXTENSIONS and not SNOWFLAKE_DISABLE_COMPILE_ARROW_EXTENSION
             if options["debug"]:
                 ext.extra_compile_args.append("-g")
                 ext.extra_link_args.append("-g")
+                ext.extra_compile_args.append("-O0")
+                ext.extra_link_args.append("-O0")
             current_dir = os.getcwd()
 
             if ext.name == "snowflake.connector.nanoarrow_arrow_iterator":
@@ -88,51 +90,35 @@ if _ABLE_TO_COMPILE_EXTENSIONS and not SNOWFLAKE_DISABLE_COMPILE_ARROW_EXTENSION
 
                 ext.sources += [
                     os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "CArrowIterator.cpp"
-                    ),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "CArrowChunkIterator.cpp"
-                    ),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "CArrowTableIterator.cpp"
-                    ),
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "SnowflakeType.cpp"),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "BinaryConverter.cpp"
-                    ),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "BooleanConverter.cpp"
-                    ),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "DecimalConverter.cpp"
-                    ),
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "DateConverter.cpp"),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "FixedSizeListConverter.cpp"
-                    ),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "FloatConverter.cpp"
-                    ),
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "IntConverter.cpp"),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "StringConverter.cpp"
-                    ),
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "TimeConverter.cpp"),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "TimeStampConverter.cpp"
-                    ),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "Python", "Common.cpp"
-                    ),
-                    os.path.join(
-                        NANOARROW_ARROW_ITERATOR_SRC_DIR, "Python", "Helpers.cpp"
-                    ),
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "Util", "time.cpp"),
-                    NANOARROW_LOGGING_SRC_DIR + "/logging.cpp",
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "nanoarrow.c"),
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "nanoarrow_ipc.c"),
-                    os.path.join(NANOARROW_ARROW_ITERATOR_SRC_DIR, "flatcc.c"),
+                        NANOARROW_ARROW_ITERATOR_SRC_DIR,
+                        *((file,) if isinstance(file, str) else file)
+                    )
+                    for file in {
+                        "BinaryConverter.cpp",
+                        "BooleanConverter.cpp",
+                        "CArrowChunkIterator.cpp",
+                        "CArrowIterator.cpp",
+                        "CArrowTableIterator.cpp",
+                        "DateConverter.cpp",
+                        "DecimalConverter.cpp",
+                        "FixedSizeListConverter.cpp",
+                        "FloatConverter.cpp",
+                        "IntConverter.cpp",
+                        "SnowflakeType.cpp",
+                        "StringConverter.cpp",
+                        "TimeConverter.cpp",
+                        "TimeStampConverter.cpp",
+                        "flatcc.c",
+                        "nanoarrow.c",
+                        "nanoarrow_ipc.c",
+                        ("Python", "Common.cpp"),
+                        ("Python", "Helpers.cpp"),
+                        ("Util", "time.cpp"),
+                    }
                 ]
+                ext.sources.append(
+                    os.path.join(NANOARROW_LOGGING_SRC_DIR, "logging.cpp")
+                )
                 ext.include_dirs.append(NANOARROW_ARROW_ITERATOR_SRC_DIR)
                 ext.include_dirs.append(NANOARROW_LOGGING_SRC_DIR)
 

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/arrow_context.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 import decimal
 import time
-from datetime import datetime, timedelta, tzinfo
+from datetime import datetime, timedelta, timezone, tzinfo
 from logging import getLogger
 from sys import byteorder
 from typing import TYPE_CHECKING
@@ -33,7 +33,7 @@ try:
 except ImportError:
     tzlocal = None
 
-ZERO_EPOCH = datetime.utcfromtimestamp(0)
+ZERO_EPOCH = datetime.fromtimestamp(0, timezone.utc).replace(tzinfo=None)
 
 logger = getLogger(__name__)
 
@@ -99,7 +99,9 @@ class ArrowConverterContext:
         return t.replace(tzinfo=tzinfo)
 
     def TIMESTAMP_NTZ_to_python(self, epoch: int, microseconds: int) -> datetime:
-        return datetime.utcfromtimestamp(epoch) + timedelta(microseconds=microseconds)
+        return datetime.fromtimestamp(epoch, timezone.utc).replace(
+            tzinfo=None
+        ) + timedelta(microseconds=microseconds)
 
     def TIMESTAMP_NTZ_to_python_windows(
         self, epoch: int, microseconds: int

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/auth/_auth.py

@@ -11,7 +11,7 @@ import logging
 import tempfile
 import time
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from os import getenv, makedirs, mkdir, path, remove, removedirs, rmdir
 from os.path import expanduser
 from threading import Lock, Thread
@@ -392,7 +392,7 @@ class Auth:
                     "Token expires at: %s. "
                     "Current Time: %s",
                     str(auth_instance._jwt_token_exp),
-                    str(datetime.utcnow()),
+                    str(datetime.now(timezone.utc).replace(tzinfo=None)),
                 )
             from . import AuthByUsrPwdMfa
 

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/auth/keypair.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import base64
 import hashlib
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from logging import getLogger
 from typing import Any
 
@@ -103,7 +103,7 @@ class AuthByKeyPair(AuthByPlugin):
         account = account.upper()
         user = user.upper()
 
-        now = datetime.utcnow()
+        now = datetime.now(timezone.utc).replace(tzinfo=None)
 
         if isinstance(self._private_key, bytes):
             try:

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/auth/webbrowser.py

@@ -5,16 +5,18 @@
 
 from __future__ import annotations
 
+import base64
 import json
 import logging
 import os
+import secrets
 import socket
 import time
 import webbrowser
 from types import ModuleType
 from typing import TYPE_CHECKING, Any
 
-from ..compat import parse_qs, urlparse, urlsplit
+from ..compat import parse_qs, urlencode, urlparse, urlsplit
 from ..constants import (
     HTTP_HEADER_ACCEPT,
     HTTP_HEADER_CONTENT_TYPE,
@@ -134,10 +136,14 @@ class AuthByWebBrowser(AuthByPlugin):
             socket_connection.listen(0)  # no backlog
             callback_port = socket_connection.getsockname()[1]
 
-            logger.debug("step 1: query GS to obtain SSO url")
-            sso_url = self._get_sso_url(
-                conn, authenticator, service_name, account, callback_port, user
-            )
+            if conn._disable_console_login:
+                logger.debug("step 1: query GS to obtain SSO url")
+                sso_url = self._get_sso_url(
+                    conn, authenticator, service_name, account, callback_port, user
+                )
+            else:
+                logger.debug("step 1: constructing console login url")
+                sso_url = self._get_console_login_url(conn, callback_port, user)
 
             logger.debug("Validate SSO URL")
             if not is_valid_url(sso_url):
@@ -274,15 +280,13 @@ class AuthByWebBrowser(AuthByPlugin):
             content.append(f"Access-Control-Allow-Origin: {self._origin}")
             content.append("Vary: Accept-Encoding, Origin")
         else:
-            msg = """
+            msg = f"""
 <!DOCTYPE html><html><head><meta charset="UTF-8"/>
 <title>SAML Response for Snowflake</title></head>
 <body>
-Your identity was confirmed and propagated to Snowflake {}.
+Your identity was confirmed and propagated to Snowflake {self._application}.
 You can close this window now and go back where you started from.
-</body></html>""".format(
-                self._application
-            )
+</body></html>"""
         content.append(f"Content-Length: {len(msg)}")
         content.append("")
         content.append(msg)
@@ -415,3 +419,21 @@ You can close this window now and go back where you started from.
         sso_url = data["ssoUrl"]
         self._proof_key = data["proofKey"]
         return sso_url
+
+    def _get_console_login_url(
+        self, conn: SnowflakeConnection, port: int, user: str
+    ) -> str:
+        self._proof_key = base64.b64encode(secrets.token_bytes(32)).decode("ascii")
+        url = (
+            conn._rest.server_url
+            + "/console/login?"
+            + urlencode(
+                {
+                    "login_name": user,
+                    "browser_mode_redirect_port": port,
+                    "proof_key": self._proof_key,
+                }
+            )
+        )
+        logger.debug(f"Console Log In URL: {url}")
+        return url

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/azure_storage_client.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import json
 import os
 import xml.etree.ElementTree as ET
-from datetime import datetime
+from datetime import datetime, timezone
 from logging import getLogger
 from random import choice
 from string import hexdigits
@@ -90,7 +90,7 @@ class SnowflakeAzureRestClient(SnowflakeStorageClient):
             headers = {}
 
         def generate_authenticated_url_and_rest_args() -> tuple[bytes, dict[str, Any]]:
-            curtime = datetime.utcnow()
+            curtime = datetime.now(timezone.utc).replace(tzinfo=None)
             timestamp = curtime.strftime("YYYY-MM-DD")
             sas_token = self.credentials.creds["AZURE_SAS_TOKEN"]
             if sas_token and sas_token.startswith("?"):

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/config_manager.py

@@ -336,7 +336,7 @@ class ConfigManager:
             ):
                 # for non-Windows, suggest change to 0600 permissions.
                 chmod_message = (
-                    f". To change owner, run `chown $USER {str(filep)}`. To restrict permissions, run `chmod 0600 {str(filep)}`."
+                    f'.\n * To change owner, run `chown $USER "{str(filep)}"`.\n * To restrict permissions, run `chmod 0600 "{str(filep)}"`.\n'
                     if not IS_WINDOWS
                     else ""
                 )

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/connection.py

@@ -256,6 +256,22 @@ DEFAULT_CONFIGURATION: dict[str, tuple[Any, type | tuple[type, ...]]] = {
         True,
         bool,
     ),  # Enable sending retryReason in response header for query-requests
+    "session_token": (
+        None,
+        (type(None), str),
+    ),  # session token from another connection, to be provided together with master token
+    "master_token": (
+        None,
+        (type(None), str),
+    ),  # master token from another connection, to be provided together with session token
+    "master_validity_in_seconds": (
+        None,
+        (type(None), int),
+    ),  # master token validity in seconds
+    "disable_console_login": (
+        True,
+        bool,
+    ),  # Disable console login and fall back to getting SSO URL from GS
 }
 
 APPLICATION_RE = re.compile(r"[\w\d_]+")
@@ -913,100 +929,123 @@ class SnowflakeConnection:
 
         # Setup authenticator
         auth = Auth(self.rest)
-        if self.auth_class is not None:
-            if type(
-                self.auth_class
-            ) not in FIRST_PARTY_AUTHENTICATORS and not issubclass(
-                type(self.auth_class), AuthByKeyPair
-            ):
-                raise TypeError("auth_class must be a child class of AuthByKeyPair")
-                # TODO: add telemetry for custom auth
-            self.auth_class = self.auth_class
-        elif self._authenticator == DEFAULT_AUTHENTICATOR:
-            self.auth_class = AuthByDefault(
-                password=self._password,
-                timeout=self._login_timeout,
-                backoff_generator=self._backoff_generator,
-            )
-        elif self._authenticator == EXTERNAL_BROWSER_AUTHENTICATOR:
-            self._session_parameters[PARAMETER_CLIENT_STORE_TEMPORARY_CREDENTIAL] = (
-                self._client_store_temporary_credential if IS_LINUX else True
-            )
-            auth.read_temporary_credentials(
-                self.host,
-                self.user,
-                self._session_parameters,
+
+        if self._session_token and self._master_token:
+            auth._rest.update_tokens(
+                self._session_token,
+                self._master_token,
+                self._master_validity_in_seconds,
             )
-            # Depending on whether self._rest.id_token is available we do different
-            #  auth_instance
-            if self._rest.id_token is None:
-                self.auth_class = AuthByWebBrowser(
-                    application=self.application,
-                    protocol=self._protocol,
-                    host=self.host,
-                    port=self.port,
-                    timeout=self._login_timeout,
-                    backoff_generator=self._backoff_generator,
+            heartbeat_ret = auth._rest._heartbeat()
+            logger.debug(heartbeat_ret)
+            if not heartbeat_ret or not heartbeat_ret.get("success"):
+                Error.errorhandler_wrapper(
+                    self,
+                    None,
+                    ProgrammingError,
+                    {
+                        "msg": "Session and master tokens invalid",
+                        "errno": ER_INVALID_VALUE,
+                    },
                 )
             else:
-                self.auth_class = AuthByIdToken(
-                    id_token=self._rest.id_token,
-                    application=self.application,
-                    protocol=self._protocol,
-                    host=self.host,
-                    port=self.port,
+                logger.debug("Session and master token validation successful.")
+
+        else:
+            if self.auth_class is not None:
+                if type(
+                    self.auth_class
+                ) not in FIRST_PARTY_AUTHENTICATORS and not issubclass(
+                    type(self.auth_class), AuthByKeyPair
+                ):
+                    raise TypeError("auth_class must be a child class of AuthByKeyPair")
+                    # TODO: add telemetry for custom auth
+                self.auth_class = self.auth_class
+            elif self._authenticator == DEFAULT_AUTHENTICATOR:
+                self.auth_class = AuthByDefault(
+                    password=self._password,
                     timeout=self._login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
-
-        elif self._authenticator == KEY_PAIR_AUTHENTICATOR:
-            private_key = self._private_key
-
-            if self._private_key_file:
-                private_key = _get_private_bytes_from_file(
-                    self._private_key_file,
-                    self._private_key_file_pwd,
-                )
-
-            self.auth_class = AuthByKeyPair(
-                private_key=private_key,
-                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,
-                backoff_generator=self._backoff_generator,
-            )
-        elif self._authenticator == USR_PWD_MFA_AUTHENTICATOR:
-            self._session_parameters[PARAMETER_CLIENT_REQUEST_MFA_TOKEN] = (
-                self._client_request_mfa_token if IS_LINUX else True
-            )
-            if self._session_parameters[PARAMETER_CLIENT_REQUEST_MFA_TOKEN]:
+            elif self._authenticator == EXTERNAL_BROWSER_AUTHENTICATOR:
+                self._session_parameters[
+                    PARAMETER_CLIENT_STORE_TEMPORARY_CREDENTIAL
+                ] = (self._client_store_temporary_credential if IS_LINUX else True)
                 auth.read_temporary_credentials(
                     self.host,
                     self.user,
                     self._session_parameters,
                 )
-            self.auth_class = AuthByUsrPwdMfa(
-                password=self._password,
-                mfa_token=self.rest.mfa_token,
-                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,
-                backoff_generator=self._backoff_generator,
-            )
+                # Depending on whether self._rest.id_token is available we do different
+                #  auth_instance
+                if self._rest.id_token is None:
+                    self.auth_class = AuthByWebBrowser(
+                        application=self.application,
+                        protocol=self._protocol,
+                        host=self.host,
+                        port=self.port,
+                        timeout=self._login_timeout,
+                        backoff_generator=self._backoff_generator,
+                    )
+                else:
+                    self.auth_class = AuthByIdToken(
+                        id_token=self._rest.id_token,
+                        application=self.application,
+                        protocol=self._protocol,
+                        host=self.host,
+                        port=self.port,
+                        timeout=self._login_timeout,
+                        backoff_generator=self._backoff_generator,
+                    )
+
+            elif self._authenticator == KEY_PAIR_AUTHENTICATOR:
+                private_key = self._private_key
+
+                if self._private_key_file:
+                    private_key = _get_private_bytes_from_file(
+                        self._private_key_file,
+                        self._private_key_file_pwd,
+                    )
+
+                self.auth_class = AuthByKeyPair(
+                    private_key=private_key,
+                    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,
+                    backoff_generator=self._backoff_generator,
+                )
+            elif self._authenticator == USR_PWD_MFA_AUTHENTICATOR:
+                self._session_parameters[PARAMETER_CLIENT_REQUEST_MFA_TOKEN] = (
+                    self._client_request_mfa_token if IS_LINUX else True
+                )
+                if self._session_parameters[PARAMETER_CLIENT_REQUEST_MFA_TOKEN]:
+                    auth.read_temporary_credentials(
+                        self.host,
+                        self.user,
+                        self._session_parameters,
+                    )
+                self.auth_class = AuthByUsrPwdMfa(
+                    password=self._password,
+                    mfa_token=self.rest.mfa_token,
+                    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,
+                    backoff_generator=self._backoff_generator,
+                )
 
-        self.authenticate_with_retry(self.auth_class)
+            self.authenticate_with_retry(self.auth_class)
 
-        self._password = None  # ensure password won't persist
-        self.auth_class.reset_secrets()
+            self._password = None  # ensure password won't persist
+            self.auth_class.reset_secrets()
 
         self.initialize_query_context_cache()
 
@@ -1115,34 +1154,35 @@ class SnowflakeConnection:
             ]:
                 self._authenticator = auth_tmp
 
-        if not self.user and self._authenticator != OAUTH_AUTHENTICATOR:
-            # OAuth Authentication does not require a username
-            Error.errorhandler_wrapper(
-                self,
-                None,
-                ProgrammingError,
-                {"msg": "User is empty", "errno": ER_NO_USER},
-            )
+        if not (self._master_token and self._session_token):
+            if not self.user and self._authenticator != OAUTH_AUTHENTICATOR:
+                # OAuth Authentication does not require a username
+                Error.errorhandler_wrapper(
+                    self,
+                    None,
+                    ProgrammingError,
+                    {"msg": "User is empty", "errno": ER_NO_USER},
+                )
 
-        if self._private_key or self._private_key_file:
-            self._authenticator = KEY_PAIR_AUTHENTICATOR
+            if self._private_key or self._private_key_file:
+                self._authenticator = KEY_PAIR_AUTHENTICATOR
 
-        if (
-            self.auth_class is None
-            and self._authenticator
-            not in [
-                EXTERNAL_BROWSER_AUTHENTICATOR,
-                OAUTH_AUTHENTICATOR,
-                KEY_PAIR_AUTHENTICATOR,
-            ]
-            and not self._password
-        ):
-            Error.errorhandler_wrapper(
-                self,
-                None,
-                ProgrammingError,
-                {"msg": "Password is empty", "errno": ER_NO_PASSWORD},
-            )
+            if (
+                self.auth_class is None
+                and self._authenticator
+                not in [
+                    EXTERNAL_BROWSER_AUTHENTICATOR,
+                    OAUTH_AUTHENTICATOR,
+                    KEY_PAIR_AUTHENTICATOR,
+                ]
+                and not self._password
+            ):
+                Error.errorhandler_wrapper(
+                    self,
+                    None,
+                    ProgrammingError,
+                    {"msg": "Password is empty", "errno": ER_NO_PASSWORD},
+                )
 
         if not self._account:
             Error.errorhandler_wrapper(

{snowflake-connector-python-3.6.0 → snowflake-connector-python-3.7.0}/src/snowflake/connector/connection_diagnostic.py

@@ -211,7 +211,7 @@ class ConnectionDiagnostic:
                     conn.send(str.encode(connect))
                     conn.recv(4096).decode("utf-8")
 
-                context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+                context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
                 sock = context.wrap_socket(conn, server_hostname=host)
                 certificate = ssl.DER_cert_to_PEM_cert(sock.getpeercert(True))
                 conn.close()