gitlabds 2.2.2__tar.gz → 2.3.0__tar.gz

{gitlabds-2.2.2/gitlabds.egg-info → gitlabds-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitlabds
-Version: 2.2.2
+Version: 2.3.0
 Summary: GitLab Data Science Tools
 Author-email: Kevin Dietz <kdietz@gitlab.com>
 License-Expression: MIT
@@ -25,9 +25,12 @@ Requires-Dist: seaborn>=0.13.2
 Requires-Dist: shap>=0.50.0
 Requires-Dist: tqdm>=4.66.2
 Requires-Dist: xgboost>=1.6.1
-Provides-Extra: feature-store
-Requires-Dist: snowflake-snowpark-python; extra == "feature-store"
-Requires-Dist: snowflake-ml-python; extra == "feature-store"
+Requires-Dist: pyyaml>=6.0.0
+Provides-Extra: snowflake
+Requires-Dist: cryptography>=41.0.0; extra == "snowflake"
+Requires-Dist: snowflake-connector-python[pandas]>=3.0.0; extra == "snowflake"
+Requires-Dist: snowflake-snowpark-python>=1.37.0; extra == "snowflake"
+Requires-Dist: snowflake-ml-python>=1.11.0; extra == "snowflake"
 Dynamic: license-file
 
 [![PyPI version](https://badge.fury.io/py/gitlabds.svg)](https://badge.fury.io/py/gitlabds)
@@ -61,19 +64,23 @@ pip install gitlabds
 
 ### Optional Dependencies
 
-#### Snowflake Feature Store
+#### Snowflake
 
-The `serve_features`, `clear_feature_serving_locks`, and `get_feature_descriptions` functions require additional Snowflake dependencies.
+The Snowflake connectors (`snowflake_engine_factory`, `ds_query_dataframe`, `query_executor`, `snowflake_stage_load_copy_remove`, `feature_store_factory`) and the feature serving functions (`serve_features`, `clear_feature_serving_locks`, `get_feature_descriptions`) require additional dependencies.
 
 To use these functions, install with:
 
 ```bash
-pip install gitlabds[feature-store]
+pip install gitlabds[snowflake]
 ```
 
 This will install:
+- `snowflake-connector-python[pandas]`
 - `snowflake-snowpark-python`
 - `snowflake-ml-python`
+- `cryptography`
+
+These are optional rather than core because `snowflake-ml-python` constrains the numpy/scikit-learn/xgboost stack that the core package also depends on.
 
 If you try to use these functions without installing the optional dependencies, you'll get an error message with installation instructions.
 
@@ -827,10 +834,10 @@ Status label for a value vs. its peer median (+/- tolerance), not percentile ran
 #### Parameters:
 - _**value**_ : value(s) to evaluate, scalar or array-like
 - _**peer_median**_ : peer group median(s) to compare against
-- _**good_direction**_ : `"decreasing"` flips which side of the median counts as "above" (e.g., for a metric where lower is better). Anything else is treated as increasing/default.
+- _**good_direction**_ : one of `"increasing"`, `"decreasing"`, `"both"`, `"none"` (scalar or array-like). `"decreasing"` flips which side of the median counts as "above" (e.g., for a metric where lower is better). `"both"` and `"none"` mean the feature has no single good direction, so the output is positional only: no flip, and the `ceiling_label` upgrade is suppressed. `None` (the default) is treated as `"none"`. Any other value raises — a blank/NaN in a feature dictionary must be normalized to `"none"` first rather than silently defaulting to increasing.
 - _**tolerance**_ : relative distance from the peer median (as a fraction of the median) required to be classified above/below average rather than "average". Default is 0.15 (a value must be >15% above/below its peer median to leave the "average" band)
 - _**no_activity_value**_ : value that should always map to `labels[3]` ("No activity") regardless of tolerance
-- _**peer_percentile**_ : optional 0-1 percentile rank within the peer group. When provided, an "above average" reading that also sits in the top `ceiling_pct` toward `good_direction` is upgraded to `ceiling_label`
+- _**peer_percentile**_ : optional 0-1 percentile rank within the peer group. When provided, an "above average" reading that also sits in the top `ceiling_pct` toward `good_direction` is upgraded to `ceiling_label`. Only applies when `good_direction` is `"increasing"` or `"decreasing"`
 - _**ceiling_pct**_ : percentile threshold used with `peer_percentile` to detect a "tapped out" strength. Default is 0.95
 - _**ceiling_label**_ : label applied when the ceiling condition is met. Default is "near ceiling"
 - _**labels**_ : tuple of (below average, average, above average, no activity) labels
@@ -859,7 +866,7 @@ Per-record SHAP attribution (log-odds / margin space) for a tree model. Uses tre
 `gitlabds.per_record_shap(model, df, feature_dict, unique_id="record_id", top_n=25, min_actionable=3, actionable_values=["Yes", "Partial"]):`
 
 #### Parameters:
-- _**model**_ : trained tree-based model (e.g., LightGBM, XGBoost)
+- _**model**_ : trained tree-based model (e.g., LightGBM, XGBoost). A raw `xgboost.Booster` (from `xgb.train`, or loaded back from a saved model file) works as well as the sklearn wrapper
 - _**df**_ : model-ready feature matrix, indexed by `unique_id`
 - _**feature_dict**_ : DataFrame or path to CSV with `field` and `actionable` columns
 - _**unique_id**_ : name to use for the record identifier column in the output. Default is "record_id"
@@ -870,6 +877,8 @@ Per-record SHAP attribution (log-odds / margin space) for a tree model. Uses tre
 #### Returns
 - Long DataFrame, one row per (record, feature): `unique_id`, `rank`, `feature`, `contribution`, `direction`, `feature_value`, `actionable`
 
+`direction` ("increases"/"decreases") describes the effect on the model's predicted probability of class 1, not on the business outcome. Where class 1 is a bad outcome (e.g. churn), "increases" means worse — any narrative or scorecard layer reading this column has to apply that polarity itself.
+
 #### Requirements
 This function requires the `shap` package (included in core dependencies).
 
@@ -889,27 +898,29 @@ shap_df = gitlabds.per_record_shap(
 <details><summary> Per-Record Counterfactuals </summary>
 
 #### Description
-"Change X -> +Y" counterfactual search, direction chosen empirically. For each actionable lever SHAP surfaced for a record, evaluates candidate values drawn from peer-group quantiles, re-scores the model at each, and keeps the single move that maximizes the gain in predicted probability. No monotonicity assumption is made.
+"Change X -> +Y" counterfactual search, direction chosen empirically. For each actionable lever SHAP surfaced for a record, evaluates candidate values drawn from peer-group quantiles, re-scores the model at each, and keeps the single move that maximizes `gain` — the improvement in the model score, signed by `score_goal` so that bigger is always better. No monotonicity assumption is made.
 
-`gitlabds.per_record_counterfactuals(model, df, shap_df, model_algo="lgb", unique_id="record_id", peer_group=None, candidate_quantiles=[0.1, 0.25, 0.5, 0.75, 0.9], direction=None, actionable_values=["Yes", "Partial"], min_delta_p=0.005, impact_medium=0.01, impact_high=0.03, levels={"poor fit": 0.03, "good fit": 0.10, "best fit": float("inf")}, n_bins=5):`
+`gitlabds.per_record_counterfactuals(model, df, shap_df, unique_id="record_id", peer_group=None, candidate_quantiles=[0.1, 0.25, 0.5, 0.75, 0.9], direction=None, score_goal="maximize", actionable_values=["Yes", "Partial"], min_gain=0.005, impact_medium=0.01, impact_high=0.03, levels={"poor fit": 0.03, "good fit": 0.10, "best fit": float("inf")}, n_bins=5):`
 
 #### Parameters:
-- _**model**_ : trained model (as in `per_record_shap`)
+- _**model**_ : trained model (as in `per_record_shap`). How probabilities are scored is chosen from the model object itself — `.predict_proba()` where available, otherwise a raw `xgboost.Booster` or `lightgbm.Booster` is scored natively. An unsupported type raises a `TypeError` naming it
 - _**df**_ : model-ready feature matrix, indexed by `unique_id`
-- _**shap_df**_ : output of `per_record_shap`; scopes which (record, feature) levers to test
-- _**model_algo**_ : `"lgb"` or `"xgb"`/`"xgboost"`; controls how probabilities are scored
+- _**shap_df**_ : output of `per_record_shap`; scopes which (record, feature) levers to test. Only numeric non-bool levers are evaluated — candidate values are peer-group quantiles, which need an ordered numeric scale. Categoricals, bools, and strings are skipped with a `UserWarning`. Marking them `'none'` in `direction` is the explicit way to express the same thing, and suppresses the warning
 - _**unique_id**_ : name of the record identifier column. Default is "record_id"
 - _**peer_group**_ : Series/DataFrame indexed by `unique_id`; numeric columns are auto-binned into `n_bins` quantile bands. `None` uses one global group
 - _**candidate_quantiles**_ : peer-group quantiles evaluated as candidate values
-- _**direction**_ : optional per-feature achievability constraint mapping feature -> `'increasing'` | `'decreasing'` | `'both'` (dict or Series)
+- _**direction**_ : optional per-feature constraint mapping feature -> `'increasing'` | `'decreasing'` | `'both'` | `'none'` (dict or Series). `'increasing'`/`'decreasing'` restrict candidates to moves in that direction (an achievability constraint); `'both'` allows either; `'none'` excludes the feature from lever evaluation entirely, for features with no meaningful good direction (categoricals, identifiers, context-only numerics). Features absent from the mapping, or `direction=None`, default to `'both'`. A blank/NaN raises — normalize it to `'none'` where the feature dictionary is read
+- _**score_goal**_ : `"maximize"` if a higher predicted probability of class 1 is the good outcome (e.g. class 1 = uptier), `"minimize"` if it is the bad one (e.g. class 1 = churn). Sets the sign of `gain`, which drives best-move selection, the `min_gain` filter, `impact_bucket`, and the output ordering. This is the outcome's polarity only — `direction` above is a separate, feature-level concept and is unaffected. Default is `"maximize"`
 - _**actionable_values**_ : values in `shap_df["actionable"]` treated as actionable levers
-- _**min_delta_p**_ : drop levers whose best achievable gain is below this
-- _**impact_medium, impact_high**_ : delta_p thresholds bucketing each lever into Low/Medium/High `impact_bucket`
-- _**levels**_ : dict mapping label -> upper bound on `p_before`/`p_after` for that level, ordered worst to best (e.g., default `{"poor fit": 0.03, "good fit": 0.10, "best fit": float("inf")}` means `p <= 0.03` -> "poor fit", `0.03 < p <= 0.10` -> "good fit", `p > 0.10` -> "best fit"). Key order doesn't matter (sorted by cutoff), but the top level's cutoff must be `float("inf")`. Used to detect whether a move crosses a level boundary (any crossing move is floored at "Medium" impact). Pass your own dict (e.g., `{"low": 0.03, "medium": 0.10, "high": float("inf")}`) to match your own pipeline
+- _**min_gain**_ : drop levers whose best achievable gain is below this. Note this is a threshold on `gain`, not on raw `delta_p`: under `score_goal="minimize"` a good move has a negative `delta_p` but a positive `gain`, so this stays positive for both polarities. Negative values (or `-inf`) are allowed, and keep moves that make the outcome worse — useful for inspecting the full candidate distribution while tuning thresholds
+- _**impact_medium, impact_high**_ : `gain` thresholds bucketing each lever into Low/Medium/High `impact_bucket`. Only meaningful for `gain > 0` — under a negative `min_gain` the retained harmful moves stay `"Low"` (the level-crossing floor doesn't apply to them), so read `gain`'s sign rather than the bucket alone
+- _**levels**_ : dict mapping label -> upper bound on P(class 1) for that level (e.g., default `{"poor fit": 0.03, "good fit": 0.10, "best fit": float("inf")}` means `p <= 0.03` -> "poor fit", `0.03 < p <= 0.10` -> "good fit", `p > 0.10` -> "best fit"). Key order doesn't matter — levels are sorted by cutoff and labels follow that order — but the top level's cutoff must be `float("inf")`. Cutoffs are always in P(class 1) space regardless of `score_goal`, and `crosses_level` is a plain inequality, so name the labels for your own outcome: a churn model would pass something like `{"low risk": 0.03, "medium risk": 0.10, "high risk": float("inf")}`. Used to detect whether a move crosses a level boundary (any crossing move is floored at "Medium" impact)
 - _**n_bins**_ : quantile bins for numeric `peer_group` columns
 
 #### Returns
-- Long DataFrame, one row per (record, lever): `current_value`, `intervention_value`, `intervention_quantile`, `p_before`, `p_after`, `delta_p`, `impact_bucket`, `level_before`, `level_after`, `crosses_level`
+- Long DataFrame, one row per (record, lever): `current_value`, `intervention_value`, `intervention_quantile`, `p_before`, `p_after`, `delta_p`, `gain`, `impact_bucket`, `level_before`, `level_after`, `crosses_level`
+
+`delta_p` is the raw signed change in P(class 1); `gain` is that change signed by `score_goal` so bigger is always better. For a `score_goal="minimize"` model, `delta_p` will be negative and `gain` positive.
 
 #### Requirements
 For XGBoost models without `predict_proba`, requires the `xgboost` package (included in core dependencies).
@@ -924,6 +935,17 @@ counterfactuals_df = gitlabds.per_record_counterfactuals(
     shap_df=shap_df,
     peer_group=peer_group_df,
 )
+
+# Churn model: class 1 = churn, so a lower score is the good outcome.
+counterfactuals_df = gitlabds.per_record_counterfactuals(
+    model=churn_model,
+    df=model_features,
+    shap_df=shap_df,
+    peer_group=peer_group_df,
+    score_goal="minimize",
+    direction=dict(zip(feature_dict["field"], feature_dict["good_direction"])),
+    levels={"low risk": 0.03, "medium risk": 0.10, "high risk": float("inf")},
+)
 ```
 
 </details>
@@ -944,6 +966,8 @@ Peer benchmarking. Each record's percentile for each feature within its peer gro
 - _**features**_ : optional explicit list of features to benchmark (used as-is, no actionable filter). If `None` (default), computed for every actionable feature in `df`
 - _**n_bins**_ : quantile bins for numeric `peer_group` columns
 
+Either way, only numeric non-bool columns are benchmarked — percentile ranks and quantiles need an ordered numeric scale. Categoricals, bools, and strings are skipped with a `UserWarning` naming them.
+
 #### Returns
 - Long DataFrame, one row per (record, feature): `unique_id`, `feature`, `record_value`, `peer_group`, `percentile`, `peer_p25`, `peer_p50`, `peer_p75`
 
@@ -1108,6 +1132,231 @@ feature_drift = results['feature_drift']
 
 ### Deployment
 
+#### Snowflake Connectors
+
+Thin wrappers over the native Snowflake SDKs that resolve GitLab's two credential paths — local (dbt profile + SSO) and GitLab CI (env vars + password or key pair) — and then hand off to the native objects. Migrated from `gitlabdata.orchestration_utils`; see the migration notes at the end of this section.
+
+All of these require `pip install gitlabds[snowflake]`.
+
+<details><summary> Snowflake Engine Factory </summary>
+
+#### Description
+Open a Snowflake connection, resolving credentials from your dbt profile locally or from GitLab CI environment variables in CI.
+
+`gitlabds.snowflake_engine_factory(args=None, role="DATA_SCIENCE_LOADER", run_target=None, profile_target="dev", schema="", auth_method="password", profiles_path=None, **connect_kwargs):`
+
+#### Parameters:
+- **_args_** : Environment mapping to read CI credentials from. Defaults to `os.environ`. Ignored on the local path.
+- **_role_** : CI credential set to use. Currently only supports `DATA_SCIENCE_LOADER`
+- **_run_target_** : `"local"` or `"ci"`. Inferred from the `GITLAB_CI` environment variable when not given.
+- **_profile_target_** : dbt profile output name. Only used on the local path.
+- **_schema_** : Schema to connect to. Falls back to the dbt profile's schema locally; when it resolves empty the connection is opened with no default schema.
+- **_auth_method_** : `"password"` or `"keypair"`. Only used on the CI path. Key pair secrets are not yet provisioned in CI.
+- **_profiles_path_** : Override the dbt `profiles.yml` location (defaults to `~/.dbt/profiles.yml`). Only used on the local path.
+- **_\*\*connect_kwargs_** : Passed through to `snowflake.connector.connect()`, e.g. `autocommit=False`, `client_session_keep_alive=True`.
+
+#### Returns
+- An open `snowflake.connector.SnowflakeConnection`. The caller owns its lifecycle.
+
+#### Requirements
+```bash
+pip install gitlabds[snowflake]
+```
+
+#### Examples:
+
+```python
+import gitlabds
+
+# Local: reads the "dev" target from ~/.dbt/profiles.yml and authenticates via SSO
+conn = gitlabds.snowflake_engine_factory()
+try:
+    df = gitlabds.ds_query_dataframe(conn, "select * from prod.data_science.my_table")
+finally:
+    conn.close()
+```
+```python
+# CI: credentials come from os.environ; run_target is inferred from GITLAB_CI
+conn = gitlabds.snowflake_engine_factory(role="DATA_SCIENCE_LOADER", schema="data_science")
+
+# Opt out of autocommit to group statements into one transaction
+conn = gitlabds.snowflake_engine_factory(autocommit=False)
+```
+</details>
+
+<details><summary> DS Query Dataframe </summary>
+
+#### Description
+Run a SELECT and return a pandas DataFrame, using Snowflake's Arrow-based fetch. Prefer this over `query_executor` for large reads such as pulling training data.
+
+`gitlabds.ds_query_dataframe(conn, query, optimize_memory=False, verbose=False):`
+
+#### Parameters:
+- **_conn_** : An open connection, e.g. from `snowflake_engine_factory()`
+- **_query_** : SELECT query to run
+- **_optimize_memory_** : Run the result through `reduce_memory_usage()` (dtype downcasting) before returning. Off by default because it is a lossy transform (e.g. float64 → float32).
+- **_verbose_** : Print the memory-optimization report and progress bar. Only applies when `optimize_memory=True`.
+
+#### Returns
+- A pandas DataFrame
+
+#### Requirements
+```bash
+pip install gitlabds[snowflake]
+```
+
+#### Examples:
+
+```python
+df = gitlabds.ds_query_dataframe(conn, "select * from my_table")
+
+# Large pull: downcast dtypes on the way out
+df = gitlabds.ds_query_dataframe(conn, training_query, optimize_memory=True, verbose=True)
+```
+</details>
+
+<details><summary> Query Executor </summary>
+
+#### Description
+Execute a SQL statement and return its rows as a list of dicts keyed by column name, as Snowflake returns them. Use for DML/DDL/transaction-control statements, or reads where a DataFrame isn't needed.
+
+`gitlabds.query_executor(conn, query):`
+
+#### Parameters:
+- **_conn_** : An open connection, e.g. from `snowflake_engine_factory()`
+- **_query_** : SQL statement to run
+
+#### Returns
+- `List[Dict[str, Any]]` — rows as `{column: value}`. DML and DDL statements return Snowflake's own status row (e.g. `{"number of rows inserted": 12}`) rather than an empty list.
+
+#### Requirements
+```bash
+pip install gitlabds[snowflake]
+```
+
+#### Examples:
+
+```python
+rows = gitlabds.query_executor(conn, "select count(*) as n from my_table")
+print(rows[0]["N"])
+```
+```python
+# Connections autocommit by default, so group statements explicitly
+gitlabds.query_executor(conn, "begin;")
+gitlabds.query_executor(conn, "delete from my_table where run_date = '2026-01-01';")
+gitlabds.query_executor(conn, "commit;")
+```
+</details>
+
+<details><summary> Snowflake Stage Load Copy Remove </summary>
+
+#### Description
+Load a local file into a Snowflake table via an internal stage: remove any leftover staged file, PUT the file, COPY INTO the target table, then REMOVE the staged file.
+
+`gitlabds.snowflake_stage_load_copy_remove(file, stage, table_path, conn, type="json", on_error="abort_statement", file_format_options="", col_names=""):`
+
+#### Parameters:
+- **_conn_** : An open connection, e.g. from `snowflake_engine_factory()`
+- **_file_** : Path to the local file to upload
+- **_stage_** : Internal stage name **without** a leading `@` — the function adds it (e.g. `"my_stage"` or `"db.schema.my_stage"`)
+- **_table_path_** : Fully-qualified target table
+- **_type_** : File format type (e.g. `"json"`, `"csv"`)
+- **_on_error_** : `COPY INTO` `ON_ERROR` behavior
+- **_file_format_options_** : Extra `FILE_FORMAT` options appended after `TYPE`, e.g. `'FIELD_DELIMITER="," SKIP_HEADER=1'`
+- **_col_names_** : Explicit column list for `COPY INTO`, e.g. `"(first_name, last_name)"`. Defaults to `"(jsontext)"` for json, empty otherwise.
+
+#### Returns
+- `None`. Progress is emitted at INFO level through the `logging` module; call `logging.basicConfig()` in your entry point to see it.
+
+#### Requirements
+```bash
+pip install gitlabds[snowflake]
+```
+
+#### Examples:
+
+```python
+gitlabds.snowflake_stage_load_copy_remove(
+    file="scores.json", stage="my_stage", table_path="prod.data_science.scores", conn=conn
+)
+```
+```python
+# CSV with a header row and an explicit column list
+gitlabds.snowflake_stage_load_copy_remove(
+    file="scores.csv",
+    stage="my_stage",
+    table_path="prod.data_science.scores",
+    conn=conn,
+    type="csv",
+    file_format_options='FIELD_DELIMITER="," SKIP_HEADER=1',
+    col_names="(account_id, score)",
+)
+```
+</details>
+
+<details><summary> Feature Store Factory </summary>
+
+#### Description
+Create a Snowflake Feature Store connection (Snowpark Session + native `FeatureStore`), resolving credentials the same way as `snowflake_engine_factory`.
+
+`gitlabds.feature_store_factory(args=None, role="DATA_SCIENCE_LOADER", run_target=None, profile_target="feature_store", auth_method="password", creation_mode="CreationMode.FAIL_IF_NOT_EXIST", profiles_path=None):`
+
+#### Parameters:
+- **_args_** : Environment mapping to read CI credentials from. Defaults to `os.environ`. Ignored on the local path.
+- **_role_** : Snowflake role for CI credentials. The feature store's database and schema come from `SNOWFLAKE_FEATURE_STORE_DATABASE` / `SNOWFLAKE_FEATURE_STORE_SCHEMA` on the CI path, not from the role's usual database/schema.
+- **_run_target_** : `"local"` or `"ci"`. Inferred from the `GITLAB_CI` environment variable when not given.
+- **_profile_target_** : dbt profile output name. Only used on the local path.
+- **_auth_method_** : `"password"` or `"keypair"`. Only used on the CI path.
+- **_creation_mode_** : Either a `"CreationMode.X"` string or a `snowflake.ml.feature_store.CreationMode` member.
+- **_profiles_path_** : Override the dbt `profiles.yml` location. Only used on the local path.
+
+#### Returns
+- A `snowflake.ml.feature_store.FeatureStore`. The underlying Snowpark session is reachable as `fs._session` and is not closed by this function.
+
+#### Requirements
+```bash
+pip install gitlabds[snowflake]
+```
+
+#### Examples:
+
+```python
+import gitlabds
+
+fs = gitlabds.feature_store_factory()
+
+df = gitlabds.serve_features(
+    session=fs._session,
+    feature_store=fs,
+    feature_views_dict={"account_ci_usage": "1.0"},
+    spine_df="select account_id from prod.data_science.my_spine",
+)
+```
+</details>
+
+<details><summary> Migrating from gitlabdata.orchestration_utils </summary>
+
+These functions replace their `gitlabdata.orchestration_utils` equivalents, but the signatures intentionally differ — this is not a drop-in import swap. Changes that fail at runtime rather than at import:
+
+| Was | Now |
+|---|---|
+| `snowflake_engine_factory(...)` returns a SQLAlchemy `Engine` | returns a native `SnowflakeConnection` |
+| `data_science_engine_factory(...)` | folded into `snowflake_engine_factory(...)`, parameterized by `role` / `profile_target` |
+| `pd.read_sql(query, engine)` | `gitlabds.ds_query_dataframe(conn, query)` |
+| `df.to_sql(..., engine)` | `snowflake.connector.pandas_tools.write_pandas(conn, df, ...)` |
+| `engine.connect()` / `engine.dispose()` | `conn` is already open; `conn.close()` |
+| `query_executor(engine, query)` returns tuples — `row[0]` | returns dicts — `row["COLUMN_NAME"]` |
+| `query_executor(..., dispose_engine=..., connection=...)` | dropped; the caller owns the connection and passes it in |
+| `snowflake_stage_load_copy_remove(..., engine, type=...)` | unchanged, except `engine` is now a connection rather than a SQLAlchemy Engine |
+| `in_docker=True` | `profiles_path="/usr/local/snowflake_profile/profiles.yml"` |
+| `run_target="local"` default | `run_target=None`, inferred from `GITLAB_CI` |
+
+Also worth knowing:
+- `file_format_options` is now honored for `json` too; the original silently dropped it for that type.
+- `stage` must be passed **without** a leading `@` (the function adds it). The original behaved the same way but did not document or enforce it.
+- These functions log through `logging.getLogger(__name__)` and no longer call `logging.basicConfig()` for you.
+</details>
+
 #### Feature Serving
 
 <details><summary> Serve Features </summary>
@@ -1140,7 +1389,7 @@ Serve features from Snowflake Feature Store with built-in distributed locking an
 #### Requirements
 This function requires Snowflake packages. Install with:
 ```bash
-pip install snowflake-snowpark-python snowflake-ml-python
+pip install gitlabds[snowflake]
 ```
 
 #### Examples:
@@ -1235,7 +1484,7 @@ Look up each feature's source feature view and description from the feature stor
 #### Requirements
 This function requires Snowflake packages. Install with:
 ```bash
-pip install snowflake-snowpark-python snowflake-ml-python
+pip install gitlabds[snowflake]
 ```
 
 #### Examples: