snowflake-ml-python 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

snowflake/ml/_internal/env_utils.py

@@ -294,19 +294,22 @@ def get_matched_package_versions_in_snowflake_conda_channel(
     url = f"{_SNOWFLAKE_CONDA_CHANNEL_URL}/{conda_os.value}/repodata.json"
 
     if req.name not in _SNOWFLAKE_CONDA_PACKAGE_CACHE:
-        http_client = retryable_http.get_http_client()
-        parsed_python_version = version.Version(python_version)
-        python_version_build_str = f"py{parsed_python_version.major}{parsed_python_version.minor}"
-        repodata = http_client.get(url).json()
-        assert isinstance(repodata, dict)
-        packages_info = repodata["packages"]
-        assert isinstance(packages_info, dict)
-        version_list = [
-            version.parse(package_info["version"])
-            for package_info in packages_info.values()
-            if package_info["name"] == req.name and python_version_build_str in package_info["build"]
-        ]
-        _SNOWFLAKE_CONDA_PACKAGE_CACHE[req.name] = version_list
+        try:
+            http_client = retryable_http.get_http_client()
+            parsed_python_version = version.Version(python_version)
+            python_version_build_str = f"py{parsed_python_version.major}{parsed_python_version.minor}"
+            repodata = http_client.get(url).json()
+            assert isinstance(repodata, dict)
+            packages_info = repodata["packages"]
+            assert isinstance(packages_info, dict)
+            version_list = [
+                version.parse(package_info["version"])
+                for package_info in packages_info.values()
+                if package_info["name"] == req.name and python_version_build_str in package_info["build"]
+            ]
+            _SNOWFLAKE_CONDA_PACKAGE_CACHE[req.name] = version_list
+        except Exception:
+            pass
 
     matched_versions = list(req.specifier.filter(set(_SNOWFLAKE_CONDA_PACKAGE_CACHE.get(req.name, []))))
     return matched_versions

snowflake/ml/_internal/exceptions/modeling_error_messages.py

@@ -1,4 +1,8 @@
-ATTRIBUTE_NOT_SET = "{} is not set."
+ATTRIBUTE_NOT_SET = (
+    "{} is not set. To read more about Snowpark ML general API differences, please refer to: "
+    "https://docs.snowflake.com/en/developer-guide/snowpark-ml/snowpark-ml-modeling#general-api"
+    "-differences."
+)
 SIZE_MISMATCH = "Size mismatch: {}={}, {}={}."
 INVALID_MODEL_PARAM = "Invalid parameter {} for model {}. Valid parameters: {}."
 UNSUPPORTED_MODEL_CONVERSION = "Object doesn't support {}. Please use {}."

snowflake/ml/_internal/telemetry.py

@@ -584,3 +584,22 @@ class _SourceTelemetryClient:
         """Send the telemetry data batch immediately."""
         if self._telemetry:
             self._telemetry.send_batch()
+
+
+def get_sproc_statement_params_kwargs(sproc: Callable[..., Any], statement_params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Get statement_params keyword argument for sproc call.
+
+    Args:
+        sproc: sproc function
+        statement_params: dictionary to be passed as statement params, if possible
+
+    Returns:
+        Keyword arguments dict
+    """
+    sproc_argspec = inspect.getfullargspec(sproc)
+    kwargs = {}
+    if "statement_params" in sproc_argspec.args:
+        kwargs["statement_params"] = statement_params
+
+    return kwargs

snowflake/ml/feature_store/__init__.py

@@ -0,0 +1,9 @@
+import os
+
+from snowflake.ml._internal import init_utils
+
+pkg_dir = os.path.dirname(os.path.abspath(__file__))
+pkg_name = __name__
+exportable_classes = init_utils.fetch_classes_from_modules_in_pkg_dir(pkg_dir=pkg_dir, pkg_name=pkg_name)
+for k, v in exportable_classes.items():
+    globals()[k] = v

snowflake/ml/feature_store/entity.py

@@ -0,0 +1,73 @@
+from typing import Dict, List
+
+from snowflake.ml._internal.utils.sql_identifier import (
+    SqlIdentifier,
+    to_sql_identifiers,
+)
+
+_ENTITY_NAME_LENGTH_LIMIT = 32
+_FEATURE_VIEW_ENTITY_TAG_DELIMITER = ","
+_ENTITY_JOIN_KEY_DELIMITER = ","
+# join key length limit is the length limit of TAG value
+_ENTITY_JOIN_KEY_LENGTH_LIMIT = 256
+# The maximum number of join keys:
+#   https://docs.snowflake.com/en/user-guide/object-tagging#specify-tag-values
+_ENTITY_MAX_NUM_JOIN_KEYS = 300
+
+
+class Entity:
+    """
+    Entity encapsulates additional metadata for feature definition.
+    Entity is typically used together with FeatureView to define join_keys and associate relevant FeatureViews.
+    It can also be used for FeatureView search and lineage tracking.
+    """
+
+    def __init__(self, name: str, join_keys: List[str], desc: str = "") -> None:
+        """
+        Creates an Entity instance.
+
+        Args:
+            name: name of the Entity.
+            join_keys: join keys associated with a FeatureView, used for feature retrieval.
+            desc: description of the Entity.
+        """
+        self._validate(name, join_keys)
+
+        self.name: SqlIdentifier = SqlIdentifier(name)
+        self.join_keys: List[SqlIdentifier] = to_sql_identifiers(join_keys)
+        self.desc = desc
+
+    def _validate(self, name: str, join_keys: List[str]) -> None:
+        if len(name) > _ENTITY_NAME_LENGTH_LIMIT:
+            raise ValueError(f"Entity name `{name}` exceeds maximum length: {_ENTITY_NAME_LENGTH_LIMIT}")
+        if _FEATURE_VIEW_ENTITY_TAG_DELIMITER in name:
+            raise ValueError(f"Entity name contains invalid char: `{_FEATURE_VIEW_ENTITY_TAG_DELIMITER}`")
+        if len(join_keys) > _ENTITY_MAX_NUM_JOIN_KEYS:
+            raise ValueError(
+                f"Maximum number of join keys are {_ENTITY_MAX_NUM_JOIN_KEYS}, " "but {len(join_keys)} is provided."
+            )
+        if len(set(join_keys)) != len(join_keys):
+            raise ValueError(f"Duplicate join keys detected in: {join_keys}")
+        for k in join_keys:
+            # TODO(wezhou) move this logic into SqlIdentifier.
+            if _ENTITY_JOIN_KEY_DELIMITER in k:
+                raise ValueError(f"Invalid char `{_ENTITY_JOIN_KEY_DELIMITER}` detected in join key {k}")
+            if len(k) > _ENTITY_JOIN_KEY_LENGTH_LIMIT:
+                raise ValueError(f"Join key: {k} exceeds length limit {_ENTITY_JOIN_KEY_LENGTH_LIMIT}.")
+
+    def _to_dict(self) -> Dict[str, str]:
+        entity_dict = self.__dict__.copy()
+        for k, v in entity_dict.items():
+            if isinstance(v, SqlIdentifier):
+                entity_dict[k] = str(v)
+        return entity_dict
+
+    def __repr__(self) -> str:
+        states = (f"{k}={v}" for k, v in vars(self).items())
+        return f"{type(self).__name__}({', '.join(states)})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Entity):
+            return False
+
+        return self.name == other.name and self.desc == other.desc and self.join_keys == other.join_keys