ml-analytics-tools 0.4.0__tar.gz → 0.4.2__tar.gz

{ml_analytics_tools-0.4.0/ml_analytics_tools.egg-info → ml_analytics_tools-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ml-analytics-tools
-Version: 0.4.0
+Version: 0.4.2
 Summary: Tools for ML projects and data management
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -51,7 +51,7 @@ arguments.
 ## What Is Included
 
 - `DataConnector`: run Redshift or Snowflake SQL, load SQL files, unload/load data through S3, and create Redshift tables from DataFrames.
-- `SFConnector`: read and write Snowflake through Spark (Databricks). PySpark is imported lazily, so the rest of the package works without it.
+- `SFConnector`: read Snowflake through Spark and save results to Unity Catalog tables (Databricks). PySpark is imported lazily, so the rest of the package works without it.
 - `S3Connector`: read, write, list, delete, and query S3 data with DuckDB.
 - `GSheet`: read, write, share, and export Google Sheets data.
 - `SlackConnector`: send messages, upload files, and manage simple Slack interactions.
@@ -168,7 +168,8 @@ df = dc.sql("SELECT 1 AS col_1")
 
 For local interactive work, `SNOWFLAKE_AUTHENTICATOR=externalbrowser` is supported.
 SSO tokens are cached in the OS keychain, so the browser login only happens once
-per token lifetime.
+per token lifetime. (Note: `externalbrowser` works with `DataConnector` only;
+`SFConnector` rejects it, since Spark jobs block on the interactive browser SSO.)
 For Databricks and Spark jobs, use key-pair auth instead. The connector reads
 default Databricks personal-scope secrets automatically:
 
@@ -195,9 +196,10 @@ df = (
 
 ### Query Snowflake With Spark (`SFConnector`)
 
-On Databricks, `SFConnector` reads and writes Snowflake directly as Spark
-DataFrames. It reuses the same `SNOWFLAKE_*` settings and key-pair secrets as
-`DataConnector`, and only imports PySpark when a query/write method runs.
+On Databricks, `SFConnector` reads Snowflake directly as Spark DataFrames and can
+persist results into Unity Catalog tables. It reuses the same `SNOWFLAKE_*`
+settings and key-pair secrets as `DataConnector`, and only imports PySpark when a
+query/write method runs.
 
 ```python
 from ml_analytics import SFConnector
@@ -210,8 +212,14 @@ df = sf.sql("SELECT * FROM cds.dim_tutor LIMIT 1000")
 # pandas DataFrame
 pdf = sf.sql("SELECT 1 AS col_1", return_pandas=True)
 
-# Write a Spark DataFrame back to Snowflake
-sf.save_table(df, "cds.my_table", mode="overwrite")
+# run a query from a .sql file (relative to project root), with templating
+df = sf.sql("queries/experiment.sql", days=14)
+
+# pull and save the result to a Unity Catalog table in one call
+sf.sql("queries/experiment.sql", save_table=True, schema="analytics", table="exp")
+
+# or save any Spark DataFrame to Unity Catalog
+sf.save_to_uc(df, table="exp", schema="analytics", catalog="prod")
 ```
 
 Credentials resolve per field as: explicit argument → `SNOWFLAKE_*` environment
@@ -262,15 +270,14 @@ gsheet.write_sheet(df, spreadsheet_id="...", sheet_name="Results")
 #### OAuth authentication (alternative to a service account)
 
 `GSheet` can authenticate as your own Google account using OAuth installed-app
-credentials (e.g. Preply's Google Workspace CLI credentials). Set these env vars
-and the connector uses OAuth automatically when no service-account credentials
-are found:
+credentials. Set these env vars and the connector uses OAuth automatically when
+no service-account credentials are found:
 
 | Variable | Required | Description |
 |----------|----------|-------------|
 | `GOOGLE_OAUTH_CLIENT_ID` | yes | OAuth client id (`...apps.googleusercontent.com`) |
 | `GOOGLE_OAUTH_CLIENT_SECRET` | yes | OAuth client secret (`GOCSPX-...`) |
-| `GOOGLE_CLOUD_PROJECT` | optional | GCP project id (e.g. `preply-gworkspace-cli`) |
+| `GOOGLE_CLOUD_PROJECT` | optional | GCP project id (e.g. `my-gcp-project`) |
 | `GSHEET_TOKEN_PATH` | optional | Token cache path (default `~/.config/ml-analytics/gsheet_token.json`) |
 
 The first run opens a browser for one-time consent; the cached refresh token

{ml_analytics_tools-0.4.0 → ml_analytics_tools-0.4.2}/README.md

@@ -16,7 +16,7 @@ arguments.
 ## What Is Included
 
 - `DataConnector`: run Redshift or Snowflake SQL, load SQL files, unload/load data through S3, and create Redshift tables from DataFrames.
-- `SFConnector`: read and write Snowflake through Spark (Databricks). PySpark is imported lazily, so the rest of the package works without it.
+- `SFConnector`: read Snowflake through Spark and save results to Unity Catalog tables (Databricks). PySpark is imported lazily, so the rest of the package works without it.
 - `S3Connector`: read, write, list, delete, and query S3 data with DuckDB.
 - `GSheet`: read, write, share, and export Google Sheets data.
 - `SlackConnector`: send messages, upload files, and manage simple Slack interactions.
@@ -133,7 +133,8 @@ df = dc.sql("SELECT 1 AS col_1")
 
 For local interactive work, `SNOWFLAKE_AUTHENTICATOR=externalbrowser` is supported.
 SSO tokens are cached in the OS keychain, so the browser login only happens once
-per token lifetime.
+per token lifetime. (Note: `externalbrowser` works with `DataConnector` only;
+`SFConnector` rejects it, since Spark jobs block on the interactive browser SSO.)
 For Databricks and Spark jobs, use key-pair auth instead. The connector reads
 default Databricks personal-scope secrets automatically:
 
@@ -160,9 +161,10 @@ df = (
 
 ### Query Snowflake With Spark (`SFConnector`)
 
-On Databricks, `SFConnector` reads and writes Snowflake directly as Spark
-DataFrames. It reuses the same `SNOWFLAKE_*` settings and key-pair secrets as
-`DataConnector`, and only imports PySpark when a query/write method runs.
+On Databricks, `SFConnector` reads Snowflake directly as Spark DataFrames and can
+persist results into Unity Catalog tables. It reuses the same `SNOWFLAKE_*`
+settings and key-pair secrets as `DataConnector`, and only imports PySpark when a
+query/write method runs.
 
 ```python
 from ml_analytics import SFConnector
@@ -175,8 +177,14 @@ df = sf.sql("SELECT * FROM cds.dim_tutor LIMIT 1000")
 # pandas DataFrame
 pdf = sf.sql("SELECT 1 AS col_1", return_pandas=True)
 
-# Write a Spark DataFrame back to Snowflake
-sf.save_table(df, "cds.my_table", mode="overwrite")
+# run a query from a .sql file (relative to project root), with templating
+df = sf.sql("queries/experiment.sql", days=14)
+
+# pull and save the result to a Unity Catalog table in one call
+sf.sql("queries/experiment.sql", save_table=True, schema="analytics", table="exp")
+
+# or save any Spark DataFrame to Unity Catalog
+sf.save_to_uc(df, table="exp", schema="analytics", catalog="prod")
 ```
 
 Credentials resolve per field as: explicit argument → `SNOWFLAKE_*` environment
@@ -227,15 +235,14 @@ gsheet.write_sheet(df, spreadsheet_id="...", sheet_name="Results")
 #### OAuth authentication (alternative to a service account)
 
 `GSheet` can authenticate as your own Google account using OAuth installed-app
-credentials (e.g. Preply's Google Workspace CLI credentials). Set these env vars
-and the connector uses OAuth automatically when no service-account credentials
-are found:
+credentials. Set these env vars and the connector uses OAuth automatically when
+no service-account credentials are found:
 
 | Variable | Required | Description |
 |----------|----------|-------------|
 | `GOOGLE_OAUTH_CLIENT_ID` | yes | OAuth client id (`...apps.googleusercontent.com`) |
 | `GOOGLE_OAUTH_CLIENT_SECRET` | yes | OAuth client secret (`GOCSPX-...`) |
-| `GOOGLE_CLOUD_PROJECT` | optional | GCP project id (e.g. `preply-gworkspace-cli`) |
+| `GOOGLE_CLOUD_PROJECT` | optional | GCP project id (e.g. `my-gcp-project`) |
 | `GSHEET_TOKEN_PATH` | optional | Token cache path (default `~/.config/ml-analytics/gsheet_token.json`) |
 
 The first run opens a browser for one-time consent; the cached refresh token

{ml_analytics_tools-0.4.0 → ml_analytics_tools-0.4.2}/ml_analytics/sf_connector.py

@@ -18,7 +18,7 @@ from .data_connector import (
     _load_private_key_pem_for_spark,
     _snowflake_secret_scope,
 )
-from .utils import get_logger, log_and_raise_error
+from .utils import get_logger, load_sql_query, log_and_raise_error
 
 # Cached Spark session shared across SFConnector instances. Populated lazily by
 # get_spark(); never created at import time so the package stays importable
@@ -221,65 +221,125 @@ class SFConnector:
             if self.authenticator:
                 options["sfAuthenticator"] = self.authenticator
         elif self.authenticator:
-            options["sfAuthenticator"] = self.authenticator
             if self.authenticator.lower() == "externalbrowser":
-                self._logger.warning(
-                    "Snowflake externalbrowser authentication is interactive and is not suitable for "
-                    "Databricks/Spark jobs. Use key-pair or OAuth for Spark workloads."
+                log_and_raise_error(
+                    self._logger,
+                    "Snowflake externalbrowser authentication is interactive and cannot be used by "
+                    "SFConnector (Spark jobs block on the browser SSO handshake). Use key-pair "
+                    "(SNOWFLAKE_PRIVATE_KEY/_PATH) or OAuth (SNOWFLAKE_TOKEN) for Spark workloads, "
+                    "or use DataConnector for interactive local queries.",
                 )
+            options["sfAuthenticator"] = self.authenticator
 
         # Caller-provided options win over resolved defaults.
         options.update({k: v for k, v in self.extra_options.items() if _clean_env_value(v) is not None})
         return options
 
-    def sql(self, query: str, return_pandas: bool = False):
+    def _resolve_query(self, query: str, **kwargs) -> str:
+        """Resolve a query string: if it looks like a SQL file path, load it; otherwise return as-is."""
+        if query and query.strip().endswith(".sql"):
+            loaded = load_sql_query(query.strip(), **kwargs)
+            if loaded is None:
+                log_and_raise_error(self._logger, f"Could not load SQL file: {query}")
+            self._logger.info(f"Loaded SQL from file: {query}")
+            return loaded
+        return query
+
+    def sql(
+        self,
+        query: str,
+        return_pandas: bool = False,
+        save_table: bool = False,
+        table: str = None,
+        schema: str = None,
+        catalog: str = None,
+        mode: str = "overwrite",
+        **kwargs,
+    ):
         """
         Execute a SQL query against Snowflake and return the result.
 
+        Optionally persist the result straight into a Databricks Unity Catalog
+        table while pulling the data, by passing ``save_table=True`` along with a
+        destination ``table`` (and optionally ``schema`` / ``catalog``).
+
         Parameters
         ----------
         query : str
-            SQL query to execute.
+            SQL query to execute, or a path to a ``.sql`` file (relative to the
+            project root). When a ``.sql`` path is given, its contents are loaded
+            automatically.
         return_pandas : bool, optional
             If True, return a pandas DataFrame; otherwise return a Spark
             DataFrame. Defaults to False.
+        save_table : bool, optional
+            If True, write the result to a Unity Catalog table via
+            :meth:`save_to_uc` before returning. Defaults to False.
+        table : str, optional
+            Destination table name when ``save_table`` is True. May be fully
+            qualified (``catalog.schema.table``), in which case ``schema`` /
+            ``catalog`` are ignored.
+        schema, catalog : str, optional
+            Unity Catalog schema and catalog to qualify ``table`` with.
+        mode : str, optional
+            Spark write mode for the saved table ('overwrite', 'append',
+            'ignore', 'error'). Defaults to 'overwrite'.
+        **kwargs
+            Template variables substituted into the SQL file using ``str.format()``.
         """
+        query = self._resolve_query(query, **kwargs)
         spark = self._get_spark()
         try:
             df = spark.read.format(self.source_format).options(**self.spark_options()).option("query", query).load()
         except Exception as e:
             log_and_raise_error(self._logger, f"Error reading from Snowflake: {e}")
 
+        if save_table:
+            self.save_to_uc(df, table=table, schema=schema, catalog=catalog, mode=mode)
+
         if return_pandas:
             return df.toPandas()
         return df
 
-    def save_table(self, df, table: str, mode: str = "overwrite", column_mapping: str = "name"):
+    @staticmethod
+    def _qualified_uc_name(table: str, schema: str = None, catalog: str = None) -> str:
+        """Build a Unity Catalog table identifier from its parts.
+
+        A ``table`` that already contains dots is treated as fully qualified and
+        returned as-is; otherwise ``catalog`` / ``schema`` are prepended when given.
         """
-        Write a Spark DataFrame to a Snowflake table.
+        if "." in table:
+            return table
+        parts = [part for part in (catalog, schema, table) if part]
+        return ".".join(parts)
+
+    def save_to_uc(self, df, table: str, schema: str = None, catalog: str = None, mode: str = "overwrite"):
+        """
+        Write a Spark DataFrame to a Databricks Unity Catalog table.
+
+        Uses Spark's native ``df.write.saveAsTable(...)`` (a managed UC table),
+        not the Snowflake connector.
 
         Parameters
         ----------
         df : pyspark.sql.DataFrame
             DataFrame to write.
         table : str
-            Destination table name (``sfDatabase`` / ``sfSchema`` from the
-            connector are used unless the name is fully qualified).
+            Destination table name. May be fully qualified
+            (``catalog.schema.table``), in which case ``schema`` / ``catalog``
+            are ignored.
+        schema, catalog : str, optional
+            Unity Catalog schema and catalog to qualify ``table`` with.
         mode : str, optional
             Spark write mode: 'overwrite', 'append', 'ignore', or 'error'.
             Defaults to 'overwrite'.
-        column_mapping : str, optional
-            Snowflake ``column_mapping`` option ('name' or 'order').
-            Defaults to 'name' so columns are matched by name.
         """
         if not table:
             log_and_raise_error(self._logger, "A destination table name is required.")
 
-        options = self.spark_options()
-        options["dbtable"] = table
-        options["column_mapping"] = column_mapping
+        full_name = self._qualified_uc_name(table, schema=schema, catalog=catalog)
         try:
-            df.write.format(self.source_format).options(**options).mode(mode).save()
+            df.write.mode(mode).saveAsTable(full_name)
         except Exception as e:
-            log_and_raise_error(self._logger, f"Error writing to Snowflake table '{table}': {e}")
-        self._logger.info(f"Table '{table}' written successfully (mode={mode}).")
+            log_and_raise_error(self._logger, f"Error writing to Unity Catalog table '{full_name}': {e}")
+        self._logger.info(f"Table '{full_name}' written to Unity Catalog (mode={mode}).")

{ml_analytics_tools-0.4.0 → ml_analytics_tools-0.4.2/ml_analytics_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ml-analytics-tools
-Version: 0.4.0
+Version: 0.4.2
 Summary: Tools for ML projects and data management
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -51,7 +51,7 @@ arguments.
 ## What Is Included
 
 - `DataConnector`: run Redshift or Snowflake SQL, load SQL files, unload/load data through S3, and create Redshift tables from DataFrames.
-- `SFConnector`: read and write Snowflake through Spark (Databricks). PySpark is imported lazily, so the rest of the package works without it.
+- `SFConnector`: read Snowflake through Spark and save results to Unity Catalog tables (Databricks). PySpark is imported lazily, so the rest of the package works without it.
 - `S3Connector`: read, write, list, delete, and query S3 data with DuckDB.
 - `GSheet`: read, write, share, and export Google Sheets data.
 - `SlackConnector`: send messages, upload files, and manage simple Slack interactions.
@@ -168,7 +168,8 @@ df = dc.sql("SELECT 1 AS col_1")
 
 For local interactive work, `SNOWFLAKE_AUTHENTICATOR=externalbrowser` is supported.
 SSO tokens are cached in the OS keychain, so the browser login only happens once
-per token lifetime.
+per token lifetime. (Note: `externalbrowser` works with `DataConnector` only;
+`SFConnector` rejects it, since Spark jobs block on the interactive browser SSO.)
 For Databricks and Spark jobs, use key-pair auth instead. The connector reads
 default Databricks personal-scope secrets automatically:
 
@@ -195,9 +196,10 @@ df = (
 
 ### Query Snowflake With Spark (`SFConnector`)
 
-On Databricks, `SFConnector` reads and writes Snowflake directly as Spark
-DataFrames. It reuses the same `SNOWFLAKE_*` settings and key-pair secrets as
-`DataConnector`, and only imports PySpark when a query/write method runs.
+On Databricks, `SFConnector` reads Snowflake directly as Spark DataFrames and can
+persist results into Unity Catalog tables. It reuses the same `SNOWFLAKE_*`
+settings and key-pair secrets as `DataConnector`, and only imports PySpark when a
+query/write method runs.
 
 ```python
 from ml_analytics import SFConnector
@@ -210,8 +212,14 @@ df = sf.sql("SELECT * FROM cds.dim_tutor LIMIT 1000")
 # pandas DataFrame
 pdf = sf.sql("SELECT 1 AS col_1", return_pandas=True)
 
-# Write a Spark DataFrame back to Snowflake
-sf.save_table(df, "cds.my_table", mode="overwrite")
+# run a query from a .sql file (relative to project root), with templating
+df = sf.sql("queries/experiment.sql", days=14)
+
+# pull and save the result to a Unity Catalog table in one call
+sf.sql("queries/experiment.sql", save_table=True, schema="analytics", table="exp")
+
+# or save any Spark DataFrame to Unity Catalog
+sf.save_to_uc(df, table="exp", schema="analytics", catalog="prod")
 ```
 
 Credentials resolve per field as: explicit argument → `SNOWFLAKE_*` environment
@@ -262,15 +270,14 @@ gsheet.write_sheet(df, spreadsheet_id="...", sheet_name="Results")
 #### OAuth authentication (alternative to a service account)
 
 `GSheet` can authenticate as your own Google account using OAuth installed-app
-credentials (e.g. Preply's Google Workspace CLI credentials). Set these env vars
-and the connector uses OAuth automatically when no service-account credentials
-are found:
+credentials. Set these env vars and the connector uses OAuth automatically when
+no service-account credentials are found:
 
 | Variable | Required | Description |
 |----------|----------|-------------|
 | `GOOGLE_OAUTH_CLIENT_ID` | yes | OAuth client id (`...apps.googleusercontent.com`) |
 | `GOOGLE_OAUTH_CLIENT_SECRET` | yes | OAuth client secret (`GOCSPX-...`) |
-| `GOOGLE_CLOUD_PROJECT` | optional | GCP project id (e.g. `preply-gworkspace-cli`) |
+| `GOOGLE_CLOUD_PROJECT` | optional | GCP project id (e.g. `my-gcp-project`) |
 | `GSHEET_TOKEN_PATH` | optional | Token cache path (default `~/.config/ml-analytics/gsheet_token.json`) |
 
 The first run opens a browser for one-time consent; the cached refresh token

{ml_analytics_tools-0.4.0 → ml_analytics_tools-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ml-analytics-tools"
-version = "0.4.0"
+version = "0.4.2"
 description = "Tools for ML projects and data management"
 readme = "README.md"
 requires-python = ">=3.11"

{ml_analytics_tools-0.4.0 → ml_analytics_tools-0.4.2}/tests/test_gsheet_connector.py

@@ -949,7 +949,7 @@ class TestGSheetOAuth:
             monkeypatch.delenv(var, raising=False)
         monkeypatch.setenv("GOOGLE_OAUTH_CLIENT_ID", "cid.apps.googleusercontent.com")
         monkeypatch.setenv("GOOGLE_OAUTH_CLIENT_SECRET", "GOCSPX-secret")
-        monkeypatch.setenv("GOOGLE_CLOUD_PROJECT", "preply-gworkspace-cli")
+        monkeypatch.setenv("GOOGLE_CLOUD_PROJECT", "my-gcp-project")
         monkeypatch.setenv("GSHEET_TOKEN_PATH", str(token_path))
 
     def test_oauth_runs_flow_when_no_token(self, monkeypatch, tmp_path, mock_google_api_services):

{ml_analytics_tools-0.4.0 → ml_analytics_tools-0.4.2}/tests/test_sf_connector.py

@@ -176,6 +176,76 @@ def test_extra_options_override(monkeypatch):
     assert options["sfTimezone"] == "UTC"
 
 
+def test_externalbrowser_authenticator_raises(monkeypatch):
+    _clear_snowflake_env(monkeypatch)
+    sf = SFConnector(account="acct", user="u", authenticator="externalbrowser")
+    with pytest.raises(ValueError, match="externalbrowser"):
+        sf.spark_options()
+
+
+def test_resolve_query_inline_passthrough(monkeypatch):
+    _clear_snowflake_env(monkeypatch)
+    sf = SFConnector(account="acct", user="u")
+    assert sf._resolve_query("SELECT 1") == "SELECT 1"
+
+
+def test_resolve_query_loads_sql_file(monkeypatch, tmp_path):
+    _clear_snowflake_env(monkeypatch)
+    sql_file = tmp_path / "q.sql"
+    sql_file.write_text("SELECT {n} AS n")
+    monkeypatch.setattr("ml_analytics.sf_connector.find_project_root", lambda *a, **k: tmp_path, raising=False)
+    monkeypatch.setattr("ml_analytics.utils.find_project_root", lambda *a, **k: tmp_path)
+    sf = SFConnector(account="acct", user="u")
+    assert sf._resolve_query("q.sql", n=5) == "SELECT 5 AS n"
+
+
+def test_resolve_query_missing_file_raises(monkeypatch, tmp_path):
+    _clear_snowflake_env(monkeypatch)
+    monkeypatch.setattr("ml_analytics.utils.find_project_root", lambda *a, **k: tmp_path)
+    sf = SFConnector(account="acct", user="u")
+    with pytest.raises(ValueError, match="Could not load SQL file"):
+        sf._resolve_query("missing.sql")
+
+
+def test_qualified_uc_name_parts():
+    assert SFConnector._qualified_uc_name("t", schema="s", catalog="c") == "c.s.t"
+    assert SFConnector._qualified_uc_name("t", schema="s") == "s.t"
+    assert SFConnector._qualified_uc_name("t") == "t"
+
+
+def test_qualified_uc_name_already_qualified():
+    # A dotted table name is treated as fully qualified; schema/catalog ignored.
+    assert SFConnector._qualified_uc_name("cat.sch.tbl", schema="x", catalog="y") == "cat.sch.tbl"
+
+
+def test_save_to_uc_uses_saveastable(monkeypatch):
+    _clear_snowflake_env(monkeypatch)
+    sf = SFConnector(account="acct", user="u")
+
+    calls = {}
+
+    class _Writer:
+        def mode(self, m):
+            calls["mode"] = m
+            return self
+
+        def saveAsTable(self, name):
+            calls["name"] = name
+
+    class _DF:
+        write = _Writer()
+
+    sf.save_to_uc(_DF(), table="tbl", schema="sch", catalog="cat", mode="append")
+    assert calls == {"mode": "append", "name": "cat.sch.tbl"}
+
+
+def test_save_to_uc_requires_table(monkeypatch):
+    _clear_snowflake_env(monkeypatch)
+    sf = SFConnector(account="acct", user="u")
+    with pytest.raises(ValueError, match="table name is required"):
+        sf.save_to_uc(object(), table="")
+
+
 def test_missing_account_raises(monkeypatch):
     _clear_snowflake_env(monkeypatch)
     with pytest.raises(ValueError):
@@ -247,20 +317,3 @@ def test_sql_return_pandas(monkeypatch):
     sf.sql("select 1", return_pandas=True)
 
     df.toPandas.assert_called_once()
-
-
-def test_save_table(monkeypatch):
-    _clear_snowflake_env(monkeypatch)
-    spark, _ = _mock_spark()
-    sf = SFConnector(account="acct", user="u", password="p", spark=spark)
-
-    df = MagicMock()
-    sf.save_table(df, "cds.my_table", mode="append")
-
-    df.write.format.assert_called_once_with("net.snowflake.spark.snowflake")
-    writer = df.write.format.return_value
-    options_passed = writer.options.call_args.kwargs
-    assert options_passed["dbtable"] == "cds.my_table"
-    assert options_passed["column_mapping"] == "name"
-    writer.options.return_value.mode.assert_called_once_with("append")
-    writer.options.return_value.mode.return_value.save.assert_called_once()