snowflake-connector-python 4.1.0__tar.gz → 4.1.1__tar.gz

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/DESCRIPTION.md

@@ -7,6 +7,11 @@ https://docs.snowflake.com/
 Source code is also available at: https://github.com/snowflakedb/snowflake-connector-python
 
 # Release Notes
+- v4.1.1(TBD)
+  - Relaxed pandas dependency requirements for Python below 3.12.
+  - Changed CRL cache cleanup background task to daemon to avoid blocking main thread.
+  - Fixed NO_PROXY issues with PUT operations
+
 - v4.1.0(November 18,2025)
   - Added the `SNOWFLAKE_AUTH_FORCE_SERVER` environment variable to force the use of the local-listening server when using the `externalbrowser` auth method.
     - This allows headless environments (like Docker or Airflow) running locally to auth via a browser URL.

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-connector-python
-Version: 4.1.0
+Version: 4.1.1
 Summary: Snowflake Connector for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -62,6 +62,7 @@ Requires-Dist: botocore>=1.24; extra == "boto"
 Provides-Extra: development
 Requires-Dist: Cython; extra == "development"
 Requires-Dist: coverage; extra == "development"
+Requires-Dist: mitmproxy>=6.0.0; python_version >= "3.10" and extra == "development"
 Requires-Dist: more-itertools; extra == "development"
 Requires-Dist: numpy<=2.2.4; extra == "development"
 Requires-Dist: pendulum!=2.1.1; extra == "development"
@@ -74,7 +75,8 @@ Requires-Dist: pytest-xdist; extra == "development"
 Requires-Dist: pytzdata; extra == "development"
 Requires-Dist: responses; extra == "development"
 Provides-Extra: pandas
-Requires-Dist: pandas<3.0.0,>=2.1.2; extra == "pandas"
+Requires-Dist: pandas<3.0.0,>=1.0.0; python_version < "3.13" and extra == "pandas"
+Requires-Dist: pandas<3.0.0,>=2.1.2; python_version >= "3.13" and extra == "pandas"
 Requires-Dist: pyarrow>=14.0.1; extra == "pandas"
 Provides-Extra: secure-local-storage
 Requires-Dist: keyring<26.0.0,>=23.1.0; extra == "secure-local-storage"
@@ -90,6 +92,11 @@ https://docs.snowflake.com/
 Source code is also available at: https://github.com/snowflakedb/snowflake-connector-python
 
 # Release Notes
+- v4.1.1(TBD)
+  - Relaxed pandas dependency requirements for Python below 3.12.
+  - Changed CRL cache cleanup background task to daemon to avoid blocking main thread.
+  - Fixed NO_PROXY issues with PUT operations
+
 - v4.1.0(November 18,2025)
   - Added the `SNOWFLAKE_AUTH_FORCE_SERVER` environment variable to force the use of the local-listening server when using the `externalbrowser` auth method.
     - This allows headless environments (like Docker or Airflow) running locally to auth via a browser URL.

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/setup.cfg

@@ -82,6 +82,7 @@ boto =
 development = 
 	Cython
 	coverage
+	mitmproxy>=6.0.0; python_version >= '3.10'
 	more-itertools
 	numpy<=2.2.4
 	pendulum!=2.1.1
@@ -94,7 +95,8 @@ development =
 	pytzdata
 	responses
 pandas = 
-	pandas>=2.1.2,<3.0.0
+	pandas>=1.0.0,<3.0.0; python_version < '3.13'
+	pandas>=2.1.2,<3.0.0; python_version >= '3.13'
 	pyarrow>=14.0.1
 secure-local-storage = 
 	keyring>=23.1.0,<26.0.0

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/src/snowflake/connector/connection.py

@@ -476,6 +476,10 @@ DEFAULT_CONFIGURATION: dict[str, tuple[Any, type | tuple[type, ...]]] = {
         None,
         (type(None), bool),
     ),  # Run CRL cache cleanup in the background
+    "crl_download_max_size": (
+        None,
+        (type(None), int),
+    ),  # Maximum CRL file size in bytes
 }
 
 APPLICATION_RE = re.compile(r"[\w\d_]+")
@@ -786,6 +790,20 @@ class SnowflakeConnection:
             return self._crl_cache_start_cleanup
         return self._crl_config.crl_cache_start_cleanup
 
+    @property
+    def crl_download_max_size(self) -> int | None:
+        """Maximum CRL file size in bytes."""
+        if not self._crl_config:
+            return self._crl_download_max_size
+        return self._crl_config.crl_download_max_size
+
+    @property
+    def skip_file_permissions_check(self) -> bool | None:
+        """Whether to skip file permission checks for CRL cache files."""
+        if not self._crl_config:
+            return self._skip_file_permissions_check
+        return self._crl_config.skip_file_permissions_check
+
     @property
     def session_id(self) -> int:
         return self._session_id

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/src/snowflake/connector/crl.py

@@ -64,6 +64,8 @@ class CRLConfig:
     crl_cache_removal_delay_days: int = 7
     crl_cache_cleanup_interval_hours: int = 1
     crl_cache_start_cleanup: bool = False
+    crl_download_max_size: int = 200 * 1024 * 1024  # 200 MB
+    unsafe_skip_file_permissions_check: bool = False
 
     @classmethod
     def from_connection(cls, sf_connection) -> CRLConfig:
@@ -158,6 +160,15 @@ class CRLConfig:
             if sf_connection.crl_cache_start_cleanup is None
             else bool(sf_connection.crl_cache_start_cleanup)
         )
+        crl_download_max_size = (
+            cls.crl_download_max_size
+            if sf_connection.crl_download_max_size is None
+            else int(sf_connection.crl_download_max_size)
+        )
+        # Use the existing unsafe_skip_file_permissions_check flag from connection
+        unsafe_skip_file_permissions_check = bool(
+            sf_connection._unsafe_skip_file_permissions_check
+        )
 
         return cls(
             cert_revocation_check_mode=cert_revocation_check_mode,
@@ -171,6 +182,8 @@ class CRLConfig:
             crl_cache_removal_delay_days=crl_cache_removal_delay_days,
             crl_cache_cleanup_interval_hours=crl_cache_cleanup_interval_hours,
             crl_cache_start_cleanup=crl_cache_start_cleanup,
+            crl_download_max_size=crl_download_max_size,
+            unsafe_skip_file_permissions_check=unsafe_skip_file_permissions_check,
         )
 
 
@@ -185,6 +198,7 @@ class CRLValidator:
         read_timeout_ms: int = CRLConfig.read_timeout_ms,
         cache_validity_time: timedelta = CRLConfig.cache_validity_time,
         cache_manager: CRLCacheManager | None = None,
+        crl_download_max_size: int = CRLConfig.crl_download_max_size,
     ):
         self._session_manager = session_manager
         self._cert_revocation_check_mode = cert_revocation_check_mode
@@ -193,6 +207,7 @@ class CRLValidator:
         self._read_timeout_ms = read_timeout_ms
         self._cache_validity_time = cache_validity_time
         self._cache_manager = cache_manager or CRLCacheManager.noop()
+        self._crl_download_max_size = crl_download_max_size
 
         # list of trusted CA and their certificates
         self._trusted_ca: dict[x509.Name, list[x509.Certificate]] = defaultdict(list)
@@ -237,7 +252,9 @@ class CRLValidator:
             if config.enable_crl_file_cache:
                 removal_delay = timedelta(days=config.crl_cache_removal_delay_days)
                 file_cache = CRLCacheFactory.get_file_cache(
-                    cache_dir=config.crl_cache_dir, removal_delay=removal_delay
+                    cache_dir=config.crl_cache_dir,
+                    removal_delay=removal_delay,
+                    unsafe_skip_file_permissions_check=config.unsafe_skip_file_permissions_check,
                 )
             else:
                 from snowflake.connector.crl_cache import NoopCRLCache
@@ -268,6 +285,7 @@ class CRLValidator:
             read_timeout_ms=config.read_timeout_ms,
             cache_validity_time=config.cache_validity_time,
             cache_manager=cache_manager,
+            crl_download_max_size=config.crl_download_max_size,
         )
 
     def validate_certificate_chain(
@@ -550,15 +568,99 @@ class CRLValidator:
         try:
             logger.debug("Trying to download CRL from: %s", crl_url)
             response = self._session_manager.get(
-                crl_url, timeout=(self._connection_timeout_ms, self._read_timeout_ms)
+                crl_url,
+                timeout=(self._connection_timeout_ms, self._read_timeout_ms),
+                stream=True,
             )
             response.raise_for_status()
-            return response.content
+
+            # Check Content-Length header first if available
+            content_length = response.headers.get("Content-Length")
+            if content_length:
+                try:
+                    size = int(content_length)
+                    if size > self._crl_download_max_size:
+                        logger.warning(
+                            "CRL from %s exceeds maximum size limit (%d bytes > %d bytes)",
+                            crl_url,
+                            size,
+                            self._crl_download_max_size,
+                        )
+                        return None
+                except ValueError:
+                    logger.debug(
+                        "Invalid Content-Length header for %s: %s",
+                        crl_url,
+                        content_length,
+                    )
+
+            # Stream the content and check size as we download
+            chunks = []
+            total_size = 0
+            for chunk in response.iter_content(chunk_size=8192):
+                if not chunk:
+                    continue
+                total_size += len(chunk)
+                if total_size > self._crl_download_max_size:
+                    logger.warning(
+                        "CRL from %s exceeded maximum size limit during download (%d bytes)",
+                        crl_url,
+                        self._crl_download_max_size,
+                    )
+                    return None
+                chunks.append(chunk)
+
+            return b"".join(chunks)
         except Exception:
             # CRL fetch or parsing failed
             logger.exception("Failed to download CRL from %s", crl_url)
             return None
 
+    def _get_crl_last_update(
+        self, crl: x509.CertificateRevocationList
+    ) -> datetime | None:
+        """
+        Get the last_update timestamp from a CRL.
+
+        Args:
+            crl: The CRL to extract the timestamp from
+
+        Returns:
+            The last_update timestamp, or None if not available
+        """
+        try:
+            return crl.last_update_utc
+        except AttributeError:
+            return getattr(crl, "last_update", None)
+
+    def _is_crl_more_recent(
+        self,
+        new_crl: x509.CertificateRevocationList,
+        cached_crl: x509.CertificateRevocationList,
+    ) -> bool:
+        """
+        Check if a newly downloaded CRL is more recent than a cached CRL.
+
+        Args:
+            new_crl: The newly downloaded CRL
+            cached_crl: The cached CRL
+
+        Returns:
+            True if new_crl is more recent (has a later last_update), False otherwise
+        """
+        new_last_update = self._get_crl_last_update(new_crl)
+        cached_last_update = self._get_crl_last_update(cached_crl)
+
+        if new_last_update is None:
+            logger.warning("New CRL has no last_update timestamp")
+            return False
+
+        if cached_last_update is None:
+            logger.warning("Cached CRL has no last_update timestamp")
+            return True
+
+        return new_last_update > cached_last_update
+
     def _download_crl(
         self, crl_url: str
     ) -> tuple[x509.CertificateRevocationList | None, datetime | None]:
@@ -572,7 +674,12 @@ class CRLValidator:
             except AttributeError:
                 next_update = crl.next_update
 
-            if next_update and now > next_update:
+            if not next_update:
+                # reject CRL as lack of next_update timestamp is a violation of both the RFC and the governing policy documents.
+                logger.warning("CRL from %s has no next_update timestamp", crl_url)
+                return None, None
+
+            if now > next_update:
                 logger.warning(
                     "The CRL from %s was expired on %s", crl_url, next_update
                 )
@@ -595,9 +702,27 @@ class CRLValidator:
             or cached_crl.is_crl_expired_by(now)
             or cached_crl.is_evicted_by(now, self._cache_validity_time)
         ):
+            logger.debug("Cached CRL is None/expired/evicted, downloading new CRL")
             crl, ts = self._download_crl(crl_url)
-            if crl and ts:
-                self._put_crl_to_cache(crl_url, crl, ts)
+            if crl is not None and ts is not None:
+                # Only cache the downloaded CRL if it's more recent than the cached one
+                is_more_recent = cached_crl is None or self._is_crl_more_recent(
+                    crl, cached_crl.crl
+                )
+                logger.debug(
+                    "Is downloaded CRL more recent? cached_crl is None=%s, is_more_recent=%s",
+                    cached_crl is None,
+                    is_more_recent,
+                )
+                if is_more_recent:
+                    self._put_crl_to_cache(crl_url, crl, ts)
+                    logger.debug("Cached newly downloaded CRL for %s", crl_url)
+                else:
+                    logger.info(
+                        "Downloaded CRL for %s is not more recent than cached version, keeping cached CRL",
+                        crl_url,
+                    )
+                    crl = cached_crl.crl
         else:
             crl = cached_crl.crl
 

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/src/snowflake/connector/crl_cache.py

@@ -6,9 +6,9 @@ import hashlib
 import logging
 import os
 import platform
+import stat
 import threading
 from abc import ABC, abstractmethod
-from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -18,6 +18,8 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import serialization
 from filelock import BaseFileLock, FileLock
 
+from .compat import IS_WINDOWS
+
 logger = logging.getLogger(__name__)
 
 
@@ -201,7 +203,10 @@ class CRLFileCache(CRLCache):
     """
 
     def __init__(
-        self, cache_dir: Path | None = None, removal_delay: timedelta | None = None
+        self,
+        cache_dir: Path | None = None,
+        removal_delay: timedelta | None = None,
+        unsafe_skip_file_permissions_check: bool = False,
     ):
         """
         Initialize the file cache.
@@ -209,6 +214,7 @@ class CRLFileCache(CRLCache):
         Args:
             cache_dir: Directory to store cached CRLs
             removal_delay: How long to wait before removing expired files
+            unsafe_skip_file_permissions_check: Skip file permission validation for security
 
         Raises:
             OSError: If cache directory cannot be created
@@ -216,14 +222,24 @@ class CRLFileCache(CRLCache):
         self._cache_file_lock_timeout = 5.0
         self._cache_dir = cache_dir or _get_default_crl_cache_path()
         self._removal_delay = removal_delay or timedelta(days=7)
+        self._unsafe_skip_file_permissions_check = unsafe_skip_file_permissions_check
 
         self._ensure_cache_directory_exists()
 
     def _ensure_cache_directory_exists(self) -> None:
-        """Create the cache directory if it doesn't exist."""
+        """Create the cache directory if it doesn't exist with secure permissions."""
         try:
-            self._cache_dir.mkdir(parents=True, exist_ok=True)
+            # Create directory with secure permissions (owner read/write/execute only)
+            self._cache_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+
+            # Verify directory permissions (if it already existed)
+            if not self._unsafe_skip_file_permissions_check:
+                self._check_permissions(self._cache_dir, "directory", "0o700")
+
             logger.debug(f"Cache directory created/verified: {self._cache_dir}")
+        except PermissionError:
+            # Re-raise permission errors as-is
+            raise
         except OSError as e:
             raise OSError(f"Failed to create cache directory {self._cache_dir}: {e}")
 
@@ -249,6 +265,44 @@ class CRLFileCache(CRLCache):
             timeout=self._cache_file_lock_timeout,
         )
 
+    def _check_permissions(
+        self, path: Path, resource_type: str, expected_perms: str
+    ) -> None:
+        """
+        Check that a CRL cache resource has secure permissions (owner-only access).
+
+        Note: This check is only performed on Unix-like systems. Windows file
+        permissions work differently and are not checked.
+
+        Args:
+            path: Path to the resource (file or directory) to check
+            resource_type: Description of the resource type (e.g., "file", "directory")
+            expected_perms: Description of expected permissions (e.g., "0o600 or 0o400", "0o700")
+
+        Raises:
+            PermissionError: If resource permissions are too wide
+        """
+        # Skip permission checks on Windows as they work differently
+        if IS_WINDOWS:
+            return
+
+        try:
+            stat_info = path.stat()
+            actual_permissions = stat.S_IMODE(stat_info.st_mode)
+
+            # Check that resource is accessible only by owner (no group/other permissions)
+            if (
+                actual_permissions & 0o077 != 0
+            ):  # Check if group or others have any permission
+                raise PermissionError(
+                    f"CRL cache {resource_type} {path} has insecure permissions: {oct(actual_permissions)}. "
+                    f"{resource_type.capitalize()} must be accessible only by the owner ({expected_perms})."
+                )
+
+        except FileNotFoundError:
+            # Resource doesn't exist yet, this is fine
+            pass
+
     def get(self, crl_url: str) -> CRLCacheEntry | None:
         """
         Get a CRL cache entry from disk.
@@ -265,6 +319,14 @@ class CRLFileCache(CRLCache):
                 if crl_file_path.exists():
                     logger.debug(f"Found CRL on disk for {crl_file_path}")
 
+                    # Check file permissions before reading
+                    if not self._unsafe_skip_file_permissions_check:
+                        self._check_permissions(crl_file_path, "file", "0o600 or 0o400")
+                    else:
+                        logger.warning(
+                            f"Skipping file permissions check for {crl_file_path}"
+                        )
+
                     # Get file modification time as download time
                     stat_info = crl_file_path.stat()
                     download_time = datetime.fromtimestamp(
@@ -278,6 +340,11 @@ class CRLFileCache(CRLCache):
                     crl = x509.load_der_x509_crl(crl_data, backend=default_backend())
                     return CRLCacheEntry(crl, download_time)
 
+            except PermissionError as e:
+                logger.error(
+                    f"Permission error reading CRL from disk cache for {crl_url}: {e}"
+                )
+                return None
             except Exception as e:
                 logger.warning(f"Failed to read CRL from disk cache for {crl_url}: {e}")
 
@@ -297,9 +364,17 @@ class CRLFileCache(CRLCache):
                 # Serialize the CRL to DER format
                 crl_data = entry.crl.public_bytes(serialization.Encoding.DER)
 
-                # Write to file
-                with open(crl_file_path, "wb") as f:
-                    f.write(crl_data)
+                # Write to file with secure permissions (owner read/write only)
+                # Using os.open with 0o600 ensures the file is created with secure permissions
+                flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+                if IS_WINDOWS:
+                    # flag necessary for writing binary data to file on Windows OS
+                    flags |= os.O_BINARY
+                fd = os.open(crl_file_path, flags, 0o600)
+                try:
+                    os.write(fd, crl_data)
+                finally:
+                    os.close(fd)
 
                 # Set file modification time to download time
                 download_timestamp = entry.download_time.timestamp()
@@ -426,7 +501,7 @@ class CRLCacheFactory:
     _instance_lock = threading.RLock()
 
     # Cleanup management
-    _cleanup_executor: ThreadPoolExecutor | None = None
+    _cleanup_thread: threading.Thread | None = None
     _cleanup_shutdown: threading.Event = threading.Event()
     _cleanup_interval: timedelta | None = None
     _atexit_registered: bool = False
@@ -454,7 +529,10 @@ class CRLCacheFactory:
 
     @classmethod
     def get_file_cache(
-        cls, cache_dir: Path | None = None, removal_delay: timedelta | None = None
+        cls,
+        cache_dir: Path | None = None,
+        removal_delay: timedelta | None = None,
+        unsafe_skip_file_permissions_check: bool = False,
     ) -> CRLFileCache:
         """
         Get or create a singleton CRLFileCache instance.
@@ -462,17 +540,23 @@ class CRLCacheFactory:
         Args:
             cache_dir: Directory to store cached CRLs
             removal_delay: How long to wait before removing expired files
+            unsafe_skip_file_permissions_check: Skip file permission validation for security
 
         Returns:
             The singleton CRLFileCache instance
         """
         with cls._instance_lock:
             if cls._file_cache_instance is None:
-                cls._file_cache_instance = CRLFileCache(cache_dir, removal_delay)
+                cls._file_cache_instance = CRLFileCache(
+                    cache_dir, removal_delay, unsafe_skip_file_permissions_check
+                )
             else:
                 # Check if parameters differ from existing instance
                 existing_cache_dir = cls._file_cache_instance._cache_dir
                 existing_removal_delay = cls._file_cache_instance._removal_delay
+                existing_skip_check = (
+                    cls._file_cache_instance._unsafe_skip_file_permissions_check
+                )
                 requested_cache_dir = cache_dir or _get_default_crl_cache_path()
                 requested_removal_delay = removal_delay or timedelta(days=7)
 
@@ -486,6 +570,11 @@ class CRLCacheFactory:
                         f"CRLs file cache has already been initialized with removal delay of {existing_removal_delay}, "
                         f"ignoring new removal delay of {requested_removal_delay}"
                     )
+                if existing_skip_check != unsafe_skip_file_permissions_check:
+                    logger.warning(
+                        f"CRLs file cache has already been initialized with unsafe_skip_file_permissions_check={existing_skip_check}, "
+                        f"ignoring new value {unsafe_skip_file_permissions_check}"
+                    )
             return cls._file_cache_instance
 
     @classmethod
@@ -504,8 +593,10 @@ class CRLCacheFactory:
                 cls.stop_periodic_cleanup()
 
             cls._cleanup_interval = cleanup_interval
-            cls._cleanup_executor = ThreadPoolExecutor(
-                max_workers=1, thread_name_prefix="crl-cache-cleanup"
+            cls._cleanup_thread = threading.Thread(
+                target=cls._cleanup_loop,
+                name="crl-cache-cleanup",
+                daemon=True,  # Make it a daemon thread so it doesn't block program exit
             )
 
             # Register atexit handler for graceful shutdown (only once)
@@ -513,8 +604,8 @@ class CRLCacheFactory:
                 atexit.register(cls._atexit_cleanup_handler)
                 cls._atexit_registered = True
 
-            # Submit the cleanup task
-            cls._cleanup_executor.submit(cls._cleanup_loop)
+            # Start the cleanup thread
+            cls._cleanup_thread.start()
 
             logger.debug(
                 f"Scheduled CRL cache cleanup task to run every {cleanup_interval.total_seconds()} seconds."
@@ -523,29 +614,29 @@ class CRLCacheFactory:
     @classmethod
     def stop_periodic_cleanup(cls) -> None:
         """Stop the periodic cleanup task."""
-        executor_to_shutdown = None
+        thread_to_join = None
 
         with cls._instance_lock:
-            if cls._cleanup_executor is None or cls._cleanup_shutdown.is_set():
+            if cls._cleanup_thread is None or cls._cleanup_shutdown.is_set():
                 return
 
             cls._cleanup_shutdown.set()
-            executor_to_shutdown = cls._cleanup_executor
+            thread_to_join = cls._cleanup_thread
 
-        # Shutdown outside of lock to avoid deadlock
-        if executor_to_shutdown is not None:
-            executor_to_shutdown.shutdown(wait=True)
+        # Join thread outside of lock to avoid deadlock
+        if thread_to_join is not None and thread_to_join.is_alive():
+            thread_to_join.join(timeout=5.0)
 
         with cls._instance_lock:
             cls._cleanup_shutdown.clear()
-            cls._cleanup_executor = None
+            cls._cleanup_thread = None
             cls._cleanup_interval = None
 
     @classmethod
     def is_periodic_cleanup_running(cls) -> bool:
         """Check if periodic cleanup task is running."""
         with cls._instance_lock:
-            return cls._cleanup_executor is not None
+            return cls._cleanup_thread is not None and cls._cleanup_thread.is_alive()
 
     @classmethod
     def _cleanup_loop(cls) -> None:

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/src/snowflake/connector/network.py

@@ -1222,3 +1222,6 @@ class SnowflakeRestful:
 
     def use_session(self, url: str | bytes) -> Generator[Session, Any, None]:
         return self.session_manager.use_session(url)
+
+    def use_requests_session(self, url: str | bytes) -> Generator[Session, Any, None]:
+        return self.use_session(url)

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/src/snowflake/connector/result_batch.py

@@ -360,7 +360,7 @@ class ResultBatch(abc.ABC):
                         and connection.rest.session_manager is not None
                     ):
                         # If connection was explicitly passed and not closed yet - we can reuse SessionManager with session pooling
-                        with connection.rest.use_session(
+                        with connection.rest.use_requests_session(
                             request_data["url"]
                         ) as session:
                             logger.debug(

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/src/snowflake/connector/session_manager.py

@@ -483,26 +483,32 @@ class SessionManager(_RequestVerbsUsingSessionMixin, _HttpConfigDirectAccessMixi
         self._mount_adapters(session)
         return session
 
+    @staticmethod
+    def _normalize_url(url: str | bytes | None) -> str:
+        """Normalize URL to string format (handles bytes from storage client)."""
+        return url.decode("utf-8") if isinstance(url, bytes) else url
+
     @contextlib.contextmanager
     @_propagate_session_manager_to_ocsp
     def use_session(
-        self, url: str | bytes, use_pooling: bool | None = None
+        self, url: str | bytes | None, use_pooling: bool | None = None
     ) -> Generator[Session, Any, None]:
+        """Yield a session for the given URL (used for proxy handling and pooling).
+        The 'url' is an obligatory parameter due to the need for correct proxy handling (i.e. bypassing caused by no_proxy settings).
         """
-        'url' is an obligatory parameter due to the need for correct proxy handling (i.e. bypassing caused by no_proxy settings).
-        """
+        url_str = self._normalize_url(url)
         use_pooling = use_pooling if use_pooling is not None else self.use_pooling
         if not use_pooling:
-            session = self.make_session(url=url)
+            session = self.make_session(url=url_str)
             try:
                 yield session
             finally:
                 session.close()
         else:
-            yield from self._yield_session_from_pool(url)
+            yield from self._yield_session_from_pool(url_str)
 
     def _yield_session_from_pool(
-        self, url: str | bytes
+        self, url: str | None
     ) -> Generator[SessionT, Any, None]:
         hostname = self._get_pooling_key_from_url(url)
         pool = self._sessions_map[hostname]
@@ -635,8 +641,8 @@ class SessionManagerFactory:
         config: HttpConfig | None = None, **http_config_kwargs
     ) -> SessionManager:
         has_param_proxies = (
-            hasattr(config, "proxy_host") or "proxies" in http_config_kwargs
-        )
+            config and config.proxy_host is not None
+        ) or "proxies" in http_config_kwargs
         if has_param_proxies:
             return ProxySessionManager(config, **http_config_kwargs)
         else:

{snowflake_connector_python-4.1.0 → snowflake_connector_python-4.1.1}/src/snowflake/connector/version.py

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