dagster-snowflake 0.24.2__py3-none-any.whl → 0.28.1__py3-none-any.whl

dagster_snowflake/__init__.py

@@ -1,16 +1,19 @@
-from dagster._core.libraries import DagsterLibraryRegistry
+from dagster_shared.libraries import DagsterLibraryRegistry
 
-from .ops import snowflake_op_for_query as snowflake_op_for_query
-from .resources import (
+from dagster_snowflake.components import (
+    SnowflakeConnectionComponent as SnowflakeConnectionComponent,
+)
+from dagster_snowflake.ops import snowflake_op_for_query as snowflake_op_for_query
+from dagster_snowflake.resources import (
     SnowflakeConnection as SnowflakeConnection,
     SnowflakeResource as SnowflakeResource,
     fetch_last_updated_timestamps as fetch_last_updated_timestamps,
     snowflake_resource as snowflake_resource,
 )
-from .snowflake_io_manager import (
+from dagster_snowflake.snowflake_io_manager import (
     SnowflakeIOManager as SnowflakeIOManager,
     build_snowflake_io_manager as build_snowflake_io_manager,
 )
-from .version import __version__
+from dagster_snowflake.version import __version__
 
 DagsterLibraryRegistry.register("dagster-snowflake", __version__)

dagster_snowflake/components/__init__.py

@@ -0,0 +1,5 @@
+from dagster_snowflake.components.sql_component.component import SnowflakeConnectionComponent
+
+__all__ = [
+    "SnowflakeConnectionComponent",
+]

dagster_snowflake/components/sql_component/component.py

@@ -0,0 +1,61 @@
+from functools import cached_property
+from typing import Any, cast
+
+import dagster as dg
+from dagster._annotations import preview, public
+from dagster._core.definitions.definitions_class import Definitions
+from dagster.components.core.context import ComponentLoadContext
+from dagster.components.lib.sql_component.sql_client import SQLClient
+from pydantic import BaseModel, create_model
+
+from dagster_snowflake.resources import SnowflakeResource
+
+
+@public
+@preview
+class SnowflakeConnectionComponentBase(dg.Component, dg.Resolvable, dg.Model, SQLClient):
+    """A component that represents a Snowflake connection. Use this component if you are
+    also using the TemplatedSqlComponent to execute SQL queries, and need to connect to Snowflake.
+    """
+
+    @cached_property
+    def _snowflake_resource(self) -> SnowflakeResource:
+        return SnowflakeResource(
+            **{
+                (field.alias or field_name): getattr(self, field_name)
+                for field_name, field in self.__class__.model_fields.items()
+            }
+        )
+
+    def connect_and_execute(self, sql: str) -> None:
+        """Connect to the SQL database and execute the SQL query."""
+        return self._snowflake_resource.connect_and_execute(sql)
+
+    def build_defs(self, context: ComponentLoadContext) -> Definitions:
+        return Definitions()
+
+
+def _copy_fields_to_model(
+    copy_from: type[BaseModel], copy_to: type[BaseModel], new_model_cls_name: str
+) -> None:
+    """Given two models, creates a copy of the second model with the fields of the first model."""
+    field_definitions: dict[str, tuple[type, Any]] = {
+        field_name: (cast("type", field.annotation), field)
+        for field_name, field in copy_from.model_fields.items()
+    }
+
+    return create_model(
+        new_model_cls_name,
+        __base__=copy_to,
+        __doc__=copy_to.__doc__,
+        **field_definitions,  # type: ignore
+    )
+
+
+SnowflakeConnectionComponent = public(preview)(
+    _copy_fields_to_model(
+        copy_from=SnowflakeResource,
+        copy_to=SnowflakeConnectionComponentBase,
+        new_model_cls_name="SnowflakeConnectionComponent",
+    )
+)

dagster_snowflake/resources.py

@@ -1,9 +1,10 @@
 import base64
 import sys
 import warnings
+from collections.abc import Iterator, Mapping, Sequence
 from contextlib import closing, contextmanager
 from datetime import datetime
-from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Union
+from typing import Any, Optional, Union
 
 import dagster._check as check
 from cryptography.hazmat.backends import default_backend
@@ -17,11 +18,11 @@ from dagster import (
 from dagster._annotations import public
 from dagster._core.definitions.resource_definition import dagster_maintained_resource
 from dagster._core.storage.event_log.sql_event_log import SqlDbConnection
-from dagster._model.pydantic_compat_layer import compat_model_validator
 from dagster._utils.cached_method import cached_method
-from pydantic import Field, validator
+from dagster.components.lib.sql_component.sql_client import SQLClient
+from pydantic import Field, model_validator, validator
 
-from .constants import (
+from dagster_snowflake.constants import (
     SNOWFLAKE_PARTNER_CONNECTION_IDENTIFIER,
     SNOWFLAKE_PARTNER_CONNECTION_IDENTIFIER_SQLALCHEMY,
 )
@@ -40,7 +41,7 @@ except ImportError:
     raise
 
 
-class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext):
+class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext, SQLClient):
     """A resource for connecting to the Snowflake data warehouse.
 
     If connector configuration is not set, SnowflakeResource.get_connection() will return a
@@ -132,8 +133,8 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
             "Raw private key to use. See the `Snowflake documentation"
             " <https://docs.snowflake.com/en/user-guide/key-pair-auth.html>`__ for details."
             " Alternately, set private_key_path and private_key_password. To avoid issues with"
-            " newlines in the keys, you can base64 encode the key. You can retrieve the base64"
-            " encoded key with this shell command: ``cat rsa_key.p8 | base64``"
+            " newlines in the keys, you can optionally base64 encode the key. You can retrieve"
+            " the base64 encoded key with this shell command: ``cat rsa_key.p8 | base64``"
         ),
     )
 
@@ -235,7 +236,7 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
             "Indicate alternative database connection engine. Permissible option is "
             "'sqlalchemy' otherwise defaults to use the Snowflake Connector for Python."
         ),
-        is_required=False,
+        is_required=False,  # type: ignore
     )
 
     cache_column_metadata: Optional[str] = Field(
@@ -259,6 +260,15 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
         default=None,
         description="Optional parameter to specify the authentication mechanism to use.",
     )
+    additional_snowflake_connection_args: Optional[dict[str, Any]] = Field(
+        default=None,
+        description=(
+            "Additional keyword arguments to pass to the snowflake.connector.connect function. For a full list of"
+            " available arguments, see the `Snowflake documentation"
+            " <https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect>`__."
+            " This config will be ignored if using the sqlalchemy connector."
+        ),
+    )
 
     @validator("paramstyle")
     def validate_paramstyle(cls, v: Optional[str]) -> Optional[str]:
@@ -272,13 +282,13 @@ 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
 
-    @compat_model_validator(mode="before")
+    @model_validator(mode="before")
     def validate_authentication(cls, values):
         auths_set = 0
         auths_set += 1 if values.get("password") is not None else 0
@@ -339,12 +349,15 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
             conn_args["private_key"] = self._snowflake_private_key(self._resolved_config_dict)
 
         conn_args["application"] = SNOWFLAKE_PARTNER_CONNECTION_IDENTIFIER
+
+        if self._resolved_config_dict.get("additional_snowflake_connection_args") is not None:
+            conn_args.update(self._resolved_config_dict["additional_snowflake_connection_args"])
         return conn_args
 
     @property
     @cached_method
     def _sqlalchemy_connection_args(self) -> Mapping[str, Any]:
-        conn_args: Dict[str, Any] = {
+        conn_args: dict[str, Any] = {
             k: self._resolved_config_dict.get(k)
             for k in (
                 "account",
@@ -379,6 +392,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:
@@ -386,7 +474,7 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
             with open(config.get("private_key_path"), "rb") as key:
                 private_key = key.read()
         else:
-            private_key = config.get("private_key", None)
+            private_key = config.get("private_key", None).encode()
 
         kwargs = {}
         if config.get("private_key_password", None) is not None:
@@ -398,7 +486,9 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
             p_key = serialization.load_pem_private_key(
                 private_key, backend=default_backend(), **kwargs
             )
-        except TypeError:
+
+        # key fails to load, possibly indicating key is base64 encoded
+        except ValueError:
             try:
                 private_key = base64.b64decode(private_key)
                 p_key = serialization.load_pem_private_key(
@@ -462,6 +552,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)
 
@@ -479,6 +578,10 @@ class SnowflakeResource(ConfigurableResource, IAttachDifferentObjectToOpContext)
             snowflake_connection_resource=self,
         )
 
+    def connect_and_execute(self, sql: str) -> None:
+        with self.get_connection() as conn:
+            conn.cursor().execute(sql)
+
 
 class SnowflakeConnection:
     """A connection to Snowflake that can execute queries. In general this class should not be
@@ -567,9 +670,6 @@ class SnowflakeConnection:
 
         with self.get_connection() as conn:
             with closing(conn.cursor()) as cursor:
-                if sys.version_info[0] < 3:
-                    sql = sql.encode("utf-8")
-
                 self.log.info("Executing query: " + sql)
                 parameters = dict(parameters) if isinstance(parameters, Mapping) else parameters
                 cursor.execute(sql, parameters)
@@ -620,7 +720,7 @@ class SnowflakeConnection:
         if not fetch_results and use_pandas_result:
             check.failed("If use_pandas_result is True, fetch_results must also be True.")
 
-        results: List[Any] = []
+        results: list[Any] = []
         with self.get_connection() as conn:
             with closing(conn.cursor()) as cursor:
                 for raw_sql in sql_queries:
@@ -729,6 +829,7 @@ def fetch_last_updated_timestamps(
     schema: str,
     tables: Sequence[str],
     database: Optional[str] = None,
+    ignore_missing_tables: Optional[bool] = False,
 ) -> Mapping[str, datetime]:
     """Fetch the last updated times of a list of tables in Snowflake.
 
@@ -742,6 +843,8 @@ def fetch_last_updated_timestamps(
         tables (Sequence[str]): A list of table names to fetch the last updated time for.
         database (Optional[str]): The database of the table. Only required if the connection
             has not been set with a database.
+        ignore_missing_tables (Optional[bool]): If True, tables not found in Snowflake
+            will be excluded from the result.
 
     Returns:
         Mapping[str, datetime]: A dictionary of table names to their last updated time in UTC.
@@ -755,7 +858,7 @@ def fetch_last_updated_timestamps(
     )
 
     query = f"""
-    SELECT table_name, CONVERT_TIMEZONE('UTC', last_altered) AS last_altered 
+    SELECT table_name, CONVERT_TIMEZONE('UTC', last_altered) AS last_altered
     FROM {fully_qualified_table_name}
     WHERE table_schema = '{schema}' AND table_name IN ({tables_str});
     """
@@ -767,6 +870,8 @@ def fetch_last_updated_timestamps(
     result_correct_case = {}
     for table_name in tables:
         if table_name.upper() not in result_mapping:
+            if ignore_missing_tables:
+                continue
             raise ValueError(f"Table {table_name} could not be found.")
         last_altered = result_mapping[table_name.upper()]
         check.invariant(

dagster_snowflake/snowflake_io_manager.py

@@ -1,10 +1,11 @@
 from abc import abstractmethod
+from collections.abc import Sequence
 from contextlib import contextmanager
-from typing import Optional, Sequence, Type, cast
+from typing import Any, Optional, cast
 
 from dagster import IOManagerDefinition, OutputContext, io_manager
 from dagster._config.pythonic_config import ConfigurableIOManagerFactory
-from dagster._core.definitions.time_window_partitions import TimeWindow
+from dagster._core.definitions.partitions.utils import TimeWindow
 from dagster._core.storage.db_io_manager import (
     DbClient,
     DbIOManager,
@@ -14,22 +15,21 @@ 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 .resources import SnowflakeResource
+from dagster_snowflake.resources import SnowflakeResource
 
 SNOWFLAKE_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
 
 
 def build_snowflake_io_manager(
-    type_handlers: Sequence[DbTypeHandler], default_load_type: Optional[Type] = None
+    type_handlers: Sequence[DbTypeHandler], default_load_type: Optional[type] = None
 ) -> IOManagerDefinition:
     """Builds an IO manager definition that reads inputs from and writes outputs to Snowflake.
 
     Args:
         type_handlers (Sequence[DbTypeHandler]): Each handler defines how to translate between
             slices of Snowflake tables and an in-memory type - e.g. a Pandas DataFrame. If only
-            one DbTypeHandler is provided, it will be used as teh default_load_type.
+            one DbTypeHandler is provided, it will be used as the default_load_type.
         default_load_type (Type): When an input has no type annotation, load it as this type.
 
     Returns:
@@ -58,7 +58,7 @@ def build_snowflake_io_manager(
 
             snowflake_io_manager = build_snowflake_io_manager([SnowflakePandasTypeHandler(), SnowflakePySparkTypeHandler()])
 
-            defs = Definitions(
+            Definitions(
                 assets=[my_table, my_second_table],
                 resources={
                     "io_manager": snowflake_io_manager.configured({
@@ -74,7 +74,7 @@ def build_snowflake_io_manager(
 
         .. code-block:: python
 
-            defs = Definitions(
+            Definitions(
                 assets=[my_table]
                 resources={"io_manager" snowflake_io_manager.configured(
                     {"database": "my_database", "schema": "my_schema", ...} # will be used as the schema
@@ -279,6 +279,15 @@ class SnowflakeIOManager(ConfigurableIOManagerFactory):
         default=None,
         description="Optional parameter to specify the authentication mechanism to use.",
     )
+    additional_snowflake_connection_args: Optional[dict[str, Any]] = Field(
+        default=None,
+        description=(
+            "Additional keyword arguments to pass to the snowflake.connector.connect function. For a full list of"
+            " available arguments, see the `Snowflake documentation"
+            " <https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect>`__."
+            " This config will be ignored if using the sqlalchemy connector."
+        ),
+    )
 
     @staticmethod
     @abstractmethod
@@ -300,7 +309,7 @@ class SnowflakeIOManager(ConfigurableIOManagerFactory):
         ...
 
     @staticmethod
-    def default_load_type() -> Optional[Type]:
+    def default_load_type() -> Optional[type]:
         """If an asset or op is not annotated with an return type, default_load_type will be used to
         determine which TypeHandler to use to store and load the output.
 
@@ -347,27 +356,29 @@ class SnowflakeDbClient(DbClient):
             if context.resource_config
             else {}
         )
-        with SnowflakeResource(schema=table_slice.schema, **no_schema_config).get_connection(
+        with SnowflakeResource(schema=table_slice.schema, **no_schema_config).get_connection(  # pyright: ignore[reportArgumentType]
             raw_conn=False
         ) as conn:
             yield conn
 
     @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:
@@ -376,7 +387,7 @@ class SnowflakeDbClient(DbClient):
     @staticmethod
     def get_select_statement(table_slice: TableSlice) -> str:
         col_str = ", ".join(table_slice.columns) if table_slice.columns else "*"
-        if table_slice.partition_dimensions and len(table_slice.partition_dimensions) > 0:
+        if table_slice.partition_dimensions:
             query = (
                 f"SELECT {col_str} FROM"
                 f" {table_slice.database}.{table_slice.schema}.{table_slice.table} WHERE\n"
@@ -390,7 +401,7 @@ def _get_cleanup_statement(table_slice: TableSlice) -> str:
     """Returns a SQL statement that deletes data in the given table to make way for the output data
     being written.
     """
-    if table_slice.partition_dimensions and len(table_slice.partition_dimensions) > 0:
+    if table_slice.partition_dimensions:
         query = (
             f"DELETE FROM {table_slice.database}.{table_slice.schema}.{table_slice.table} WHERE\n"
         )
@@ -411,7 +422,7 @@ def _partition_where_clause(partition_dimensions: Sequence[TablePartitionDimensi
 
 
 def _time_window_where_clause(table_partition: TablePartitionDimension) -> str:
-    partition = cast(TimeWindow, table_partition.partitions)
+    partition = cast("TimeWindow", table_partition.partitions)
     start_dt, end_dt = partition
     start_dt_str = start_dt.strftime(SNOWFLAKE_DATETIME_FORMAT)
     end_dt_str = end_dt.strftime(SNOWFLAKE_DATETIME_FORMAT)

dagster_snowflake/version.py

@@ -1 +1 @@
-__version__ = "0.24.2"
+__version__ = "0.28.1"

dagster_snowflake-0.28.1.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: dagster-snowflake
+Version: 0.28.1
+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
+Author-email: hello@dagsterlabs.com
+License: Apache-2.0
+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.14
+License-File: LICENSE
+Requires-Dist: dagster==1.12.1
+Requires-Dist: snowflake-connector-python>=3.4.0
+Requires-Dist: pyOpenSSL>=22.1.0
+Provides-Extra: snowflake-sqlalchemy
+Requires-Dist: sqlalchemy!=1.4.42; extra == "snowflake-sqlalchemy"
+Requires-Dist: snowflake-sqlalchemy; extra == "snowflake-sqlalchemy"
+Provides-Extra: pandas
+Requires-Dist: pandas; extra == "pandas"
+Requires-Dist: snowflake-connector-python[pandas]>=3.4.0; extra == "pandas"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

dagster_snowflake-0.28.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+dagster_snowflake/__init__.py,sha256=aDqda8Dff_jKm6tjyvOX2BqiXYNIVVMmPbL2h7pZKec,785
+dagster_snowflake/constants.py,sha256=26PGL1eFncm0WfbgZjA7jaznfaRx75vVJnqbieVYeco,481
+dagster_snowflake/ops.py,sha256=L_MP28fLm7_hrJmzMoDocLwyvVnkpy1LVwUSLIArKWc,2225
+dagster_snowflake/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+dagster_snowflake/resources.py,sha256=1s-vLJ3d9xGIXSgF04NqFkuggf_J4BXdjdXxSwWkghk,36042
+dagster_snowflake/snowflake_io_manager.py,sha256=E40E-09u4BMu-Rt5vFfjG8z4Y2N7uaebXVxbOfQqgcg,17682
+dagster_snowflake/version.py,sha256=ZRQKbgDaGz_yuLk-cUKuk6ZBKCSRKZC8nQd041NRNXk,23
+dagster_snowflake/components/__init__.py,sha256=RlBmjimRJNlrlkZKMrZftBjco1wmD4cOFyomfFyooks,145
+dagster_snowflake/components/sql_component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dagster_snowflake/components/sql_component/component.py,sha256=jSQK0odxTY3KQ5BDhCAp-gJbfGW81-lVs7kcCXWKiiM,2141
+dagster_snowflake-0.28.1.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
+dagster_snowflake-0.28.1.dist-info/METADATA,sha256=maVAgut9C8nr48ST1zOZPuw3QGSMyhWPzqG670BBYy0,1350
+dagster_snowflake-0.28.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dagster_snowflake-0.28.1.dist-info/entry_points.txt,sha256=Ddljs88OCl4BNyhSyE8lIAe54bIqEms0cOkR9vUAqsM,72
+dagster_snowflake-0.28.1.dist-info/top_level.txt,sha256=uECYCiluOxLQ996SCUPBBwdK0CTyz45FjWqf7WDqMMc,18
+dagster_snowflake-0.28.1.dist-info/RECORD,,

{dagster_snowflake-0.24.2.dist-info → dagster_snowflake-0.28.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dagster_snowflake-0.28.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[dagster_dg_cli.registry_modules]
+dagster_snowflake = dagster_snowflake

{dagster_snowflake-0.24.2.dist-info → dagster_snowflake-0.28.1.dist-info/licenses}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2023 Dagster Labs, Inc".
+   Copyright 2025 Dagster Labs, Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

dagster_snowflake-0.24.2.dist-info/METADATA

@@ -1,26 +0,0 @@
-Metadata-Version: 2.1
-Name: dagster-snowflake
-Version: 0.24.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
-Author-email: hello@dagsterlabs.com
-License: Apache-2.0
-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: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8,<3.13
-License-File: LICENSE
-Requires-Dist: dagster ==1.8.2
-Requires-Dist: snowflake-connector-python >=3.4.0
-Provides-Extra: pandas
-Requires-Dist: pandas ; extra == 'pandas'
-Requires-Dist: snowflake-connector-python[pandas] >=3.4.0 ; extra == 'pandas'
-Provides-Extra: snowflake.sqlalchemy
-Requires-Dist: sqlalchemy !=1.4.42 ; extra == 'snowflake.sqlalchemy'
-Requires-Dist: snowflake-sqlalchemy ; extra == 'snowflake.sqlalchemy'
-

dagster_snowflake-0.24.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-dagster_snowflake/__init__.py,sha256=hPi8JkjApGPlu4ClTzx0BikfxMf440yW7jsRYZCkGcs,605
-dagster_snowflake/constants.py,sha256=26PGL1eFncm0WfbgZjA7jaznfaRx75vVJnqbieVYeco,481
-dagster_snowflake/ops.py,sha256=L_MP28fLm7_hrJmzMoDocLwyvVnkpy1LVwUSLIArKWc,2225
-dagster_snowflake/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-dagster_snowflake/resources.py,sha256=QVh3IUyg5RZCKgjdYl_-Dv37XrdAp0SgkLqhL8RSZpA,31166
-dagster_snowflake/snowflake_io_manager.py,sha256=eP2zme6HzstCGQs0fONVAZqqmt54D7M1hvEYm-mqjZE,17188
-dagster_snowflake/version.py,sha256=UBF3OYTcBAovta3ux5ybxb0MZYAGpGO79WH_ax2NGeI,23
-dagster_snowflake-0.24.2.dist-info/LICENSE,sha256=TMatHW4_G9ldRdodEAp-l2Xa2WvsdeOh60E3v1R2jis,11349
-dagster_snowflake-0.24.2.dist-info/METADATA,sha256=ZdtH_yk0ibEM8yIETF8WcRc62mt1GFm6fHje0LA7v6Q,1119
-dagster_snowflake-0.24.2.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-dagster_snowflake-0.24.2.dist-info/top_level.txt,sha256=uECYCiluOxLQ996SCUPBBwdK0CTyz45FjWqf7WDqMMc,18
-dagster_snowflake-0.24.2.dist-info/RECORD,,