snowflake-sqlalchemy 1.7.7__tar.gz → 1.8.0__tar.gz

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/DESCRIPTION.md

@@ -6,11 +6,19 @@ Snowflake Documentation is available at:
 
 Source code is also available at:
 <https://github.com/snowflakedb/snowflake-sqlalchemy>
+
 # Unreleased Notes
 
 # Release Notes
+
+- v1.8.0(December 5, 2025)
+  - Add logging of SQLAlchemy version
+  - Bump `snowflake-connector-python<5.0.0`
+  - Add python up to 3.14
+  - Add logging of SQLAlchemy version and pandas (if used)
+
 - v1.7.7(September 3, 2025)
-  - Fix exception for structured type columns dropped while collecting meetadata
+  - Fix exception for structured type columns dropped while collecting metadata
 
 - v1.7.6(July 10, 2025)
   - Fix get_multi_indexes issue, wrong assign of returned indexes when processing multiple indexes in a table

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sqlalchemy
-Version: 1.7.7
+Version: 1.8.0
 Summary: Snowflake SQLAlchemy Dialect
 Project-URL: Changelog, https://github.com/snowflakedb/snowflake-sqlalchemy/blob/main/DESCRIPTION.md
 Project-URL: Documentation, https://docs.snowflake.com/en/user-guide/sqlalchemy.html
@@ -27,6 +27,7 @@ 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 :: Python :: 3.13
 Classifier: Programming Language :: SQL
 Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
@@ -35,7 +36,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
-Requires-Dist: snowflake-connector-python<4.0.0
+Requires-Dist: snowflake-connector-python<5.0.0
 Requires-Dist: sqlalchemy>=1.4.19
 Provides-Extra: development
 Requires-Dist: mock; extra == 'development'
@@ -63,9 +64,6 @@ Description-Content-Type: text/markdown
 Snowflake SQLAlchemy runs on the top of the Snowflake Connector for Python as a [dialect](http://docs.sqlalchemy.org/en/latest/dialects/) to bridge a Snowflake database and SQLAlchemy applications.
 
 
-| :exclamation: | Effective May 8th, 2025, Snowflake SQLAlchemy will transition to maintenance mode and will cease active development. Support will be limited to addressing critical bugs and security vulnerabilities. To report such issues, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). for individual evaluation. Please note that pull requests from external contributors may not receive action from Snowflake. |
-|---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-
 
 ## Prerequisites
 

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/README.md

@@ -9,9 +9,6 @@
 Snowflake SQLAlchemy runs on the top of the Snowflake Connector for Python as a [dialect](http://docs.sqlalchemy.org/en/latest/dialects/) to bridge a Snowflake database and SQLAlchemy applications.
 
 
-| :exclamation: | Effective May 8th, 2025, Snowflake SQLAlchemy will transition to maintenance mode and will cease active development. Support will be limited to addressing critical bugs and security vulnerabilities. To report such issues, please [create a case with Snowflake Support](https://community.snowflake.com/s/article/How-To-Submit-a-Support-Case-in-Snowflake-Lodge). for individual evaluation. Please note that pull requests from external contributors may not receive action from Snowflake. |
-|---------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-
 
 ## Prerequisites
 

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/ci/docker/sqlalchemy_build/Dockerfile

@@ -4,9 +4,9 @@ FROM $BASE_IMAGE
 
 # This is to solve permission issue, read https://denibertovic.com/posts/handling-permissions-with-docker-volumes/
 ARG GOSU_URL=https://github.com/tianon/gosu/releases/download/1.14/gosu-amd64
-ENV GOSU_PATH $GOSU_URL
+ENV GOSU_PATH=$GOSU_URL
 RUN curl -o /usr/local/bin/gosu -SL $GOSU_PATH \
-    && chmod +x /usr/local/bin/gosu
+  && chmod +x /usr/local/bin/gosu
 
 COPY scripts/entrypoint.sh /usr/local/bin/entrypoint.sh
 RUN chmod +x /usr/local/bin/entrypoint.sh
@@ -14,6 +14,13 @@ RUN chmod +x /usr/local/bin/entrypoint.sh
 WORKDIR /home/user
 RUN chmod 777 /home/user
 
-ENV PATH="${PATH}:/opt/python/cp37-cp37m/bin:/opt/python/cp38-cp38/bin:/opt/python/cp39-cp39/bin:/opt/python/cp310-cp310/bin:/opt/python/cp311-cp311/bin"
+ENV PATH="${PATH}:/opt/python/cp37-cp37/bin"
+ENV PATH="${PATH}:/opt/python/cp38-cp38/bin"
+ENV PATH="${PATH}:/opt/python/cp39-cp39/bin"
+ENV PATH="${PATH}:/opt/python/cp310-cp310/bin"
+ENV PATH="${PATH}:/opt/python/cp311-cp311/bin"
+ENV PATH="${PATH}:/opt/python/cp312-cp312/bin"
+ENV PATH="${PATH}:/opt/python/cp313-cp313/bin"
+ENV PATH="${PATH}:/opt/python/cp314-cp314/bin"
 
 ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/ci/test_docker.sh

@@ -7,11 +7,11 @@
 set -o pipefail
 
 # In case this is ran from dev-vm
-PYTHON_ENV=${1:-3.7}
+PYTHON_ENV=${1:-3.8}
 
 # Set constants
-THIS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-SQLALCHEMY_DIR="$( dirname "${THIS_DIR}")"
+THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
 WORKSPACE=${WORKSPACE:-$SQLALCHEMY_DIR}
 source $THIS_DIR/set_base_image.sh
 
@@ -35,19 +35,19 @@ echo "[Info] Start building docker image and testing"
 
 user_id=$(id -u ${USER})
 docker run \
-    --rm \
-    --network=host \
-    -e TERM=vt102 \
-    -e PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    -e OPENSSL_FIPS=1 \
-    -e LOCAL_USER_ID=${user_id} \
-    -e AWS_ACCESS_KEY_ID \
-    -e AWS_SECRET_ACCESS_KEY \
-    -e SF_REGRESS_LOGS \
-    -e SF_PROJECT_ROOT \
-    -e cloud_provider \
-    -e JENKINS_HOME \
-    -e GITHUB_ACTIONS \
-    --mount type=bind,source="${SQLALCHEMY_DIR}",target=/home/user/snowflake-sqlalchemy \
-    $(docker build --pull --build-arg BASE_IMAGE=$BASE_IMAGE --build-arg GOSU_URL="$GOSU_URL" -q .) \
-    /home/user/snowflake-sqlalchemy/ci/test_linux.sh ${PYTHON_ENV}
+  --rm \
+  --network=host \
+  -e TERM=vt102 \
+  -e PIP_DISABLE_PIP_VERSION_CHECK=1 \
+  -e OPENSSL_FIPS=1 \
+  -e LOCAL_USER_ID=${user_id} \
+  -e AWS_ACCESS_KEY_ID \
+  -e AWS_SECRET_ACCESS_KEY \
+  -e SF_REGRESS_LOGS \
+  -e SF_PROJECT_ROOT \
+  -e cloud_provider \
+  -e JENKINS_HOME \
+  -e GITHUB_ACTIONS \
+  --mount type=bind,source="${SQLALCHEMY_DIR}",target=/home/user/snowflake-sqlalchemy \
+  $(docker build --pull --build-arg BASE_IMAGE=$BASE_IMAGE --build-arg GOSU_URL="$GOSU_URL" -q .) \
+  /home/user/snowflake-sqlalchemy/ci/test_linux.sh ${PYTHON_ENV}

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/ci/test_linux.sh

@@ -6,7 +6,7 @@
 #   - This script assumes that ../dist/repaired_wheels has the wheel(s) built for all versions to be tested
 #   - This is the script that test_docker.sh runs inside of the docker container
 
-PYTHON_VERSIONS="${1:-3.8 3.9 3.10 3.11}"
+PYTHON_VERSIONS="${1:-3.8 3.9 3.10 3.11 3.12 3.13 3.14}"
 THIS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SQLALCHEMY_DIR="$(dirname "${THIS_DIR}")"
 
@@ -19,7 +19,7 @@ for PYTHON_VERSION in ${PYTHON_VERSIONS}; do
   echo "[Info] Testing with ${PYTHON_VERSION}"
   SHORT_VERSION=$(python3 -c "print('${PYTHON_VERSION}'.replace('.', ''))")
   SQLALCHEMY_WHL=$(ls $SQLALCHEMY_DIR/dist/snowflake_sqlalchemy-*-py3-none-any.whl | sort -r | head -n 1)
-  TEST_ENVLIST=fix_lint,py${SHORT_VERSION}-ci,py${SHORT_VERSION}-coverage
+  TEST_ENVLIST=fix_lint,py${SHORT_VERSION}-ci,py${SHORT_VERSION}-coverage,py${SHORT_VERSION}-pandas-ci,py${SHORT_VERSION}-pandas-coverage
   echo "[Info] Running tox for ${TEST_ENVLIST}"
   python3 -m tox -e ${TEST_ENVLIST} --installpkg ${SQLALCHEMY_WHL}
 done

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/pyproject.toml

@@ -30,6 +30,7 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Programming Language :: SQL",
   "Topic :: Database",
   "Topic :: Scientific/Engineering :: Information Analysis",
@@ -38,7 +39,7 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Application Frameworks",
   "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-dependencies = ["SQLAlchemy>=1.4.19", "snowflake-connector-python<4.0.0"]
+dependencies = ["SQLAlchemy>=1.4.19", "snowflake-connector-python<5.0.0"]
 
 [tool.hatch.version]
 path = "src/snowflake/sqlalchemy/version.py"
@@ -75,17 +76,17 @@ exclude = ["/.github"]
 packages = ["src/snowflake"]
 
 [tool.hatch.envs.default]
-path = ".venv"
-type = "virtual"
 extra-dependencies = ["SQLAlchemy>=1.4.19,<2.1.0"]
 features = ["development", "pandas"]
-python = "3.8"
+python = "3.12"
 installer = "uv"
 
 [tool.hatch.envs.sa14]
-extra-dependencies = ["SQLAlchemy>=1.4.19,<2.0.0"]
+installer = "uv"
+builder = true
+extra-dependencies = ["SQLAlchemy>=1.4.19,<2.0.0", "pandas<2.1", "numpy<2"]
 features = ["development", "pandas"]
-python = "3.8"
+python = "3.12"
 
 [tool.hatch.envs.sa14.scripts]
 test-dialect = "pytest --ignore_v20_test -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
@@ -105,7 +106,7 @@ gh-cache-sum = "python -VV | sha256sum | cut -d' ' -f1"
 check-import = "python -c 'import snowflake.sqlalchemy; print(snowflake.sqlalchemy.__version__)'"
 
 [[tool.hatch.envs.release.matrix]]
-python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
 features = ["development", "pandas"]
 
 [tool.hatch.envs.release.scripts]

snowflake_sqlalchemy-1.8.0/snyk/requirements.txt

@@ -0,0 +1,2 @@
+SQLAlchemy>=1.4.19
+snowflake-connector-python<5.0.0

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/src/snowflake/sqlalchemy/snowdialect.py

@@ -5,10 +5,13 @@ import operator
 from collections import defaultdict
 from enum import Enum
 from functools import reduce
-from typing import Any, Collection, Optional
+from logging import getLogger
+from time import time as time_in_seconds
+from typing import Any, Collection, Optional, cast
 from urllib.parse import unquote_plus
 
 import sqlalchemy.sql.sqltypes as sqltypes
+from sqlalchemy import __version__ as SQLALCHEMY_VERSION
 from sqlalchemy import event as sa_vnt
 from sqlalchemy import exc as sa_exc
 from sqlalchemy import util as sa_util
@@ -19,8 +22,10 @@ from sqlalchemy.sql.sqltypes import NullType
 from sqlalchemy.types import FLOAT, Date, DateTime, Float, Time
 
 from snowflake.connector import errors as sf_errors
-from snowflake.connector.connection import DEFAULT_CONFIGURATION
+from snowflake.connector.connection import DEFAULT_CONFIGURATION, SnowflakeConnection
 from snowflake.connector.constants import UTF8
+from snowflake.connector.network import SnowflakeRestful
+from snowflake.connector.telemetry import TelemetryClient, TelemetryData, TelemetryField
 from snowflake.sqlalchemy.compat import returns_unicode
 from snowflake.sqlalchemy.name_utils import _NameUtils
 from snowflake.sqlalchemy.structured_type_info_manager import _StructuredTypeInfoManager
@@ -59,6 +64,12 @@ colspecs = {
 
 _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME = True
 
+logger = getLogger(__name__)
+
+
+class TelemetryEvents(Enum):
+    NEW_CONNECTION = "sqlalchemy_new_connection"
+
 
 class SnowflakeIsolationLevel(Enum):
     READ_COMMITTED = "READ COMMITTED"
@@ -896,18 +907,53 @@ class SnowflakeDialect(default.DefaultDialect):
         return self._value_or_default(data, table_name, schema)
 
     def connect(self, *cargs, **cparams):
-        return (
-            super().connect(
-                *cargs,
-                **(
-                    _update_connection_application_name(**cparams)
-                    if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME
-                    else cparams
-                ),
+        if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME:
+            cparams = _update_connection_application_name(**cparams)
+
+        connection = super().connect(*cargs, **cparams)
+        self._log_new_connection_event(connection)
+
+        return connection
+
+    def _log_new_connection_event(self, connection):
+        try:
+            snowflake_connection = cast(SnowflakeConnection, cast(object, connection))
+            snowflake_rest_client = SnowflakeRestful(
+                host=snowflake_connection.host,
+                port=snowflake_connection.port,
+                protocol="https",
+                connection=snowflake_connection,
+            )
+            snowflake_telemetry_client = TelemetryClient(rest=snowflake_rest_client)
+
+            telemetry_value = {
+                "SQLAlchemy": SQLALCHEMY_VERSION,
+            }
+            try:
+                from pandas import __version__ as PANDAS_VERSION
+
+                telemetry_value["pandas"] = PANDAS_VERSION
+            except ImportError:
+                pass
+
+            snowflake_telemetry_client.add_log_to_batch(
+                TelemetryData.from_telemetry_data_dict(
+                    from_dict={
+                        TelemetryField.KEY_TYPE.value: TelemetryEvents.NEW_CONNECTION.value,
+                        TelemetryField.KEY_VALUE.value: str(telemetry_value),
+                    },
+                    timestamp=int(time_in_seconds() * 1000),
+                    connection=snowflake_connection,
+                )
+            )
+            snowflake_telemetry_client.send_batch()
+        except Exception as e:
+            logger.debug(
+                "Failed to send telemetry data for %s event: %s: %s",
+                TelemetryEvents.NEW_CONNECTION.value,
+                type(e).__name__,
+                str(e),
             )
-            if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME
-            else super().connect(*cargs, **cparams)
-        )
 
 
 @sa_vnt.listens_for(Table, "before_create")

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/src/snowflake/sqlalchemy/version.py

@@ -3,4 +3,4 @@
 #
 # Update this for the versions
 # Don't change the forth version number from None
-VERSION = "1.7.7"
+VERSION = "1.8.0"

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/tests/conftest.py

@@ -9,6 +9,7 @@ import sys
 import time
 import uuid
 from logging import getLogger
+from typing import Literal
 
 import pytest
 from sqlalchemy import create_engine
@@ -58,7 +59,6 @@ def pytest_addoption(parser):
 
 def pytest_collection_modifyitems(config, items):
     if config.getoption("--ignore_v20_test"):
-        # --ignore_v20_test given in cli: skip sqlalchemy 2.0 tests
         skip_feature_v2 = pytest.mark.skip(
             reason="need remove --ignore_v20_test option to run"
         )
@@ -67,37 +67,11 @@ def pytest_collection_modifyitems(config, items):
                 item.add_marker(skip_feature_v2)
 
 
-@pytest.fixture(scope="session")
-def on_travis():
-    return os.getenv("TRAVIS", "").lower() == "true"
-
-
-@pytest.fixture(scope="session")
-def on_appveyor():
-    return os.getenv("APPVEYOR", "").lower() == "true"
-
-
-@pytest.fixture(scope="session")
-def on_public_ci(on_travis, on_appveyor):
-    return on_travis or on_appveyor
-
-
-def help():
-    print(
-        """Connection parameter must be specified in parameters.py,
-    for example:
-CONNECTION_PARAMETERS = {
-    'account': 'testaccount',
-    'user': 'user1',
-    'password': 'test',
-    'database': 'testdb',
-    'schema': 'public',
-}"""
-    )
-
-
 logger = getLogger(__name__)
 
+TZ_ENV_VAR: Literal["TZ"] = "TZ"
+DEFAULT_TZ_VALUE: Literal["UTC"] = "UTC"
+
 DEFAULT_PARAMETERS = {
     "account": "<account_name>",
     "user": "<user_name>",
@@ -133,6 +107,11 @@ def external_stage():
         raise ValueError("External_stage is not set")
 
 
+@pytest.fixture(scope="session")
+def on_public_ci():
+    return running_on_public_ci()
+
+
 @pytest.fixture(scope="function")
 def base_location(external_stage, engine_testaccount):
     unique_id = str(uuid.uuid4())
@@ -150,9 +129,12 @@ def get_db_parameters() -> dict:
     Sets the db connection parameters
     """
     ret = {}
-    os.environ["TZ"] = "UTC"
-    if not IS_WINDOWS:
-        time.tzset()
+    os.environ[TZ_ENV_VAR] = DEFAULT_TZ_VALUE
+    if hasattr(time, "tzset"):
+        if not IS_WINDOWS:
+            time.tzset()
+    else:
+        logger.warning("time.tzset is unavailable on this platform")
 
     ret.update(DEFAULT_PARAMETERS)
     ret.update(CONNECTION_PARAMETERS)
@@ -318,6 +300,7 @@ def running_on_public_ci() -> bool:
 
 def pytest_runtest_setup(item) -> None:
     """Ran before calling each test, used to decide whether a test should be skipped."""
+    _ensure_optional_dependencies(item)
     test_tags = [mark.name for mark in item.iter_markers()]
 
     # Get what cloud providers the test is marked for if any
@@ -335,3 +318,9 @@ def pytest_runtest_setup(item) -> None:
         pytest.skip("cannot run this test on external CI")
     elif INTERNAL_SKIP_TAGS.intersection(test_tags) and not running_on_public_ci():
         pytest.skip("cannot run this test on internal CI")
+
+
+def _ensure_optional_dependencies(item):
+    """Skip optional-dependency tests when the dependency is unavailable."""
+    if "pandas" in item.keywords:
+        pytest.importorskip("pandas")

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/tests/test_core.py

@@ -171,7 +171,6 @@ def test_connect_args():
 
 
 def test_boolean_query_argument_parsing():
-
     engine = create_engine(
         URL(
             **CONNECTION_PARAMETERS,
@@ -1385,12 +1384,12 @@ def test_special_schema_character(db_parameters, on_public_ci):
     with connect(**options) as sf_conn:
         sf_connection = (
             sf_conn.cursor()
-            .execute("select current_database(), " "current_schema();")
+            .execute("select current_database(), current_schema();")
             .fetchall()
         )
     with create_engine(URL(**options)).connect() as sa_conn:
         sa_connection = sa_conn.execute(
-            text("select current_database(), " "current_schema();")
+            text("select current_database(), current_schema();")
         ).fetchall()
     # Teardown
     with connect(**options) as conn:
@@ -1823,6 +1822,7 @@ CREATE OR REPLACE TEMP TABLE {table_name}
         )
 
 
+@pytest.mark.pandas
 def test_snowflake_sqlalchemy_as_valid_client_type():
     engine = create_engine(
         URL(**CONNECTION_PARAMETERS),

snowflake_sqlalchemy-1.8.0/tests/test_dialect_connect.py

@@ -0,0 +1,124 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+#
+
+from sys import modules
+from types import SimpleNamespace
+from unittest import mock
+
+import pytest
+from sqlalchemy import __version__ as SQLALCHEMY_VERSION
+from sqlalchemy.engine import default as sqla_default
+
+from snowflake.sqlalchemy.snowdialect import (
+    SnowflakeDialect,
+    TelemetryEvents,
+    TelemetryField,
+)
+
+
+@pytest.fixture
+def fake_connection():
+    return SimpleNamespace(
+        host="example.snowflakecomputing.com",
+        port=443,
+        application="test_app",
+    )
+
+
+@mock.patch.object(sqla_default.DefaultDialect, "connect")
+@mock.patch("snowflake.sqlalchemy.snowdialect.TelemetryClient")
+@mock.patch("snowflake.sqlalchemy.snowdialect.SnowflakeRestful")
+def test_connect_sends_telemetry(
+    mock_restful, mock_telemetry_client, mock_connect, fake_connection
+):
+    """Ensure telemetry is sent with the expected payload on connect."""
+    mock_connect.return_value = fake_connection
+
+    # Mock out pandas to ensure deterministic behavior
+    with mock.patch.dict(modules, {"pandas": None}):
+        dialect = SnowflakeDialect()
+        result = dialect.connect()
+
+    assert result is fake_connection
+
+    # Verify add_log_to_batch was called with correct payload
+    telemetry_instance = mock_telemetry_client.return_value
+    payload = telemetry_instance.add_log_to_batch.call_args[0][0]
+    assert (
+        payload.message[TelemetryField.KEY_TYPE.value]
+        == TelemetryEvents.NEW_CONNECTION.value
+    )
+    assert payload.message[TelemetryField.KEY_VALUE.value] == str(
+        {"SQLAlchemy": SQLALCHEMY_VERSION}
+    )
+    assert payload.timestamp != 0
+
+    # Verify send_batch was called
+    telemetry_instance.send_batch.assert_called_once()
+
+
+@mock.patch.object(sqla_default.DefaultDialect, "connect")
+@mock.patch("snowflake.sqlalchemy.snowdialect.TelemetryClient")
+@mock.patch("snowflake.sqlalchemy.snowdialect.SnowflakeRestful")
+def test_connect_telemetry_includes_pandas_when_available(
+    mock_restful, mock_telemetry_client, mock_connect, fake_connection
+):
+    """Ensure telemetry includes pandas version when pandas is installed."""
+    mock_connect.return_value = fake_connection
+
+    # Create a mock pandas module with a version
+    mock_pandas = mock.MagicMock()
+    mock_pandas.__version__ = "2.1.0"
+
+    with mock.patch.dict(modules, {"pandas": mock_pandas}):
+        dialect = SnowflakeDialect()
+        dialect.connect()
+
+    telemetry_instance = mock_telemetry_client.return_value
+    payload = telemetry_instance.add_log_to_batch.call_args[0][0]
+    telemetry_value = payload.message[TelemetryField.KEY_VALUE.value]
+
+    assert telemetry_value == str({"SQLAlchemy": SQLALCHEMY_VERSION, "pandas": "2.1.0"})
+
+
+@mock.patch.object(sqla_default.DefaultDialect, "connect")
+@mock.patch("snowflake.sqlalchemy.snowdialect.TelemetryClient")
+@mock.patch("snowflake.sqlalchemy.snowdialect.SnowflakeRestful")
+def test_connect_telemetry_excludes_pandas_when_not_available(
+    mock_restful, mock_telemetry_client, mock_connect, fake_connection
+):
+    """Ensure telemetry does not include pandas when it is not installed."""
+    mock_connect.return_value = fake_connection
+
+    # Simulate pandas not being installed
+    with mock.patch.dict(modules, {"pandas": None}):
+        dialect = SnowflakeDialect()
+        dialect.connect()
+
+    telemetry_instance = mock_telemetry_client.return_value
+    payload = telemetry_instance.add_log_to_batch.call_args[0][0]
+    telemetry_value = payload.message[TelemetryField.KEY_VALUE.value]
+
+    assert telemetry_value == str({"SQLAlchemy": SQLALCHEMY_VERSION})
+
+
+@mock.patch.object(sqla_default.DefaultDialect, "connect")
+@mock.patch("snowflake.sqlalchemy.snowdialect.TelemetryClient")
+@mock.patch("snowflake.sqlalchemy.snowdialect.SnowflakeRestful")
+def test_connect_logs_when_telemetry_fails(
+    mock_restful, mock_telemetry_client, mock_connect, caplog, fake_connection
+):
+    """Ensure failures in telemetry do not break connect and are logged."""
+    mock_connect.return_value = fake_connection
+    mock_telemetry_client.side_effect = RuntimeError("boom")
+
+    caplog.set_level("DEBUG", logger="snowflake.sqlalchemy.snowdialect")
+
+    dialect = SnowflakeDialect()
+    result = dialect.connect()
+
+    assert result is fake_connection
+    assert any(
+        "Failed to send telemetry data" in message for message in caplog.messages
+    )

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/tests/test_pandas.py

@@ -10,8 +10,10 @@ import textwrap
 import uuid
 
 import numpy as np
-import pandas as pd
 import pytest
+
+pytest.importorskip("pandas")
+import pandas as pd
 import sqlalchemy
 from sqlalchemy import (
     Column,

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/tests/test_qmark.py

@@ -5,8 +5,10 @@
 import os
 import sys
 
-import pandas as pd
 import pytest
+
+pytest.importorskip("pandas")
+import pandas as pd
 from sqlalchemy import text
 
 THIS_DIR = os.path.dirname(os.path.realpath(__file__))

{snowflake_sqlalchemy-1.7.7 → snowflake_sqlalchemy-1.8.0}/tox.ini

@@ -1,7 +1,7 @@
 [tox]
 min_version = 4.0.0
 envlist = fix_lint,
-          py{37,38,39,310,311}{,-pandas},
+          py{38,39,310,311,312,313,314}{,-pandas},
           coverage,
 skip_missing_interpreters = true
 
@@ -10,14 +10,17 @@ package = external
 description = run the tests with pytest under {basepython}
 extras =
     development
-    pandas
+    pandas: pandas
 external_wheels =
-    py37-ci: dist/*.whl
     py38-ci: dist/*.whl
     py39-ci: dist/.whl
     py310-ci: dist/.whl
     py311-ci: dist/.whl
+    py312-ci: dist/.whl
+    py313-ci: dist/.whl
+    py314-ci: dist/.whl
 deps = pip
+  pytest-xdist
 passenv =
     AWS_ACCESS_KEY_ID
     AWS_SECRET_ACCESS_KEY
@@ -32,6 +35,7 @@ passenv =
     USERNAME
     PYTEST_ADDOPTS
 setenv =
+    PIP_ONLY_BINARY=pyarrow
     COVERAGE_FILE = {env:COVERAGE_FILE:{toxworkdir}/.coverage.{envname}}
     SQLALCHEMY_WARN_20 = 1
     ci: SNOWFLAKE_PYTEST_OPTS = -vvv --tb=long
@@ -40,10 +44,12 @@ commands = pytest \
            --cov "snowflake.sqlalchemy" \
            --junitxml {toxworkdir}/junit_{envname}.xml \
            --ignore=tests/sqlalchemy_test_suite \
+           -n8 \
            {posargs:tests}
            pytest {env:SNOWFLAKE_PYTEST_OPTS:} \
            --cov "snowflake.sqlalchemy" --cov-append \
            --junitxml {toxworkdir}/junit_{envname}.xml \
+           -n8 \
            {posargs:tests/sqlalchemy_test_suite}
 
 [testenv:.pkg_external]
@@ -66,7 +72,7 @@ commands = coverage combine
            coverage xml -o {toxworkdir}/coverage.xml
            coverage html -d {toxworkdir}/htmlcov
            ;diff-cover --compare-branch {env:DIFF_AGAINST:origin/main} {toxworkdir}/coverage.xml
-depends = py37, py38, py39, py310, py311
+depends = py38, py39, py310, py311, py312, py313, py314
 
 [testenv:fix_lint]
 description = format the code base to adhere to our styles, and complain about what we cannot do automatically

snowflake_sqlalchemy-1.7.7/snyk/requirements.txt

@@ -1,2 +0,0 @@
-SQLAlchemy>=1.4.19
-snowflake-connector-python<4.0.0