snowflake-ml-python 1.8.4__py3-none-any.whl → 1.8.6__py3-none-any.whl

snowflake/ml/model/_packager/model_runtime/_snowml_inference_alternative_requirements.py

@@ -12,7 +12,7 @@ REQUIREMENTS = [
     "importlib_resources>=6.1.1, <7",
     "numpy>=1.23,<2",
     "packaging>=20.9,<25",
-    "pandas>=1.0.0,<3",
+    "pandas>=2.1.4,<3",
     "pyarrow",
     "pydantic>=2.8.2, <3",
     "pyjwt>=2.0.0, <3",
@@ -24,9 +24,10 @@ REQUIREMENTS = [
     "scikit-learn<1.6",
     "scipy>=1.9,<2",
     "shap>=0.46.0,<1",
-    "snowflake-connector-python>=3.14.0,<4",
+    "snowflake-connector-python>=3.15.0,<4",
     "snowflake-snowpark-python>=1.17.0,<2,!=1.26.0",
     "snowflake.core>=1.0.2,<2",
     "sqlparse>=0.4,<1",
     "typing-extensions>=4.1.0,<5",
+    "xgboost>=1.7.3,<3",
 ]

snowflake/ml/model/_signatures/core.py

@@ -559,6 +559,30 @@ class ModelSignature:
                 )"""
         )
 
+    def _repr_html_(self) -> str:
+        """Generate an HTML representation of the model signature.
+
+        Returns:
+            str: HTML string containing formatted signature details.
+        """
+        from snowflake.ml.utils import html_utils
+
+        # Create collapsible sections for inputs and outputs
+        inputs_content = html_utils.create_features_html(self.inputs, "Input")
+        outputs_content = html_utils.create_features_html(self.outputs, "Output")
+
+        inputs_section = html_utils.create_collapsible_section("Inputs", inputs_content, open_by_default=True)
+        outputs_section = html_utils.create_collapsible_section("Outputs", outputs_content, open_by_default=True)
+
+        content = f"""
+        <div style="margin-top: 10px;">
+            {inputs_section}
+            {outputs_section}
+        </div>
+        """
+
+        return html_utils.create_base_container("Model Signature", content)
+
     @classmethod
     def from_mlflow_sig(cls, mlflow_sig: "mlflow.models.ModelSignature") -> "ModelSignature":
         return ModelSignature(

snowflake/ml/monitoring/explain_visualize.py

@@ -1,4 +1,4 @@
-from typing import Union, cast, overload
+from typing import Any, Union, cast, overload
 
 import altair as alt
 import numpy as np
@@ -6,16 +6,22 @@ import pandas as pd
 
 import snowflake.snowpark.dataframe as sp_df
 from snowflake import snowpark
+from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml.model import model_signature, type_hints
 from snowflake.ml.model._signatures import snowpark_handler
 
+DEFAULT_FIGSIZE = (1400, 500)
+DEFAULT_VIOLIN_FIGSIZE = (1400, 100)
+MAX_ANNOTATION_LENGTH = 20
+MIN_DISTANCE = 10  # Increase minimum distance between labels for more spreading in plot_force
+
 
 @overload
 def plot_force(
     shap_row: snowpark.Row,
     features_row: snowpark.Row,
     base_value: float = 0.0,
-    figsize: tuple[float, float] = (600, 200),
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
     contribution_threshold: float = 0.05,
 ) -> alt.LayerChart:
     ...
@@ -26,7 +32,7 @@ def plot_force(
     shap_row: pd.Series,
     features_row: pd.Series,
     base_value: float = 0.0,
-    figsize: tuple[float, float] = (600, 200),
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
     contribution_threshold: float = 0.05,
 ) -> alt.LayerChart:
     ...
@@ -36,7 +42,7 @@ def plot_force(
     shap_row: Union[pd.Series, snowpark.Row],
     features_row: Union[pd.Series, snowpark.Row],
     base_value: float = 0.0,
-    figsize: tuple[float, float] = (600, 200),
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
     contribution_threshold: float = 0.05,
 ) -> alt.LayerChart:
     """
@@ -53,7 +59,17 @@ def plot_force(
 
     Returns:
         Altair chart object
+
+    Raises:
+        SnowflakeMLException: If the contribution threshold is not between 0 and 1,
+            or if no features with significant contributions are found.
     """
+    if not (0 < contribution_threshold and contribution_threshold < 1):
+        raise exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=ValueError("contribution_threshold must be between 0 and 1."),
+        )
+
     if isinstance(shap_row, snowpark.Row):
         shap_row = pd.Series(shap_row.as_dict())
     if isinstance(features_row, snowpark.Row):
@@ -67,7 +83,7 @@ def plot_force(
             {
                 "feature": feature,
                 "feature_value": features_row.iloc[index],
-                "feature_annotated": f"{feature}: {features_row.iloc[index]}",
+                "feature_annotated": f"{feature}: {features_row.iloc[index]}"[:MAX_ANNOTATION_LENGTH],
                 "influence_value": shap_row.iloc[index],
                 "bar_direction": positive_label if shap_row.iloc[index] >= 0 else negative_label,
             }
@@ -95,11 +111,11 @@ def plot_force(
 
         if row_influence_value >= 0:
             start = current_position_pos - spacing
-            end = current_position_pos - row_influence_value
+            end = current_position_pos - row_influence_value - spacing
             current_position_pos = end
         else:
             start = current_position_neg + spacing
-            end = current_position_neg + abs(row_influence_value)
+            end = current_position_neg + abs(row_influence_value) + spacing
             current_position_neg = end
 
         positions.append(
@@ -108,13 +124,23 @@ def plot_force(
                 "end": end,
                 "avg": (start + end) / 2,
                 "influence_value": row_influence_value,
-                "influence_annotated": f"Influence: {row_influence_value}",
                 "feature_value": row["feature_value"],
                 "feature_annotated": row["feature_annotated"],
                 "bar_direction": row["bar_direction"],
+                "bar_y": 0,
+                "feature": row["feature"],
             }
         )
 
+    if len(positions) == 0:
+        raise exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=ValueError(
+                "No features with significant contributions found. Try lowering the contribution_threshold,"
+                "and verify the input is non-empty."
+            ),
+        )
+
     position_df = pd.DataFrame(positions)
 
     # Create force plot using Altair
@@ -127,12 +153,13 @@ def plot_force(
         .encode(
             x=alt.X("start:Q", title="Feature Impact"),
             x2=alt.X2("end:Q"),
+            y=alt.Y("bar_y:Q", axis=None),
             color=alt.Color(
                 "bar_direction:N",
                 scale=alt.Scale(domain=[positive_label, negative_label], range=[red_color, blue_color]),
                 legend=alt.Legend(title="Influence Direction"),
             ),
-            tooltip=["influence_value", "feature_value"],
+            tooltip=["feature", "influence_value", "feature_value"],
         )
         .properties(title="Feature Influence (SHAP values)", width=width, height=height)
     ).interactive()
@@ -142,6 +169,7 @@ def plot_force(
         .mark_point(shape="triangle", filled=True, fillOpacity=1)
         .encode(
             x=alt.X("start:Q"),
+            y=alt.Y("bar_y:Q", axis=None),
             angle=alt.Angle("bar_direction:N", scale=alt.Scale(domain=["Positive", "Negative"], range=[90, -90])),
             color=alt.Color(
                 "bar_direction:N", scale=alt.Scale(domain=["Positive", "Negative"], range=["#1f77b4", "#d62728"])
@@ -154,37 +182,147 @@ def plot_force(
     # Add a vertical line at the base value
     zero_line: alt.Chart = alt.Chart(pd.DataFrame({"x": [base_value]})).mark_rule(strokeDash=[3, 3]).encode(x="x:Q")
 
-    # Add text labels on each bar
+    # Calculate label positions to avoid overlap and ensure labels are spread apart horizontally
+
+    # Sort by bar center (avg) for label placement
+    sorted_positions = sorted(positions, key=lambda x: x["avg"])
+
+    # Improved label spreading algorithm:
+    # Calculate the minimum and maximum x positions (avg) for the bars
+    min_x = min(pos["avg"] for pos in sorted_positions)
+    max_x = max(pos["avg"] for pos in sorted_positions)
+    n_labels = len(sorted_positions)
+    # Calculate the minimum required distance between labels
+    spread_width = max_x - min_x
+    if n_labels > 1:
+        space_per_label = spread_width / (n_labels - 1)
+        # If space_per_label is less than min_distance, use min_distance instead
+        effective_distance = max(space_per_label, MIN_DISTANCE)
+    else:
+        effective_distance = 0
+
+    # Start from min_x - offset, and assign label_x for each label from left to right
+    offset = -effective_distance  # Start a bit to the left
+    label_positions = []
+    label_lines = []
+    placed_label_xs: list[float] = []
+    for i, pos in enumerate(sorted_positions):
+        if i == 0:
+            label_x = min_x + offset
+        else:
+            label_x = placed_label_xs[-1] + effective_distance
+        placed_label_xs.append(label_x)
+        label_positions.append(
+            {
+                "label_x": label_x,
+                "label_y": 1,  # Place labels below the bars
+                "feature_annotated": pos["feature_annotated"],
+                "feature_value": pos["feature_value"],
+            }
+        )
+        # Draw a diagonal line from the bar to the label
+        label_lines.append(
+            {
+                "x": pos["avg"],
+                "x2": label_x,
+                "y": 0,
+                "y2": 1,
+            }
+        )
+
+    label_positions_df = pd.DataFrame(label_positions)
+    label_lines_df = pd.DataFrame(label_lines)
+
+    # Draw diagonal lines from bar to label
+    label_connectors = (
+        alt.Chart(label_lines_df)
+        .mark_rule(strokeDash=[2, 2], color="grey")
+        .encode(
+            x="x:Q",
+            x2="x2:Q",
+            y=alt.Y("y:Q", axis=None),
+            y2="y2:Q",
+        )
+    )
+
+    # Place labels at adjusted positions
     feature_labels = (
-        alt.Chart(position_df)
-        .mark_text(align="center", baseline="line-bottom", dy=30, fontSize=11)
+        alt.Chart(label_positions_df)
+        .mark_text(align="center", baseline="line-bottom", dy=0, fontSize=11)
         .encode(
-            x=alt.X("avg:Q"),
-            text=alt.Text("feature_annotated:N"),  # Display with 2 decimal places
-            color=alt.value("grey"),  # Label color for positive values
+            x=alt.X("label_x:Q"),
+            y=alt.Y("label_y:Q", axis=None),
+            text=alt.Text("feature_annotated:N"),
+            color=alt.value("grey"),
             tooltip=["feature_value"],
         )
     )
 
-    return cast(alt.LayerChart, bars + feature_labels + zero_line + arrow)
+    return cast(alt.LayerChart, bars + feature_labels + zero_line + arrow + label_connectors)
 
 
 def plot_influence_sensitivity(
-    feature_values: pd.Series, shap_values: pd.Series, figsize: tuple[float, float] = (600, 400)
-) -> alt.Chart:
+    shap_values: type_hints.SupportedDataType,
+    feature_values: type_hints.SupportedDataType,
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
+) -> Any:
     """
-    Create a SHAP dependence scatter plot for a specific feature.
+    Create a SHAP dependence scatter plot for a specific feature. If a DataFrame is provided, a select box
+    will be displayed to select the feature. This is only supported in Snowflake notebooks.
+    If Streamlit is not available and a DataFrame is passed in, an ImportError will be raised.
 
     Args:
-        feature_values: pandas Series containing the feature values for a specific feature
-        shap_values: pandas Series containing the SHAP values for the same feature
+        shap_values: pandas Series or 2D array containing the SHAP values for a specific feature
+        feature_values: pandas Series or 2D array containing the feature values for the same feature
         figsize: tuple of (width, height) for the plot
 
     Returns:
         Altair chart object
 
+    Raises:
+        ValueError: If the types of feature_values and shap_values are not the same
+
     """
 
+    use_streamlit = False
+    feature_values_df = _convert_to_pandas_df(feature_values)
+    shap_values_df = _convert_to_pandas_df(shap_values)
+
+    if len(shap_values_df.shape) > 1:
+        feature_values, shap_values, st = _prepare_feature_values_for_streamlit(feature_values_df, shap_values_df)
+        use_streamlit = True
+    elif feature_values_df.shape[0] != shap_values_df.shape[0]:
+        raise ValueError("Feature values and SHAP values must have the same number of rows.")
+
+    scatter = _create_scatter_plot(feature_values, shap_values, figsize)
+    return st.altair_chart(scatter) if use_streamlit else scatter
+
+
+def _prepare_feature_values_for_streamlit(
+    feature_values_df: pd.DataFrame, shap_values: pd.DataFrame
+) -> tuple[pd.Series, pd.Series, Any]:
+    try:
+        from IPython import get_ipython
+        from snowbook.executor.python_transformer import IPythonProxy
+
+        assert isinstance(
+            get_ipython(), IPythonProxy
+        ), "Influence sensitivity plots for a DataFrame are not supported outside of Snowflake notebooks."
+    except ImportError:
+        raise RuntimeError(
+            "Influence sensitivity plots for a DataFrame are not supported outside of Snowflake notebooks."
+        )
+
+    import streamlit as st
+
+    feature_columns = feature_values_df.columns
+    chosen_ft: str = st.selectbox("Feature:", feature_columns)
+    feature_values = feature_values_df[chosen_ft]
+    shap_values = shap_values.iloc[:, feature_columns.get_loc(chosen_ft)]
+    return feature_values, shap_values, st
+
+
+def _create_scatter_plot(feature_values: pd.Series, shap_values: pd.Series, figsize: tuple[float, float]) -> alt.Chart:
     unique_vals = np.sort(np.unique(feature_values.values))
     max_points_per_unique_value = float(np.max(np.bincount(np.searchsorted(unique_vals, feature_values.values))))
     points_per_value = len(feature_values.values) / len(unique_vals)
@@ -224,7 +362,7 @@ def plot_influence_sensitivity(
 def plot_violin(
     shap_df: type_hints.SupportedDataType,
     feature_df: type_hints.SupportedDataType,
-    figsize: tuple[float, float] = (600, 200),
+    figsize: tuple[float, float] = DEFAULT_VIOLIN_FIGSIZE,
 ) -> alt.Chart:
     """
     Create a violin plot per feature showing the distribution of SHAP values.

snowflake/ml/monitoring/model_monitor.py

@@ -1,7 +1,5 @@
-from snowflake import snowpark
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.utils import sql_identifier
-from snowflake.ml.monitoring import model_monitor_version
 from snowflake.ml.monitoring._client import model_monitor_sql_client
 
 
@@ -29,7 +27,6 @@ class ModelMonitor:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def suspend(self) -> None:
         """Suspend the Model Monitor"""
         statement_params = telemetry.get_statement_params(
@@ -42,7 +39,6 @@ class ModelMonitor:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def resume(self) -> None:
         """Resume the Model Monitor"""
         statement_params = telemetry.get_statement_params(

snowflake/ml/registry/registry.py

@@ -14,7 +14,7 @@ from snowflake.ml.model import (
     type_hints as model_types,
 )
 from snowflake.ml.model._client.model import model_version_impl
-from snowflake.ml.monitoring import model_monitor, model_monitor_version
+from snowflake.ml.monitoring import model_monitor
 from snowflake.ml.monitoring._manager import model_monitor_manager
 from snowflake.ml.monitoring.entities import model_monitor_config
 from snowflake.ml.registry._manager import model_manager
@@ -30,6 +30,7 @@ _MODEL_MONITORING_DISABLED_ERROR = (
 
 
 class Registry:
+    @telemetry.send_api_usage_telemetry(project=_TELEMETRY_PROJECT, subproject=_MODEL_TELEMETRY_SUBPROJECT)
     def __init__(
         self,
         session: session.Session,
@@ -74,6 +75,22 @@ class Registry:
                 else sql_identifier.SqlIdentifier("PUBLIC")
             )
 
+        database_exists = session.sql(
+            f"""SELECT 1 FROM INFORMATION_SCHEMA.DATABASES WHERE DATABASE_NAME = '{self._database_name.resolved()}';"""
+        ).collect()
+
+        if not database_exists:
+            raise ValueError(f"Database {self._database_name} does not exist.")
+
+        schema_exists = session.sql(
+            f"""
+            SELECT 1 FROM {self._database_name.identifier()}.INFORMATION_SCHEMA.SCHEMATA
+            WHERE SCHEMA_NAME = '{self._schema_name.resolved()}';"""
+        ).collect()
+
+        if not schema_exists:
+            raise ValueError(f"Schema {self._schema_name} does not exist.")
+
         self._model_manager = model_manager.ModelManager(
             session,
             database_name=self._database_name,
@@ -155,7 +172,11 @@ class Registry:
                      `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
-                {"WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"}. Defaults to None.
+                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES":
+                - ["WAREHOUSE"]  (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"]  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] (Both)
+                Defaults to None. When None, the target platforms will be both.
             python_version: Python version in which the model is run. Defaults to None.
             signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
                 sample_input_data would be used to infer the signatures for those models that cannot automatically
@@ -295,8 +316,11 @@ class Registry:
                      `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
-                ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"]. Defaults to None. When None, the target platforms will be
-                both.
+                "WAREHOUSE" and "SNOWPARK_CONTAINER_SERVICES":
+                - ["WAREHOUSE"]  (Warehouse only)
+                - ["SNOWPARK_CONTAINER_SERVICES"]  (Snowpark Container Services only)
+                - ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"] (Both)
+                Defaults to None. When None, the target platforms will be both.
             python_version: Python version in which the model is run. Defaults to None.
             signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
                 sample_input_data would be used to infer the signatures for those models that cannot automatically
@@ -397,11 +421,11 @@ class Registry:
             if task is not model_types.Task.UNKNOWN:
                 raise ValueError("`task` cannot be specified when calling log_model with a ModelVersion.")
 
-        if pip_requirements:
+        if pip_requirements and not artifact_repository_map:
             warnings.warn(
-                "Models logged specifying `pip_requirements` can not be executed "
-                "in Snowflake Warehouse where all dependencies are required to be retrieved "
-                "from Snowflake Anaconda Channel.",
+                "Models logged specifying `pip_requirements` cannot be executed in a Snowflake Warehouse "
+                "without specifying `artifact_repository_map`. This model can be run in Snowpark Container "
+                "Services. See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container.",
                 category=UserWarning,
                 stacklevel=1,
             )
@@ -500,7 +524,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def add_monitor(
         self,
         name: str,
@@ -525,7 +548,7 @@ class Registry:
         return self._model_monitor_manager.add_monitor(name, source_config, model_monitor_config)
 
     @overload
-    def get_monitor(self, model_version: model_version_impl.ModelVersion) -> model_monitor.ModelMonitor:
+    def get_monitor(self, *, model_version: model_version_impl.ModelVersion) -> model_monitor.ModelMonitor:
         """Get a Model Monitor on a Model Version from the Registry.
 
         Args:
@@ -534,7 +557,7 @@ class Registry:
         ...
 
     @overload
-    def get_monitor(self, name: str) -> model_monitor.ModelMonitor:
+    def get_monitor(self, *, name: str) -> model_monitor.ModelMonitor:
         """Get a Model Monitor by name from the Registry.
 
         Args:
@@ -546,7 +569,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def get_monitor(
         self, *, name: Optional[str] = None, model_version: Optional[model_version_impl.ModelVersion] = None
     ) -> model_monitor.ModelMonitor:
@@ -575,7 +597,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def show_model_monitors(self) -> list[snowpark.Row]:
         """Show all model monitors in the registry.
 
@@ -593,7 +614,6 @@ class Registry:
         project=telemetry.TelemetryProject.MLOPS.value,
         subproject=telemetry.TelemetrySubProject.MONITORING.value,
     )
-    @snowpark._internal.utils.private_preview(version=model_monitor_version.SNOWFLAKE_ML_MONITORING_MIN_VERSION)
     def delete_monitor(self, name: str) -> None:
         """Delete a Model Monitor by name from the Registry.
 

snowflake/ml/utils/connection_params.py

@@ -113,6 +113,10 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
 
     config = configparser.ConfigParser(inline_comment_prefixes="#")
 
+    snowflake_connection_name = os.getenv("SNOWFLAKE_CONNECTION_NAME")
+    if snowflake_connection_name is not None:
+        connection_name = snowflake_connection_name
+
     if connection_name:
         if not connection_name.startswith("connections."):
             connection_name = "connections." + connection_name
@@ -132,7 +136,7 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
     return conn_params
 
 
-@snowpark._internal.utils.private_preview(version="0.2.0")
+@snowpark._internal.utils.deprecated(version="1.8.5")
 def SnowflakeLoginOptions(connection_name: str = "", login_file: Optional[str] = None) -> dict[str, Union[str, bytes]]:
     """Returns a dict that can be used directly into snowflake python connector or Snowpark session config.
 
@@ -153,9 +157,11 @@ def SnowflakeLoginOptions(connection_name: str = "", login_file: Optional[str] =
       Ideally one should have a snowsql config file. Read more here:
       https://docs.snowflake.com/en/user-guide/snowsql-start.html#configuring-default-connection-settings
 
+      If snowsql config file does not exist, it tries auth from env variables.
+
     Args:
-        connection_name: Name of the connection to look for inside the config file. If `connection_name` is NOT given,
-            it tries auth from env variables.
+        connection_name: Name of the connection to look for inside the config file. If environment variable
+            SNOWFLAKE_CONNECTION_NAME is provided, it will override the input connection_name.
         login_file: If provided, this is used as config file instead of default one (_DEFAULT_CONNECTION_FILE).
 
     Returns: