dagster-snowflake 0.27.1__tar.gz → 0.27.2__tar.gz

{dagster_snowflake-0.27.1/dagster_snowflake.egg-info → dagster_snowflake-0.27.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster-snowflake
-Version: 0.27.1
+Version: 0.27.2
 Summary: Package for Snowflake Dagster framework components.
 Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-snowflake
 Author: Dagster Labs
@@ -10,11 +10,12 @@ 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: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.9,<=3.13.3
 License-File: LICENSE
-Requires-Dist: dagster==1.11.1
+Requires-Dist: dagster==1.11.2
 Requires-Dist: snowflake-connector-python>=3.4.0
 Requires-Dist: pyOpenSSL>=22.1.0
 Provides-Extra: snowflake-sqlalchemy

{dagster_snowflake-0.27.1 → dagster_snowflake-0.27.2}/dagster_snowflake/resources.py

@@ -281,9 +281,9 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
 
     @validator("connector")
     def validate_connector(cls, v: Optional[str]) -> Optional[str]:
-        if v is not None and v != "sqlalchemy":
+        if v is not None and v not in ["sqlalchemy", "adbc"]:
             raise ValueError(
-                "Snowflake Resource: 'connector' configuration value must be None or sqlalchemy."
+                "Snowflake Resource: 'connector' configuration value must be None, sqlalchemy or adbc."
             )
         return v
 
@@ -391,6 +391,81 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
 
         return sqlalchemy_engine_args
 
+    @property
+    @cached_method
+    def _adbc_connection_args(self) -> Mapping[str, Any]:
+        config = self._resolved_config_dict
+        adbc_engine_args = {}
+
+        if config.get("account"):
+            adbc_engine_args["adbc.snowflake.sql.account"] = config["account"]
+        if config.get("user"):
+            adbc_engine_args["username"] = config["user"]
+        if config.get("password"):
+            adbc_engine_args["password"] = config["password"]
+        if config.get("database"):
+            adbc_engine_args["adbc.snowflake.sql.db"] = config["database"]
+        if config.get("schema"):
+            adbc_engine_args["adbc.snowflake.sql.schema"] = config["schema"]
+        if config.get("role"):
+            adbc_engine_args["adbc.snowflake.sql.role"] = config["role"]
+        if config.get("warehouse"):
+            adbc_engine_args["adbc.snowflake.sql.warehouse"] = config["warehouse"]
+
+        if config.get("authenticator"):
+            auth_mapping = {
+                "snowflake": "auth_snowflake",
+                "oauth": "auth_oauth",
+                "externalbrowser": "auth_ext_browser",
+                "okta": "auth_okta",
+                "jwt": "auth_jwt",
+                "snowflake_jwt": "auth_jwt",
+            }
+            auth_type = auth_mapping.get(config["authenticator"].lower(), config["authenticator"])
+            adbc_engine_args["adbc.snowflake.sql.auth_type"] = auth_type
+
+        if config.get("private_key") or config.get("private_key_path"):
+            # ADBC expects the raw private key value as bytes for jwt_private_key_pkcs8_value
+            adbc_engine_args["adbc.snowflake.sql.auth_type"] = "auth_jwt"
+            if config.get("private_key"):
+                adbc_engine_args["adbc.snowflake.sql.client_option.jwt_private_key_pkcs8_value"] = (
+                    config["private_key"]
+                )
+            elif config.get("private_key_path"):
+                adbc_engine_args["adbc.snowflake.sql.client_option.jwt_private_key"] = config[
+                    "private_key_path"
+                ]
+
+            if config.get("private_key_password"):
+                adbc_engine_args[
+                    "adbc.snowflake.sql.client_option.jwt_private_key_pkcs8_password"
+                ] = config["private_key_password"]
+
+        if config.get("login_timeout"):
+            adbc_engine_args["adbc.snowflake.sql.client_option.login_timeout"] = (
+                f"{config['login_timeout']}s"
+            )
+        if config.get("network_timeout"):
+            adbc_engine_args["adbc.snowflake.sql.client_option.request_timeout"] = (
+                f"{config['network_timeout']}s"
+            )
+        if config.get("client_session_keep_alive") is not None:
+            adbc_engine_args["adbc.snowflake.sql.client_option.keep_session_alive"] = str(
+                config["client_session_keep_alive"]
+            ).lower()
+
+        adbc_engine_args["adbc.snowflake.sql.client_option.app_name"] = (
+            SNOWFLAKE_PARTNER_CONNECTION_IDENTIFIER
+        )
+
+        if config.get("additional_snowflake_connection_args"):
+            for key, value in config["additional_snowflake_connection_args"].items():
+                # Allow direct ADBC option names to be passed through
+                if key.startswith("adbc.snowflake."):
+                    adbc_engine_args[key] = value  # noqa: PERF403
+
+        return adbc_engine_args
+
     def _snowflake_private_key(self, config) -> bytes:
         # If the user has defined a path to a private key, we will use that.
         if config.get("private_key_path", None) is not None:
@@ -476,6 +551,15 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
             yield conn
             conn.close()
             engine.dispose()
+        elif self.connector == "adbc":
+            import adbc_driver_snowflake.dbapi
+
+            conn = adbc_driver_snowflake.dbapi.connect(
+                db_kwargs=self._adbc_connection_args,  # pyright: ignore[reportArgumentType]
+            )
+
+            yield conn
+            conn.close()
         else:
             conn = snowflake.connector.connect(**self._connection_args)
 

{dagster_snowflake-0.27.1 → dagster_snowflake-0.27.2}/dagster_snowflake/snowflake_io_manager.py

@@ -15,7 +15,6 @@ from dagster._core.storage.db_io_manager import (
 )
 from dagster._core.storage.io_manager import dagster_maintained_io_manager
 from pydantic import Field
-from snowflake.connector.errors import ProgrammingError
 
 from dagster_snowflake.resources import SnowflakeResource
 
@@ -364,20 +363,22 @@ class SnowflakeDbClient(DbClient):
 
     @staticmethod
     def ensure_schema_exists(context: OutputContext, table_slice: TableSlice, connection) -> None:
-        schemas = (
-            connection.cursor()
-            .execute(f"show schemas like '{table_slice.schema}' in database {table_slice.database}")
-            .fetchall()
-        )
+        with connection.cursor() as cursor:
+            cursor.execute(
+                f"show schemas like '{table_slice.schema}' in database {table_slice.database}"
+            )
+            schemas = cursor.fetchall()
+
         if len(schemas) == 0:
-            connection.cursor().execute(f"create schema {table_slice.schema};")
+            with connection.cursor() as cursor:
+                cursor.execute(f"create schema {table_slice.schema};")
 
     @staticmethod
     def delete_table_slice(context: OutputContext, table_slice: TableSlice, connection) -> None:
         try:
             connection.cursor().execute(_get_cleanup_statement(table_slice))
-        except ProgrammingError as e:
-            if "does not exist" in e.msg:  # type: ignore
+        except Exception as e:
+            if "does not exist or not authorized" in str(e):
                 # table doesn't exist yet, so ignore the error
                 return
             else:

dagster_snowflake-0.27.2/dagster_snowflake/version.py

@@ -0,0 +1 @@
+__version__ = "0.27.2"

{dagster_snowflake-0.27.1 → dagster_snowflake-0.27.2/dagster_snowflake.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster-snowflake
-Version: 0.27.1
+Version: 0.27.2
 Summary: Package for Snowflake Dagster framework components.
 Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-snowflake
 Author: Dagster Labs
@@ -10,11 +10,12 @@ 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: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.9,<=3.13.3
 License-File: LICENSE
-Requires-Dist: dagster==1.11.1
+Requires-Dist: dagster==1.11.2
 Requires-Dist: snowflake-connector-python>=3.4.0
 Requires-Dist: pyOpenSSL>=22.1.0
 Provides-Extra: snowflake-sqlalchemy

{dagster_snowflake-0.27.1 → dagster_snowflake-0.27.2}/dagster_snowflake.egg-info/requires.txt

@@ -1,4 +1,4 @@
-dagster==1.11.1
+dagster==1.11.2
 snowflake-connector-python>=3.4.0
 pyOpenSSL>=22.1.0
 

{dagster_snowflake-0.27.1 → dagster_snowflake-0.27.2}/setup.py

@@ -27,14 +27,15 @@ setup(
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
         "License :: OSI Approved :: Apache Software License",
         "Operating System :: OS Independent",
     ],
     packages=find_packages(exclude=["dagster_snowflake_tests*"]),
     include_package_data=True,
-    python_requires=">=3.9,<3.13",
+    python_requires=">=3.9,<=3.13.3",
     install_requires=[
-        "dagster==1.11.1",
+        "dagster==1.11.2",
         "snowflake-connector-python>=3.4.0",
         # Workaround for incorrect pin in the snowflake-connector-python package
         # See https://github.com/snowflakedb/snowflake-connector-python/issues/2109

dagster_snowflake-0.27.1/dagster_snowflake/version.py

@@ -1 +0,0 @@
-__version__ = "0.27.1"