teradataml 17.20.0.7__py3-none-any.whl → 20.0.0.0__py3-none-any.whl

teradataml/data/docs/sqle/docs_17_10/NumApply.py

@@ -1,147 +1,147 @@
-def NumApply(data=None, target_columns=None, output_columns=None, accumulate=None, apply_method=None,
-             sigmoid_style=None, in_place=None, **generic_arguments):
-    """
-    DESCRIPTION:
-        Apply predefined numeric operation on specified target columns.
-
-
-    PARAMETERS:
-        data:
-            Required Argument.
-            Specifies the input teradataml DataFrame.
-            Types: teradataml DataFrame
-
-        target_columns:
-            Required Argument.
-            Specifies the name(s) of the column(s) in "data" to perform numeric operations on.
-            Types: str OR list of Strings (str)
-
-        apply_method:
-            Required Argument.
-            Specifies the numeric operator/method.
-            Permitted Values:
-                * EXP - Raises e (base of natural logarithms) to power of value,
-                        where e = 2.71828182845905.
-                * LOG - Computes base 10 logarithm of value.
-                * SIGMOID - Applies sigmoid function to value. See "sigmoid_style".
-                * SININV - Computes inverse hyperbolic sine of value.
-                * TANH - Computes hyperbolic tangent of value.
-            Types: str
-
-        in_place:
-            Optional Argument.
-            Specifies whether the output columns have the same names as the target columns.
-            When set to True, function effectively replaces each value in each target column
-            with the result of applying "apply_method" to it, otherwise copies the target
-            columns to the output and adds output columns whose values are the result of
-            applying "apply_method" to each value.
-            No target columns can be part of the "accumulate" column.
-            Default Value: True
-            Types: boolean
-
-        output_columns:
-            Optional Argument.
-            Specifies the name(s) of the output column(s) to be generated.
-            An output column name cannot exceed 128 characters.
-            By default, with "in_place" set to False, 'target_column_operator'; otherwise same as
-            "target_column" names.
-            Notes:
-                1. If any 'target_column_operator' exceeds 128 characters, specify an "output_column" for each
-                   target_column.
-                2. Ignored with "in_place" set to True.
-            Types: str OR list of strs
-
-        accumulate:
-            Optional Argument.
-            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the output.
-            Types: str OR list of Strings (str)
-
-        sigmoid_style:
-            Optional Argument, required when "apply_method" is 'sigmoid'.
-            Specifies the sigmoid style.
-            Permitted Values:
-                * LOGIT
-                * MODIFIEDLOGIT
-                * TANH
-            Default Value: LOGIT
-            Types: str
-
-        **generic_arguments:
-            Specifies the generic keyword arguments SQLE functions accept.
-            Below are the generic keyword arguments:
-                persist:
-                    Optional Argument.
-                    Specifies whether to persist the results of the function in table or not.
-                    When set to True, results are persisted in table; otherwise, results
-                    are garbage collected at the end of the session.
-                    Default Value: False
-                    Types: boolean
-
-                volatile:
-                    Optional Argument.
-                    Specifies whether to put the results of the function in volatile table or not.
-                    When set to True, results are stored in volatile table, otherwise not.
-                    Default Value: False
-                    Types: boolean
-
-            Function allows the user to partition, hash, order or local order the input
-            data. These generic arguments are available for each argument that accepts
-            teradataml DataFrame as input and can be accessed as:
-                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
-                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
-                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
-                * "local_order_<input_data_arg_name>" accepts boolean
-            Note:
-                These generic arguments are supported by teradataml if the underlying
-                SQLE Engine function supports, else an exception is raised.
-
-
-    RETURNS:
-        Instance of NumApply.
-        Output teradataml DataFrames can be accessed using attribute
-        references, such as NumApplyObj.<attribute_name>.
-        Output teradataml DataFrame attribute name is:
-            result
-
-
-    RAISES:
-        TeradataMlException, TypeError, ValueError
-
-
-    EXAMPLES:
-        # Notes:
-        #     1. Get the connection to Vantage to execute the function.
-        #     2. One must import the required functions mentioned in
-        #        the example from teradataml.
-        #     3. Function will raise error if not supported on the Vantage
-        #        user is connected to.
-
-        # Load the example data.
-        load_example_data("teradataml", ["numerics"])
-
-        # Create teradataml DataFrame object.
-        numerics = DataFrame.from_table("numerics")
-
-        # Check the list of available analytic functions.
-        display_analytic_functions()
-
-        # Example 1: Apply "log" method to column "num1" in numerics.
-        obj = NumApply(data=numerics,
-                       target_columns="integer_col",
-                       apply_method="log",
-                       in_place=True)
-
-        # Print the result DataFrame.
-        print(obj.result)
-
-        # Example 2: Apply "sigmoid" method and "tanh" as sigmoid style.
-        obj = NumApply(data=numerics,
-                       target_columns="decimal_col",
-                       output_columns="out1",
-                       apply_method="sigmoid",
-                       sigmoid_style="tanh",
-                       in_place=False)
-
-        # Print the result DataFrame.
-        print(obj.result)
-    """
+def NumApply(data=None, target_columns=None, output_columns=None, accumulate=None, apply_method=None,
+             sigmoid_style=None, in_place=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        Apply predefined numeric operation on specified target columns.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the name(s) of the column(s) in "data" to perform numeric operations on.
+            Types: str OR list of Strings (str)
+
+        apply_method:
+            Required Argument.
+            Specifies the numeric operator/method.
+            Permitted Values:
+                * EXP - Raises e (base of natural logarithms) to power of value,
+                        where e = 2.71828182845905.
+                * LOG - Computes base 10 logarithm of value.
+                * SIGMOID - Applies sigmoid function to value. See "sigmoid_style".
+                * SININV - Computes inverse hyperbolic sine of value.
+                * TANH - Computes hyperbolic tangent of value.
+            Types: str
+
+        in_place:
+            Optional Argument.
+            Specifies whether the output columns have the same names as the target columns.
+            When set to True, function effectively replaces each value in each target column
+            with the result of applying "apply_method" to it, otherwise copies the target
+            columns to the output and adds output columns whose values are the result of
+            applying "apply_method" to each value.
+            No target columns can be part of the "accumulate" column.
+            Default Value: True
+            Types: boolean
+
+        output_columns:
+            Optional Argument.
+            Specifies the name(s) of the output column(s) to be generated.
+            An output column name cannot exceed 128 characters.
+            By default, with "in_place" set to False, 'target_column_operator'; otherwise same as
+            "target_column" names.
+            Notes:
+                1. If any 'target_column_operator' exceeds 128 characters, specify an "output_column" for each
+                   target_column.
+                2. Ignored with "in_place" set to True.
+            Types: str OR list of strs
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the output.
+            Types: str OR list of Strings (str)
+
+        sigmoid_style:
+            Optional Argument, required when "apply_method" is 'sigmoid'.
+            Specifies the sigmoid style.
+            Permitted Values:
+                * LOGIT
+                * MODIFIEDLOGIT
+                * TANH
+            Default Value: LOGIT
+            Types: str
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in table or not.
+                    When set to True, results are persisted in table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in volatile table or not.
+                    When set to True, results are stored in volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying
+                SQLE Engine function supports, else an exception is raised.
+
+
+    RETURNS:
+        Instance of NumApply.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as NumApplyObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Load the example data.
+        load_example_data("teradataml", ["numerics"])
+
+        # Create teradataml DataFrame object.
+        numerics = DataFrame.from_table("numerics")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Apply "log" method to column "num1" in numerics.
+        obj = NumApply(data=numerics,
+                       target_columns="integer_col",
+                       apply_method="log",
+                       in_place=True)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Apply "sigmoid" method and "tanh" as sigmoid style.
+        obj = NumApply(data=numerics,
+                       target_columns="decimal_col",
+                       output_columns="out1",
+                       apply_method="sigmoid",
+                       sigmoid_style="tanh",
+                       in_place=False)
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

teradataml/data/docs/sqle/docs_17_10/OneHotEncodingFit.py

@@ -1,133 +1,133 @@
-def OneHotEncodingFit(data=None, is_input_dense=None, target_column=None, categorical_values=None, other_column=None,
-                      attribute_column=None, value_column=None, target_attributes=None, other_attributes=None,
-                      **generic_arguments):
-    """
-    DESCRIPTION:
-        Function records all the parameters required for OneHotEncodingTransform() function.
-        Such as, target attributes and their categorical values to be encoded and other parameters.
-        Output of OneHotEncodingFit() function is used by OneHotEncodingTransform() function for encoding
-        the input data. It supports inputs in both sparse and dense format.
-
-
-    PARAMETERS:
-        data:
-            Required Argument.
-            Specifies the input teradataml DataFrame.
-            Types: teradataml DataFrame
-
-        is_input_dense:
-            Required Argument.
-            Specifies whether input is in dense format or sparse format.
-            Types: boolean
-
-        target_column:
-            Required Argument when 'is_input_dense=True', disallowed otherwise.
-            Specifies the name of the column in "data" to be encoded.
-            Types: str
-
-        categorical_values:
-            Required Argument when 'is_input_dense=True', disallowed otherwise.
-            Specifies the categorical values to encode in one-hot form.
-            Types: str OR list of strs
-
-        other_column:
-            Required Argument when 'is_input_dense=True', disallowed otherwise.
-            Specifies a category name for values that "categorical_values" does not specify
-            (categorical values not to encode in one-hot form).
-            Default Value: 'other'
-            Types: str
-
-        attribute_column:
-            Required Argument when 'is_input_dense=False', disallowed otherwise.
-            Specifies the name of the column in "data" which contains attribute
-            names.
-            Types: str
-
-        value_column:
-            Required Argument when 'is_input_dense=False', disallowed otherwise.
-            Specifies the name of the column in "data" which contains attribute
-            values.
-            Types: str
-
-        target_attributes:
-            Required Argument when 'is_input_dense=False', disallowed otherwise.
-            Specifies one or more attributes to encode in one-hot form. Every target attribute must
-            be in "attribute_column".
-            Types: str OR list of strs
-
-        other_attributes:
-            Optional Argument when 'is_input_dense=False', disallowed otherwise.
-            For each target attribute, specifies a category name for attributes that "target_attributes"
-            does not specify. The nth "other_attributes" corresponds to the nth "target_attribute".
-            Types: str OR list of strs
-
-        **generic_arguments:
-            Specifies the generic keyword arguments SQLE functions accept.
-            Below are the generic keyword arguments:
-                persist:
-                    Optional Argument.
-                    Specifies whether to persist the results of the function in table or not.
-                    When set to True, results are persisted in table; otherwise, results
-                    are garbage collected at the end of the session.
-                    Default Value: False
-                    Types: boolean
-
-                volatile:
-                    Optional Argument.
-                    Specifies whether to put the results of the function in volatile table or not.
-                    When set to True, results are stored in volatile table, otherwise not.
-                    Default Value: False
-                    Types: boolean
-
-            Function allows the user to partition, hash, order or local order the input
-            data. These generic arguments are available for each argument that accepts
-            teradataml DataFrame as input and can be accessed as:
-                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
-                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
-                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
-                * "local_order_<input_data_arg_name>" accepts boolean
-            Note:
-                These generic arguments are supported by teradataml if the underlying
-                SQLE Engine function supports, else an exception is raised.
-
-
-    RETURNS:
-        Instance of OneHotEncodingFit.
-        Output teradataml DataFrames can be accessed using attribute
-        references, such as OneHotEncodingFitObj.<attribute_name>.
-        Output teradataml DataFrame attribute name is:
-            result
-
-
-    RAISES:
-        TeradataMlException, TypeError, ValueError
-
-
-    EXAMPLES:
-        # Notes:
-        #     1. Get the connection to Vantage to execute the function.
-        #     2. One must import the required functions mentioned in
-        #        the example from teradataml.
-        #     3. Function will raise error if not supported on the Vantage
-        #        user is connected to.
-
-        # Load the example data.
-        load_example_data("teradataml", ["titanic"])
-
-        # Create teradataml DataFrame object.
-        titanic_data = DataFrame.from_table("titanic")
-
-        # Check the list of available analytic functions.
-        display_analytic_functions()
-
-        # Example 1: Generate fit object to encode "male" and "female" values of column "sex".
-        fit_obj = OneHotEncodingFit(data=titanic_data,
-                                    is_input_dense=True,
-                                    target_column="sex",
-                                    categorical_values=["male", "female"],
-                                    other_column="other")
-
-        # Print the result DataFrame.
-        print(fit_obj.result)
-
+def OneHotEncodingFit(data=None, is_input_dense=None, target_column=None, categorical_values=None, other_column=None,
+                      attribute_column=None, value_column=None, target_attributes=None, other_attributes=None,
+                      **generic_arguments):
+    """
+    DESCRIPTION:
+        Function records all the parameters required for OneHotEncodingTransform() function.
+        Such as, target attributes and their categorical values to be encoded and other parameters.
+        Output of OneHotEncodingFit() function is used by OneHotEncodingTransform() function for encoding
+        the input data. It supports inputs in both sparse and dense format.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        is_input_dense:
+            Required Argument.
+            Specifies whether input is in dense format or sparse format.
+            Types: boolean
+
+        target_column:
+            Required Argument when 'is_input_dense=True', disallowed otherwise.
+            Specifies the name of the column in "data" to be encoded.
+            Types: str
+
+        categorical_values:
+            Required Argument when 'is_input_dense=True', disallowed otherwise.
+            Specifies the categorical values to encode in one-hot form.
+            Types: str OR list of strs
+
+        other_column:
+            Required Argument when 'is_input_dense=True', disallowed otherwise.
+            Specifies a category name for values that "categorical_values" does not specify
+            (categorical values not to encode in one-hot form).
+            Default Value: 'other'
+            Types: str
+
+        attribute_column:
+            Required Argument when 'is_input_dense=False', disallowed otherwise.
+            Specifies the name of the column in "data" which contains attribute
+            names.
+            Types: str
+
+        value_column:
+            Required Argument when 'is_input_dense=False', disallowed otherwise.
+            Specifies the name of the column in "data" which contains attribute
+            values.
+            Types: str
+
+        target_attributes:
+            Required Argument when 'is_input_dense=False', disallowed otherwise.
+            Specifies one or more attributes to encode in one-hot form. Every target attribute must
+            be in "attribute_column".
+            Types: str OR list of strs
+
+        other_attributes:
+            Optional Argument when 'is_input_dense=False', disallowed otherwise.
+            For each target attribute, specifies a category name for attributes that "target_attributes"
+            does not specify. The nth "other_attributes" corresponds to the nth "target_attribute".
+            Types: str OR list of strs
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in table or not.
+                    When set to True, results are persisted in table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in volatile table or not.
+                    When set to True, results are stored in volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying
+                SQLE Engine function supports, else an exception is raised.
+
+
+    RETURNS:
+        Instance of OneHotEncodingFit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as OneHotEncodingFitObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Load the example data.
+        load_example_data("teradataml", ["titanic"])
+
+        # Create teradataml DataFrame object.
+        titanic_data = DataFrame.from_table("titanic")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Generate fit object to encode "male" and "female" values of column "sex".
+        fit_obj = OneHotEncodingFit(data=titanic_data,
+                                    is_input_dense=True,
+                                    target_column="sex",
+                                    categorical_values=["male", "female"],
+                                    other_column="other")
+
+        # Print the result DataFrame.
+        print(fit_obj.result)
+
     """