teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,172 @@
+def BincodeFit(data=None, fit_data=None, target_columns=None, method_type=None,
+               nbins=None, label_prefix=None, target_colnames=None,
+               minvalue_column=None, maxvalue_column=None, label_column=None,
+               **generic_arguments):
+    """
+    DESCRIPTION:
+        The BinCodeFit() function outputs a DataFrame of information to input to
+        BinCodeTransform() function, which bin-codes the specified input DataFrame.
+        Bin-coding is typically used to convert numeric data to categorical data by
+        binning the numeric data into multiple numeric bins (intervals).
+        The bins can have a fixed-width with auto-generated labels or can have variable
+        widths and labels.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        fit_data:
+            Optional Argument.
+            Specifies the input teradataml DataFrame containing binning parameters for
+            VARIABLE-WIDTH. It is not needed for EQUAL-WIDTH.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the input teradataml DataFrame columns to generate bins information
+            and binning parameters on.
+            Types: str OR list of Strings (str)
+
+        method_type:
+            Required Argument.
+            Specifies the Method Type which will be used for histogram computation.
+            Permitted Values: EQUAL-WIDTH, VARIABLE-WIDTH
+            Types: str
+
+        nbins:
+            Optional Argument.
+            Specifies the number of bins to be used when "method_type" is
+            EQUAL-WIDTH. It is not needed for VARIABLE-WIDTH. If one value is provided,
+            it applies to all target columns, if more than one value is
+            specified, "nbins" values apply to "target_columns" in the order
+            specified by the user.
+            Types: int OR list of ints
+
+        label_prefix:
+            Optional Argument.
+            Specify the label prefix to be used when MethodType is EQUAL-WIDTH. If
+            one value is provided, it applies to all target columns. If more than
+            one value is specified, "label_prefix" values apply to "target_columns"
+            in the order specified by the user.
+            Default Value:  target column names.
+            Types: str OR list of strs
+
+        target_colnames:
+            Optional Argument.
+            Specifies the "fit_data" column which contains column name for
+            which bins are specified.
+            Default Value: ColumnName.
+            Types: str
+
+        minvalue_column:
+            Optional Argument.
+            Specifies the "fit_data" column which contains Min Value for the
+            specified bins.
+            Default Value: MinValue.
+            Types: str
+
+        maxvalue_column:
+            Optional Argument.
+            Specifies the "fit_data" column which contains Max Value for the
+            specified bins.
+            Default Value: MaxValue.
+            Types: str
+
+        label_column:
+            Optional Argument.
+            Specifies the "fit_data" column which contains label for which
+            bins are specified.
+            Default Value: Label.
+            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 function supports it, else an exception is raised.
+
+    RETURNS:
+        Instance of BincodeFit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as BincodeFitObj.<attribute_name>.
+        Output teradataml DataFrame attribute names are:
+            1. output
+            2. output_data
+
+
+    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", "bin_fit_ip"])
+
+        # Create teradataml DataFrame objects.
+        titanic_data = DataFrame.from_table("titanic")
+        bin_fit_ip = DataFrame.from_table("bin_fit_ip")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Transform the data using BincodeFit object with Variable-Width.
+        bin_code_1 = BincodeFit(data=titanic_data,
+                                fit_data=bin_fit_ip,
+                                fit_data_order_column = ['minVal', 'maxVal'],
+                                target_columns='age',
+                                minvalue_column='minVal',
+                                maxvalue_column='maxVal',
+                                label_column='label',
+                                method_type='Variable-Width',
+                                label_prefix='label_prefix'
+                               )
+
+        # Print the result.
+        print(bin_code_1.output)
+
+        # Example 2: Transform the data using BincodeFit object with Equal-Width.
+        bin_code_2 = BincodeFit(data=titanic_data,
+                                target_columns='age',
+                                method_type='Equal-Width',
+                                nbins=2,
+                                label_prefix='label_prefix'
+                               )
+
+        # Print the result.
+        print(bin_code_2.output)
+
+    """

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

@@ -0,0 +1,131 @@
+def BincodeTransform(data=None, object=None, accumulate=None,
+                     **generic_arguments):
+    """
+    DESCRIPTION:
+        The BincodeTransform() function is used to convert the continuous numeric data to
+        categorical data. The BincodeTransform() function takes the output of BincodeFit()
+        function to apply the transform on input DataFrame.
+        BincodeTransform() function takes two DataFrames as input:
+            1. Input dataframe which contains numeric data to be converted to categorical
+               data.
+            2. Output of BincodeFit() function which contains the binning data.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the binning parameters
+            generated by BincodeFit() function or the instance of BincodeFit.
+            Types: teradataml DataFrame or BincodeFit
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the
+            output. By default, the function copies no input teradataml
+            DataFrame columns to the output.
+            Types: str OR list of Strings (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 BincodeTransform.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as BincodeTransformObj.<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", "bin_fit_ip"])
+
+        # Create teradataml DataFrame objects.
+        titanic_data = DataFrame.from_table("titanic")
+        bin_fit_ip = DataFrame.from_table("bin_fit_ip")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Transform the data using BincodeFit object with Variable-Width.
+        # Create BincodeFit object.
+        bin_code_1 = BincodeFit(data=titanic_data,
+                                fit_data=bin_fit_ip,
+                                fit_data_order_column = ['minVal', 'maxVal'],
+                                target_columns='age',
+                                minvalue_column='minVal',
+                                maxvalue_column='maxVal',
+                                label_column='label',
+                                method_type='Variable-Width',
+                                label_prefix='label_prefix'
+                               )
+
+        # Run BincodeTransform.
+        obj = BincodeTransform(data=titanic_data,
+                               object=bin_code_1.output,
+                               object_order_column="TD_MinValue_BINFIT",
+                               accumulate=['passenger', 'ticket']
+                               )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Transform the data using BincodeFit object with Equal-Width.
+        # Create BincodeFit object.
+        bin_code_2 = BincodeFit(data=titanic_data,
+                                target_columns='age',
+                                method_type='Equal-Width',
+                                nbins=2,
+                                label_prefix='label_prefix'
+                                )
+
+        # Run BincodeTransform.
+        obj = BincodeTransform(data=titanic_data,
+                               object=bin_code_2.output,
+                               accumulate=['passenger', 'ticket']
+                               )
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

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

@@ -0,0 +1,86 @@
+def CategoricalSummary(data = None, target_columns = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The CategoricalSummary() function displays the distinct values and their counts for
+        each specified input DataFrame column.
+
+
+    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" for which
+            categorical summary needs to be determined.
+            Types: str OR list of Strings (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 CategoricalSummary.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as CategoricalSummaryObj.<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: Find the distinct values and counts for column 'sex'.
+        obj = CategoricalSummary(data=titanic_data,
+                                 target_columns="sex"
+                                )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """

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

@@ -0,0 +1,90 @@
+def ChiSq(data=None, alpha=0.05, **generic_arguments):
+    """
+    DESCRIPTION:
+        The ChiSq() function performs Pearson's chi-squared (χ2) test for independence,
+        which determines if there is a statistically significant difference between
+        the expected and observed frequencies in one or more categories of a
+        contingency table (also called a cross tabulation).
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        alpha:
+            Optional Argument.
+            Specifies the probability below which the null hypothesis is rejected.
+            "alpha" must be a numeric value in the range [0, 1].
+            Default Value: 0.05
+            Types: float
+
+        **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 ChiSq.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ChiSq.<attribute_name>.
+        Output teradataml DataFrame attribute names are:
+            1. output_data
+            2. output
+
+    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", "chi_sq")
+
+        # Create teradataml DataFrame object.
+        chi_sq_data = DataFrame.from_table("chi_sq")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example: Run ChiSq() with all arguments.
+        obj = ChiSq(data=chi_sq_data,
+                    alpha=0.5)
+
+        # Print the output DataFrame and expected values DataFrame.
+        print(obj.output)
+        print(obj.output_data)
+
+    """

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

@@ -0,0 +1,86 @@
+def ColumnSummary(data = None, target_columns = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The ColumnSummary() function can be used to take a quick look at the columns,
+        their datatypes, and summary of NULLs/non-NULLs for a given table.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the input teradataml DataFrame columns for which column
+            summary needs to be determined.
+            Types: str OR list of Strings (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 ColumnSummary.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ColumnSummaryObj.<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: Find datatypes, NULL and non-NULL counts etc.
+        obj = ColumnSummary(data=titanic_data,
+                            target_columns=['age', 'pclass', 'embarked', 'cabin']
+                           )
+
+        # Print the result DataFrame.
+        print(obj.result)
+        
+    """

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

@@ -0,0 +1,96 @@
+def ConvertTo(data = None, target_columns = None, target_datatype = None,
+              **generic_arguments):
+    """
+    DESCRIPTION:
+        The ConvertTo() function converts the specified input DataFrame columns to
+        specified data types.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the input teradataml DataFrame columns which needs to be
+            casted/converted to another data type.
+            Types: str OR list of Strings (str)
+
+        target_datatype:
+            Required Argument.
+            Specify target data type(s) into which "target_columns" need to be
+            converted. If one value is provided, it applies to all "target_columns".
+            If more than one value is specified, each "target_datatype" value applies to
+            corresponding "target_columns" value (in the order specified by the user).
+            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 ConvertTo.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ConvertToObj.<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: Convert datatype of 'fare' to integer.
+        obj = ConvertTo(data=titanic_data,
+                        target_columns="fare", target_datatype="integer"
+                       )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """