snowpark-connect 0.20.2__py3-none-any.whl

snowflake/snowpark_connect/includes/python/pyspark/mllib/stat/KernelDensity.py

@@ -0,0 +1,59 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from typing import Iterable, Optional
+
+import numpy as np
+from numpy import ndarray
+
+from pyspark.mllib.common import callMLlibFunc
+from pyspark.rdd import RDD
+
+
+class KernelDensity:
+    """
+    Estimate probability density at required points given an RDD of samples
+    from the population.
+
+    Examples
+    --------
+    >>> kd = KernelDensity()
+    >>> sample = sc.parallelize([0.0, 1.0])
+    >>> kd.setSample(sample)
+    >>> kd.estimate([0.0, 1.0])
+    array([ 0.12938758,  0.12938758])
+    """
+
+    def __init__(self) -> None:
+        self._bandwidth: float = 1.0
+        self._sample: Optional[RDD[float]] = None
+
+    def setBandwidth(self, bandwidth: float) -> None:
+        """Set bandwidth of each sample. Defaults to 1.0"""
+        self._bandwidth = bandwidth
+
+    def setSample(self, sample: RDD[float]) -> None:
+        """Set sample points from the population. Should be a RDD"""
+        if not isinstance(sample, RDD):
+            raise TypeError("samples should be a RDD, received %s" % type(sample))
+        self._sample = sample
+
+    def estimate(self, points: Iterable[float]) -> ndarray:
+        """Estimate the probability density at points"""
+        points = list(points)
+        densities = callMLlibFunc("estimateKernelDensity", self._sample, self._bandwidth, points)
+        return np.asarray(densities)

snowflake/snowpark_connect/includes/python/pyspark/mllib/stat/__init__.py

@@ -0,0 +1,34 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Python package for statistical functions in MLlib.
+"""
+
+from pyspark.mllib.stat._statistics import Statistics, MultivariateStatisticalSummary
+from pyspark.mllib.stat.distribution import MultivariateGaussian
+from pyspark.mllib.stat.test import ChiSqTestResult, KolmogorovSmirnovTestResult
+from pyspark.mllib.stat.KernelDensity import KernelDensity
+
+__all__ = [
+    "Statistics",
+    "MultivariateStatisticalSummary",
+    "ChiSqTestResult",
+    "KolmogorovSmirnovTestResult",
+    "MultivariateGaussian",
+    "KernelDensity",
+]

snowflake/snowpark_connect/includes/python/pyspark/mllib/stat/_statistics.py

@@ -0,0 +1,409 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import sys
+from typing import cast, overload, List, Optional, TYPE_CHECKING, Union
+
+from numpy import ndarray
+from py4j.java_gateway import JavaObject
+
+from pyspark.rdd import RDD
+from pyspark.mllib.common import callMLlibFunc, JavaModelWrapper
+from pyspark.mllib.linalg import Matrix, Vector, _convert_to_vector
+from pyspark.mllib.regression import LabeledPoint
+from pyspark.mllib.stat.test import ChiSqTestResult, KolmogorovSmirnovTestResult
+
+if TYPE_CHECKING:
+    from pyspark.mllib._typing import CorrMethodType, KolmogorovSmirnovTestDistNameType
+
+__all__ = ["MultivariateStatisticalSummary", "Statistics"]
+
+
+class MultivariateStatisticalSummary(JavaModelWrapper):
+
+    """
+    Trait for multivariate statistical summary of a data matrix.
+    """
+
+    def mean(self) -> ndarray:
+        return cast(JavaObject, self.call("mean")).toArray()
+
+    def variance(self) -> ndarray:
+        return cast(JavaObject, self.call("variance")).toArray()
+
+    def count(self) -> int:
+        return int(self.call("count"))
+
+    def numNonzeros(self) -> ndarray:
+        return cast(JavaObject, self.call("numNonzeros")).toArray()
+
+    def max(self) -> ndarray:
+        return cast(JavaObject, self.call("max")).toArray()
+
+    def min(self) -> ndarray:
+        return cast(JavaObject, self.call("min")).toArray()
+
+    def normL1(self) -> ndarray:
+        return cast(JavaObject, self.call("normL1")).toArray()
+
+    def normL2(self) -> ndarray:
+        return cast(JavaObject, self.call("normL2")).toArray()
+
+
+class Statistics:
+    @staticmethod
+    def colStats(rdd: RDD[Vector]) -> MultivariateStatisticalSummary:
+        """
+        Computes column-wise summary statistics for the input RDD[Vector].
+
+        Parameters
+        ----------
+        rdd : :py:class:`pyspark.RDD`
+            an RDD[Vector] for which column-wise summary statistics
+            are to be computed.
+
+        Returns
+        -------
+        :class:`MultivariateStatisticalSummary`
+            object containing column-wise summary statistics.
+
+        Examples
+        --------
+        >>> from pyspark.mllib.linalg import Vectors
+        >>> rdd = sc.parallelize([Vectors.dense([2, 0, 0, -2]),
+        ...                       Vectors.dense([4, 5, 0,  3]),
+        ...                       Vectors.dense([6, 7, 0,  8])])
+        >>> cStats = Statistics.colStats(rdd)
+        >>> cStats.mean()
+        array([ 4.,  4.,  0.,  3.])
+        >>> cStats.variance()
+        array([  4.,  13.,   0.,  25.])
+        >>> cStats.count()
+        3
+        >>> cStats.numNonzeros()
+        array([ 3.,  2.,  0.,  3.])
+        >>> cStats.max()
+        array([ 6.,  7.,  0.,  8.])
+        >>> cStats.min()
+        array([ 2.,  0.,  0., -2.])
+        """
+        cStats = callMLlibFunc("colStats", rdd.map(_convert_to_vector))
+        return MultivariateStatisticalSummary(cStats)
+
+    @overload
+    @staticmethod
+    def corr(x: RDD[Vector], *, method: Optional["CorrMethodType"] = ...) -> Matrix:
+        ...
+
+    @overload
+    @staticmethod
+    def corr(x: RDD[float], y: RDD[float], method: Optional["CorrMethodType"] = ...) -> float:
+        ...
+
+    @staticmethod
+    def corr(
+        x: Union[RDD[Vector], RDD[float]],
+        y: Optional[RDD[float]] = None,
+        method: Optional["CorrMethodType"] = None,
+    ) -> Union[float, Matrix]:
+        """
+        Compute the correlation (matrix) for the input RDD(s) using the
+        specified method.
+        Methods currently supported: `pearson (default), spearman`.
+
+        If a single RDD of Vectors is passed in, a correlation matrix
+        comparing the columns in the input RDD is returned. Use `method`
+        to specify the method to be used for single RDD inout.
+        If two RDDs of floats are passed in, a single float is returned.
+
+        Parameters
+        ----------
+        x : :py:class:`pyspark.RDD`
+            an RDD of vector for which the correlation matrix is to be computed,
+            or an RDD of float of the same cardinality as y when y is specified.
+        y : :py:class:`pyspark.RDD`, optional
+            an RDD of float of the same cardinality as x.
+        method : str, optional
+            String specifying the method to use for computing correlation.
+            Supported: `pearson` (default), `spearman`
+
+        Returns
+        -------
+        :py:class:`pyspark.mllib.linalg.Matrix`
+            Correlation matrix comparing columns in x.
+
+        Examples
+        --------
+        >>> x = sc.parallelize([1.0, 0.0, -2.0], 2)
+        >>> y = sc.parallelize([4.0, 5.0, 3.0], 2)
+        >>> zeros = sc.parallelize([0.0, 0.0, 0.0], 2)
+        >>> abs(Statistics.corr(x, y) - 0.6546537) < 1e-7
+        True
+        >>> Statistics.corr(x, y) == Statistics.corr(x, y, "pearson")
+        True
+        >>> Statistics.corr(x, y, "spearman")
+        0.5
+        >>> from math import isnan
+        >>> isnan(Statistics.corr(x, zeros))
+        True
+        >>> from pyspark.mllib.linalg import Vectors
+        >>> rdd = sc.parallelize([Vectors.dense([1, 0, 0, -2]), Vectors.dense([4, 5, 0, 3]),
+        ...                       Vectors.dense([6, 7, 0,  8]), Vectors.dense([9, 0, 0, 1])])
+        >>> pearsonCorr = Statistics.corr(rdd)
+        >>> print(str(pearsonCorr).replace('nan', 'NaN'))
+        [[ 1.          0.05564149         NaN  0.40047142]
+         [ 0.05564149  1.                 NaN  0.91359586]
+         [        NaN         NaN  1.                 NaN]
+         [ 0.40047142  0.91359586         NaN  1.        ]]
+        >>> spearmanCorr = Statistics.corr(rdd, method="spearman")
+        >>> print(str(spearmanCorr).replace('nan', 'NaN'))
+        [[ 1.          0.10540926         NaN  0.4       ]
+         [ 0.10540926  1.                 NaN  0.9486833 ]
+         [        NaN         NaN  1.                 NaN]
+         [ 0.4         0.9486833          NaN  1.        ]]
+        >>> try:
+        ...     Statistics.corr(rdd, "spearman")
+        ...     print("Method name as second argument without 'method=' shouldn't be allowed.")
+        ... except TypeError:
+        ...     pass
+        """
+        # Check inputs to determine whether a single value or a matrix is needed for output.
+        # Since it's legal for users to use the method name as the second argument, we need to
+        # check if y is used to specify the method name instead.
+        if type(y) == str:
+            raise TypeError("Use 'method=' to specify method name.")
+
+        if not y:
+            return cast(
+                JavaObject, callMLlibFunc("corr", x.map(_convert_to_vector), method)
+            ).toArray()
+        else:
+            return cast(
+                float,
+                callMLlibFunc("corr", cast(RDD[float], x).map(float), y.map(float), method),
+            )
+
+    @overload
+    @staticmethod
+    def chiSqTest(observed: Matrix) -> ChiSqTestResult:
+        ...
+
+    @overload
+    @staticmethod
+    def chiSqTest(observed: Vector, expected: Optional[Vector] = ...) -> ChiSqTestResult:
+        ...
+
+    @overload
+    @staticmethod
+    def chiSqTest(observed: RDD[LabeledPoint]) -> List[ChiSqTestResult]:
+        ...
+
+    @staticmethod
+    def chiSqTest(
+        observed: Union[Matrix, RDD[LabeledPoint], Vector], expected: Optional[Vector] = None
+    ) -> Union[ChiSqTestResult, List[ChiSqTestResult]]:
+        """
+        If `observed` is Vector, conduct Pearson's chi-squared goodness
+        of fit test of the observed data against the expected distribution,
+        or against the uniform distribution (by default), with each category
+        having an expected frequency of `1 / len(observed)`.
+
+        If `observed` is matrix, conduct Pearson's independence test on the
+        input contingency matrix, which cannot contain negative entries or
+        columns or rows that sum up to 0.
+
+        If `observed` is an RDD of LabeledPoint, conduct Pearson's independence
+        test for every feature against the label across the input RDD.
+        For each feature, the (feature, label) pairs are converted into a
+        contingency matrix for which the chi-squared statistic is computed.
+        All label and feature values must be categorical.
+
+        Parameters
+        ----------
+        observed : :py:class:`pyspark.mllib.linalg.Vector` or \
+            :py:class:`pyspark.mllib.linalg.Matrix`
+            it could be a vector containing the observed categorical
+            counts/relative frequencies, or the contingency matrix
+            (containing either counts or relative frequencies),
+            or an RDD of LabeledPoint containing the labeled dataset
+            with categorical features. Real-valued features will be
+            treated as categorical for each distinct value.
+        expected : :py:class:`pyspark.mllib.linalg.Vector`
+            Vector containing the expected categorical counts/relative
+            frequencies. `expected` is rescaled if the `expected` sum
+            differs from the `observed` sum.
+
+        Returns
+        -------
+        :py:class:`pyspark.mllib.stat.ChiSqTestResult`
+            object containing the test statistic, degrees
+            of freedom, p-value, the method used, and the null hypothesis.
+
+        Notes
+        -----
+        `observed` cannot contain negative values
+
+        Examples
+        --------
+        >>> from pyspark.mllib.linalg import Vectors, Matrices
+        >>> observed = Vectors.dense([4, 6, 5])
+        >>> pearson = Statistics.chiSqTest(observed)
+        >>> print(pearson.statistic)
+        0.4
+        >>> pearson.degreesOfFreedom
+        2
+        >>> print(round(pearson.pValue, 4))
+        0.8187
+        >>> pearson.method
+        'pearson'
+        >>> pearson.nullHypothesis
+        'observed follows the same distribution as expected.'
+
+        >>> observed = Vectors.dense([21, 38, 43, 80])
+        >>> expected = Vectors.dense([3, 5, 7, 20])
+        >>> pearson = Statistics.chiSqTest(observed, expected)
+        >>> print(round(pearson.pValue, 4))
+        0.0027
+
+        >>> data = [40.0, 24.0, 29.0, 56.0, 32.0, 42.0, 31.0, 10.0, 0.0, 30.0, 15.0, 12.0]
+        >>> chi = Statistics.chiSqTest(Matrices.dense(3, 4, data))
+        >>> print(round(chi.statistic, 4))
+        21.9958
+
+        >>> data = [LabeledPoint(0.0, Vectors.dense([0.5, 10.0])),
+        ...         LabeledPoint(0.0, Vectors.dense([1.5, 20.0])),
+        ...         LabeledPoint(1.0, Vectors.dense([1.5, 30.0])),
+        ...         LabeledPoint(0.0, Vectors.dense([3.5, 30.0])),
+        ...         LabeledPoint(0.0, Vectors.dense([3.5, 40.0])),
+        ...         LabeledPoint(1.0, Vectors.dense([3.5, 40.0])),]
+        >>> rdd = sc.parallelize(data, 4)
+        >>> chi = Statistics.chiSqTest(rdd)
+        >>> print(chi[0].statistic)
+        0.75
+        >>> print(chi[1].statistic)
+        1.5
+        """
+        if isinstance(observed, RDD):
+            if not isinstance(observed.first(), LabeledPoint):
+                raise ValueError("observed should be an RDD of LabeledPoint")
+            jmodels = callMLlibFunc("chiSqTest", observed)
+            return [ChiSqTestResult(m) for m in jmodels]
+
+        if isinstance(observed, Matrix):
+            jmodel = callMLlibFunc("chiSqTest", observed)
+        else:
+            if expected and len(expected) != len(observed):
+                raise ValueError("`expected` should have same length with `observed`")
+            jmodel = callMLlibFunc("chiSqTest", _convert_to_vector(observed), expected)
+        return ChiSqTestResult(jmodel)
+
+    @staticmethod
+    def kolmogorovSmirnovTest(
+        data: RDD[float], distName: "KolmogorovSmirnovTestDistNameType" = "norm", *params: float
+    ) -> KolmogorovSmirnovTestResult:
+        """
+        Performs the Kolmogorov-Smirnov (KS) test for data sampled from
+        a continuous distribution. It tests the null hypothesis that
+        the data is generated from a particular distribution.
+
+        The given data is sorted and the Empirical Cumulative
+        Distribution Function (ECDF) is calculated
+        which for a given point is the number of points having a CDF
+        value lesser than it divided by the total number of points.
+
+        Since the data is sorted, this is a step function
+        that rises by (1 / length of data) for every ordered point.
+
+        The KS statistic gives us the maximum distance between the
+        ECDF and the CDF. Intuitively if this statistic is large, the
+        probability that the null hypothesis is true becomes small.
+        For specific details of the implementation, please have a look
+        at the Scala documentation.
+
+
+        Parameters
+        ----------
+        data : :py:class:`pyspark.RDD`
+            RDD, samples from the data
+        distName : str, optional
+            string, currently only "norm" is supported.
+            (Normal distribution) to calculate the
+            theoretical distribution of the data.
+        params
+            additional values which need to be provided for
+            a certain distribution.
+            If not provided, the default values are used.
+
+        Returns
+        -------
+        :py:class:`pyspark.mllib.stat.KolmogorovSmirnovTestResult`
+            object containing the test statistic, degrees of freedom, p-value,
+            the method used, and the null hypothesis.
+
+        Examples
+        --------
+        >>> kstest = Statistics.kolmogorovSmirnovTest
+        >>> data = sc.parallelize([-1.0, 0.0, 1.0])
+        >>> ksmodel = kstest(data, "norm")
+        >>> print(round(ksmodel.pValue, 3))
+        1.0
+        >>> print(round(ksmodel.statistic, 3))
+        0.175
+        >>> ksmodel.nullHypothesis
+        'Sample follows theoretical distribution'
+
+        >>> data = sc.parallelize([2.0, 3.0, 4.0])
+        >>> ksmodel = kstest(data, "norm", 3.0, 1.0)
+        >>> print(round(ksmodel.pValue, 3))
+        1.0
+        >>> print(round(ksmodel.statistic, 3))
+        0.175
+        """
+        if not isinstance(data, RDD):
+            raise TypeError("data should be an RDD, got %s." % type(data))
+        if not isinstance(distName, str):
+            raise TypeError("distName should be a string, got %s." % type(distName))
+
+        param_list = [float(param) for param in params]
+        return KolmogorovSmirnovTestResult(
+            callMLlibFunc("kolmogorovSmirnovTest", data, distName, param_list)
+        )
+
+
+def _test() -> None:
+    import doctest
+    import numpy
+    from pyspark.sql import SparkSession
+
+    try:
+        # Numpy 1.14+ changed it's string format.
+        numpy.set_printoptions(legacy="1.13")
+    except TypeError:
+        pass
+    globs = globals().copy()
+    spark = (
+        SparkSession.builder.master("local[4]").appName("mllib.stat.statistics tests").getOrCreate()
+    )
+    globs["sc"] = spark.sparkContext
+    (failure_count, test_count) = doctest.testmod(globs=globs, optionflags=doctest.ELLIPSIS)
+    spark.stop()
+    if failure_count:
+        sys.exit(-1)
+
+
+if __name__ == "__main__":
+    _test()

snowflake/snowpark_connect/includes/python/pyspark/mllib/stat/distribution.py

@@ -0,0 +1,39 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+__all__ = ["MultivariateGaussian"]
+
+from typing import NamedTuple
+
+from pyspark.mllib.linalg import Matrix, Vector
+
+
+class MultivariateGaussian(NamedTuple):
+
+    """Represents a (mu, sigma) tuple
+
+    Examples
+    --------
+    >>> m = MultivariateGaussian(Vectors.dense([11,12]),DenseMatrix(2, 2, (1.0, 3.0, 5.0, 2.0)))
+    >>> (m.mu, m.sigma.toArray())
+    (DenseVector([11.0, 12.0]), array([[ 1., 5.],[ 3., 2.]]))
+    >>> (m[0], m[1])
+    (DenseVector([11.0, 12.0]), array([[ 1., 5.],[ 3., 2.]]))
+    """
+
+    mu: Vector
+    sigma: Matrix

snowflake/snowpark_connect/includes/python/pyspark/mllib/stat/test.py

@@ -0,0 +1,86 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from typing import Generic, Tuple, TypeVar
+
+from pyspark.mllib.common import inherit_doc, JavaModelWrapper
+
+
+__all__ = ["ChiSqTestResult", "KolmogorovSmirnovTestResult"]
+
+DF = TypeVar("DF", int, float, Tuple[int, ...], Tuple[float, ...])
+
+
+class TestResult(JavaModelWrapper, Generic[DF]):
+    """
+    Base class for all test results.
+    """
+
+    @property
+    def pValue(self) -> float:
+        """
+        The probability of obtaining a test statistic result at least as
+        extreme as the one that was actually observed, assuming that the
+        null hypothesis is true.
+        """
+        return self._java_model.pValue()
+
+    @property
+    def degreesOfFreedom(self) -> DF:
+        """
+        Returns the degree(s) of freedom of the hypothesis test.
+        Return type should be Number(e.g. Int, Double) or tuples of Numbers.
+        """
+        return self._java_model.degreesOfFreedom()
+
+    @property
+    def statistic(self) -> float:
+        """
+        Test statistic.
+        """
+        return self._java_model.statistic()
+
+    @property
+    def nullHypothesis(self) -> str:
+        """
+        Null hypothesis of the test.
+        """
+        return self._java_model.nullHypothesis()
+
+    def __str__(self) -> str:
+        return self._java_model.toString()
+
+
+@inherit_doc
+class ChiSqTestResult(TestResult[int]):
+    """
+    Contains test results for the chi-squared hypothesis test.
+    """
+
+    @property
+    def method(self) -> str:
+        """
+        Name of the test method
+        """
+        return self._java_model.method()
+
+
+@inherit_doc
+class KolmogorovSmirnovTestResult(TestResult[int]):
+    """
+    Contains test results for the Kolmogorov-Smirnov test.
+    """

snowflake/snowpark_connect/includes/python/pyspark/mllib/tests/__init__.py

@@ -0,0 +1,16 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#