snowflake-ml-python 1.3.1__py3-none-any.whl → 1.4.1__py3-none-any.whl

snowflake/ml/_internal/env_utils.py

@@ -18,7 +18,7 @@ from snowflake.ml._internal.exceptions import (
     exceptions as snowml_exceptions,
 )
 from snowflake.ml._internal.utils import query_result_checker
-from snowflake.snowpark import session
+from snowflake.snowpark import context, exceptions, session
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 
@@ -332,6 +332,16 @@ def get_matched_package_versions_in_snowflake_conda_channel(
     return matched_versions
 
 
+def get_matched_package_versions_in_information_schema_with_active_session(
+    reqs: List[requirements.Requirement], python_version: str
+) -> Dict[str, List[version.Version]]:
+    try:
+        session = context.get_active_session()
+    except exceptions.SnowparkSessionException:
+        return {}
+    return get_matched_package_versions_in_information_schema(session, reqs, python_version)
+
+
 def get_matched_package_versions_in_information_schema(
     session: session.Session, reqs: List[requirements.Requirement], python_version: str
 ) -> Dict[str, List[version.Version]]:

snowflake/ml/_internal/human_readable_id/adjectives.txt

@@ -0,0 +1,128 @@
+afraid
+ancient
+angry
+average
+bad
+big
+bitter
+black
+blue
+brave
+breezy
+bright
+brown
+calm
+chatty
+chilly
+clever
+cold
+cowardly
+cuddly
+curly
+curvy
+dangerous
+dry
+dull
+empty
+evil
+fast
+fat
+fluffy
+foolish
+fresh
+friendly
+funny
+gentle
+giant
+good
+great
+green
+grumpy
+happy
+hard
+heavy
+helpless
+honest
+horrible
+hot
+hungry
+itchy
+jolly
+kind
+lazy
+light
+little
+loud
+lovely
+lucky
+massive
+mean
+mighty
+modern
+moody
+nasty
+neat
+nervous
+new
+nice
+odd
+old
+orange
+ordinary
+perfect
+pink
+plastic
+polite
+popular
+pretty
+proud
+purple
+quick
+quiet
+rare
+red
+rotten
+rude
+selfish
+serious
+shaggy
+sharp
+short
+shy
+silent
+silly
+slimy
+slippery
+smart
+smooth
+soft
+sour
+spicy
+splendid
+spotty
+stale
+strange
+strong
+stupid
+sweet
+swift
+tall
+tame
+tasty
+tender
+terrible
+thin
+tidy
+tiny
+tough
+tricky
+ugly
+warm
+weak
+wet
+wicked
+wise
+witty
+wonderful
+yellow
+young

snowflake/ml/_internal/human_readable_id/animals.txt

@@ -0,0 +1,128 @@
+anaconda
+ant
+ape
+baboon
+badger
+bat
+bear
+bird
+bobcat
+bulldog
+bullfrog
+camel
+canary
+capybara
+cat
+catfish
+cheetah
+chicken
+chipmunk
+cobra
+cougar
+cow
+crab
+deer
+dingo
+dodo
+dog
+dolphin
+donkey
+dragon
+dragonfly
+duck
+eagle
+earwig
+eel
+egret
+elephant
+emu
+falcon
+fireant
+firefox
+fish
+fly
+fox
+frog
+gazelle
+gecko
+gibbon
+giraffe
+goat
+goose
+gorilla
+grasshopper
+horse
+hound
+husky
+impala
+insect
+jackal
+jaguar
+jellyfish
+kangaroo
+kiwi
+ladybug
+leech
+leopard
+llama
+liger
+lion
+lionfish
+lizard
+lobster
+mayfly
+mamba
+mole
+monkey
+moose
+moth
+mouse
+mule
+newt
+octopus
+otter
+owl
+panda
+panther
+parrot
+penguin
+pig
+puma
+pug
+python
+quail
+rabbit
+ram
+rat
+ray
+rattlesnake
+robin
+salmon
+seahorse
+seal
+shark
+sheep
+shrimp
+skunk
+sloth
+snail
+snake
+squid
+starfish
+stingray
+swan
+termite
+tiger
+treefrog
+turkey
+turtle
+vampirebat
+walrus
+warthog
+wasp
+wolverine
+wombat
+worm
+yak
+yeti
+zebra

snowflake/ml/_internal/human_readable_id/hrid_generator.py

@@ -0,0 +1,40 @@
+"""Implement a generator for human readable ID (HRID).
+
+The original idea for this comes from Asana where it is documented on their
+blog:
+    http://blog.asana.com/2011/09/6-sad-squid-snuggle-softly/
+
+There are other partial implementations of this and can be found here:
+    Node.js: https://github.com/linus/greg
+    Java: https://github.com/PerWiklander/IdentifierSentence
+
+In this module you will find:
+
+    HRID16: An implementation of HRIDBase for 16 bit integers.
+
+The list used here is coming from:
+    https://git.coolaj86.com/coolaj86/human-readable-ids.js
+"""
+
+import random
+
+import importlib_resources
+
+from snowflake.ml._internal import human_readable_id
+from snowflake.ml._internal.human_readable_id import hrid_generator_base
+
+
+class HRID16(hrid_generator_base.HRIDBase):
+    """An implementation of HRIDBase for 16 bit integers."""
+
+    def __id_generator__(self) -> int:
+        return int(random.getrandbits(16))
+
+    __hrid_structure__ = ("adjective", "animal", "number")
+    __hrid_words__ = dict(
+        number=tuple(str(x) for x in range(1, 5)),
+        adjective=tuple(
+            importlib_resources.files(human_readable_id).joinpath("adjectives.txt").read_text("utf-8").split()
+        ),
+        animal=tuple(importlib_resources.files(human_readable_id).joinpath("animals.txt").read_text("utf-8").split()),
+    )

snowflake/ml/_internal/human_readable_id/hrid_generator_base.py

@@ -0,0 +1,135 @@
+"""Implement a generator for human readable ID (HRID).
+
+The original idea for this comes from Asana where it is documented on their
+blog:
+    http://blog.asana.com/2011/09/6-sad-squid-snuggle-softly/
+
+There are other partial implementations of this and can be found here:
+    Node.js: https://github.com/linus/greg
+    Java: https://github.com/PerWiklander/IdentifierSentence
+
+In this module you will find:
+
+    HRIDBase: The base class for all human readable id.
+"""
+
+import math
+from abc import ABC, abstractmethod
+from typing import Dict, List, Tuple
+
+
+class HRIDBase(ABC):
+    """The base class for all all human readable id.
+
+    This provides all of the necessary helper functionality to turn IDs into
+    HRIDs and HRIDs into IDs. ID typically is a random int, while HRID is a corresponding short string.
+    """
+
+    @abstractmethod
+    def __id_generator__(self) -> int:
+        """The generator to use to generate new IDs. The implementer needs to provide this."""
+        pass
+
+    __hrid_structure__: Tuple[str, ...]
+    """The HRID structure to be generated. The implementer needs to provide this."""
+
+    __hrid_words__: Dict[str, Tuple[str, ...]]
+    """The mapping between the HRID parts and the words to use. The implementer needs to provide this."""
+
+    __separator__ = "_"
+
+    def __init__(self) -> None:
+        self._part_n_words = dict()
+        self._part_bits = dict()
+        for part in self.__hrid_structure__:
+            n_words = len(self.__hrid_words__[part])
+            self._part_n_words[part] = n_words
+            if not (n_words > 0 and ((n_words & (n_words - 1)) == 0)):
+                raise ValueError(f"{part} part has {n_words} words, which is not a power of 2")
+            self._part_bits[part] = int(math.log(self._part_n_words[part], 2))
+        self.__total_bits__ = sum(v for v in self._part_bits.values())
+
+    def hrid_to_id(self, hrid: str) -> int:
+        """Take the HRID and convert it the ID.
+
+        Args:
+            hrid: The HRID to convert into an ID
+
+        Returns:
+            The ID represented by the HRID
+        """
+        idxs = self._hrid_to_idxs(hrid)
+        id = 0
+        for i in range(len(idxs)):
+            part = self.__hrid_structure__[i]
+            id = (id << self._part_bits[part]) + idxs[i]
+        return id
+
+    def id_to_hrid(self, id: int) -> str:
+        """Take the ID and convert it a HRID.
+
+        Args:
+            id: The ID to convert into a HRID
+
+        Returns:
+            The HRID represented by the ID
+        """
+        idxs = self._id_to_idxs(id)
+        hrid = []
+        for i in range(len(self.__hrid_structure__)):
+            part = self.__hrid_structure__[i]
+            values = self.__hrid_words__[part]
+            hrid.append(str(values[idxs[i]]))
+        return self.__separator__.join(hrid)
+
+    def generate(self) -> Tuple[int, str]:
+        """Generate an ID and the corresponding HRID.
+
+        Returns:
+            A tuple containing the id and the HRID
+        """
+        id = self.__id_generator__()
+        hrid = self.id_to_hrid(id)
+        return (id, hrid)
+
+    def _id_to_idxs(self, id: int) -> List[int]:
+        """Take the ID and convert it to indices into the HRID words.
+
+        Args:
+            id: The ID to convert into indices
+
+        Returns:
+            A list of indices into the HRID words
+        """
+        shift = self.__total_bits__
+        idxs = []
+        for part in self.__hrid_structure__:
+            shift -= self._part_bits[part]
+            mask = (self._part_n_words[part] - 1) << shift
+            idxs.append((id & mask) >> shift)
+        return idxs
+
+    def _hrid_to_idxs(self, hrid: str) -> List[int]:
+        """Take the HRID and convert it to indices into the HRID words.
+
+        Args:
+            hrid: The HRID to convert into indices
+
+        Raises:
+            ValueError: Raised when the input does not meet the structure.
+
+        Returns:
+            A list of indices into the HRID words
+        """
+        split_hrid = hrid.split(self.__separator__)
+        if len(split_hrid) != len(self.__hrid_structure__):
+            raise ValueError(
+                ("The hrid must have {} parts and be of the form {}").format(
+                    len(self.__hrid_structure__), self.__hrid_structure__
+                )
+            )
+        idxs = []
+        for i in range(len(self.__hrid_structure__)):
+            part = self.__hrid_structure__[i]
+            idxs.append(self.__hrid_words__[part].index(split_hrid[i]))
+        return idxs

snowflake/ml/_internal/utils/formatting.py

@@ -1,7 +1,7 @@
 """String formatting utilities for general use in the SnowML Reposiory.
 
 This file contains a collection of utilities that help with formatting strings. Functionality is not limited to tests
-only. Anything that is re-usable across different modules and related to string formatting should go here.
+only. Anything that is reusable across different modules and related to string formatting should go here.
 """
 
 import re

snowflake/ml/_internal/utils/identifier.py

@@ -338,4 +338,6 @@ def resolve_identifier(name: str) -> str:
     elif UNQUOTED_CASE_INSENSITIVE_RE.match(name):
         return name.upper()
     else:
-        raise ValueError(f"Invalid name {name} passed. ID is not quoted and cannot normalized.")
+        raise ValueError(
+            f"{name} is not a valid SQL identifier: https://docs.snowflake.com/en/sql-reference/identifiers-syntax"
+        )

snowflake/ml/_internal/utils/sql_identifier.py

@@ -27,15 +27,11 @@ class SqlIdentifier(str):
                 automatically added if necessary to make sure the original input's cases are preserved.
                 Default to False.
 
-        Raises:
-            ValueError: input name is not a valid identifier.
-
         Returns:
             Returns new instance created.
         """
-        # TODO (wezhou) add stronger validation to recognize a valid snowflake identifier.
-        if not name:
-            raise ValueError(f"name:`{name}` is not a valid identifier.")
+        assert name is not None
+
         if case_sensitive:
             return super().__new__(cls, identifier.get_inferred_name(name))
         else: