teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,187 @@
+def StrApply(data=None, target_columns=None, output_columns=None, accumulate=None, string_operation=None, operating_side=None,
+             in_place=True, string=None, escape_string=None, is_case_specific=True, ignore_trailing_blank=False,
+             string_length=None, start_index=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        StrApply() function applies a specified string operator to the specified input DataFrame 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 string operations on.
+            Types: str OR list of Strings (str)
+
+        output_columns:
+            Optional Argument.
+            Specifies the output column names that contains the output of the
+            string operation on the columns values.
+            Types: str OR list Strings (str)
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input teradataml DataFrame columns to copy to
+            the output.
+            Types: str OR list of Strings (str)
+
+        string_operation:
+            Required Argument.
+            Specifies the string method to use on the target columns.
+            Permitted Values:
+                * TOUPPER
+                * TOLOWER
+                * strTRIM
+                * strCON
+                * strPAD
+                * strLIKE
+                * strINDEX
+                * INITCAP
+                * TRIMSPACES
+                * CHARTOHEXINT
+                * strREVERSE
+                * SUBstr
+                * GETNCHARS
+                * UNICODEstr
+            Types: str
+
+        operating_side:
+            Optional Argument.
+            Specifies the operating side to consider while performing operations
+            like 'stringPad', 'getNchars'.
+            Permitted Values: LEFT, RIGHT
+            Default Value: LEFT
+            Types: str
+
+        in_place:
+            Optional Argument.
+            Specifies whether to use the same column name for the resulted target
+            columns.
+            Default Value: True
+            Types: bool
+
+        string:
+            Optional Argument.
+            Specifies the names of the strings to use as input while applying
+            string operation.
+            Types: str OR list of Strings (str)
+
+        escape_string:
+            Optional Argument.
+            Specifies the names of the string to use as an escape string while
+            applying stringLike operation.
+            Types: str OR list of Strings (str)
+
+        is_case_specific:
+            Optional Argument.
+            Specifies whether to consider uppercase letters(e.g. "A") and lowercase
+            letters(e.g. "a") as same or different.
+            Default Value: True
+            Types: bool
+
+        ignore_trailing_blank:
+            Optional Argument.
+            Specifies whether to ignore trailing blanks in the column strings. Used
+            if the stringOperation is 'StringLike' only.
+            Default Value: False
+            Types: bool
+
+        string_length:
+            Optional Argument.
+            Specifies the length of a string.
+            Types: int
+
+        start_index:
+            Optional Argument.
+            Specifies the start index of the target column string. Used only if
+            the string operation is 'SubString'.
+            Types: int
+
+        **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 it, else an exception is raised.
+
+    RETURNS:
+        Instance of StrApply.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as StrApplyObj.<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: Apply 'TOUPPER' string operator to the
+        #            specified input "name" columns.
+        obj = StrApply(data=titanic_data,
+                       target_columns='name',
+                       string_operation='TOUPPER',
+                       in_place=False)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Apply StrApply using all the arguments.
+        obj = StrApply(data=titanic_data,
+                       data_partition_column='age',
+                       data_order_column='age',
+                       target_columns='name',
+                       accumulate='passenger',
+                       output_columns='str_op_output',
+                       string_operation='TOUPPER',
+                       in_place=False,
+                       persist=True)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """

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

@@ -0,0 +1,146 @@
+def StringSimilarity(data=None, comparison_columns=None, case_sensitive=None, accumulate=None,
+                     **generic_arguments):
+    """
+    DESCRIPTION:
+        StringSimilarity() function calculates the similarity between two
+        strings, using either the Jaro, Jaro-Winkler, N-Gram, or Levenshtein
+        distance.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        comparison_columns:
+            Required Argument.
+            Specifies pairs of input teradataml DataFrame columns that contain
+            strings to be compared (column1 and column2), how to compare them
+            (comparison_type), and (optionally) a constant and the name of the
+            output column for their similarity (output_column). The similarity is
+            a value in the range [0, 1].
+            For comparison_type, use one of these values:
+                * "jaro": Jaro distance.
+                * "jaro_winkler": Jaro-Winkler distance (1 for an exact match, 0 otherwise).
+                  If you specify this comparison type, you can specify the value of
+                  factor p with constant. 0 ≤ p ≤ 0.25.
+                  Default: p = 0.1
+                * "n_gram": N-gram similarity.
+                  If you specify this comparison type, you can specify the value of N with
+                  constant.
+                  Default: N = 2
+                * "LD": Levenshtein distance
+                  The number of edits needed to transform one string into the other,
+                  where edits include insertions, deletions, or substitutions of
+                  individual characters.
+                * "LDWS": Levenshtein distance without substitution.
+                  Number of edits needed to transform one string into the other using only
+                  insertions or deletions of individual characters.
+                * "OSA": Optimal string alignment distance.
+                  Number of edits needed to transform one string into the other.
+                  Edits are insertions, deletions, substitutions, or transpositions of
+                  characters. A substring can be edited only once.
+                * "DL": Damerau-Levenshtein distance.
+                  Like OSA, except that a substring can be edited any number of times.
+                * "hamming": Hamming distance.
+                  Number of positions where corresponding characters differ (that is,
+                  minimum number of substitutions needed to transform one string into the
+                  other) for strings of equal length, otherwise -1 for strings of unequal
+                  length.
+                * "LCS": Longest common substring.
+                  Length of longest substring common to both strings.
+                * "jaccard": Jaccard index-based comparison.
+                * "cosine": Cosine similarity.
+                * "soundexcode": Only for English strings. -1 if either string has a
+                  non-English character, otherwise, 1 if their soundex codes are the same
+                  and 0 otherwise.
+            You can specify a different comparison_type for every pair of columns.
+            The default output_column is "sim_i", where i is the sequence number of the
+            column pair.
+            Types: str OR list of Strings (str)
+
+        case_sensitive:
+            Optional Argument.
+            Specifies whether string comparison is case-sensitive. The default
+            value is False. You can specify either one value for all pairs or
+            one value for each pair. If you specify one value for each pair, then
+            the ith value applies to the ith pair.
+            Types: bool OR list of bools
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input teradataml DataFrame columns to be
+            copied 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 StringSimilarity.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as StringSimilarityObj.<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("stringsimilarity", ["strsimilarity_input"])
+
+        # Create teradataml DataFrame object.
+        strsimilarity_input = DataFrame.from_table("strsimilarity_input")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Creating teradataml dataframe by calculating the
+        #            similarity between two strings.
+        obj = StringSimilarity(data = strsimilarity_input,
+                               comparison_columns=['jaro (src_text1, tar_text) AS jaro1_sim',
+                                                   'LD (src_text1, tar_text) AS ld1_sim',
+                                                   'n_gram (src_text1, tar_text, 2) AS ngram1_sim',
+                                                   'jaro_winkler (src_text1, tar_text, 0.1) AS jw1_sim'],
+                               case_sensitive = True,
+                               accumulate = ["id","src_text1","tar_text"])
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

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

@@ -0,0 +1,105 @@
+def Transform(data=None, object=None, id_columns=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The Transform() function applies numeric transformations to input columns,
+        using Fit() output.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame which contains the model data generated by
+            the Fit() function or instance of Fit.
+            Types: teradataml DataFrame or Fit
+
+        id_columns:
+            Optional Argument.
+            Specifies the input teradataml DataFrame numeric columns to exactly
+            copy to the output. By default, all numeric columns will be converted
+            to float.
+            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 Transform.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as TransformObj.<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", ["iris_input", "transformation_table"])
+
+        # Create teradataml DataFrame objects.
+        iris_input = DataFrame.from_table("iris_input")
+        transformation_df = DataFrame.from_table("transformation_table")
+        transformation_df = transformation_df.drop(['id'], axis=0)
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Run Fit() with all arguments and pass the output to Transform().
+        fit_df = Fit(data=iris_input,
+                     object=transformation_df,
+                     object_order_column='TargetColumn'
+                     )
+
+        # Run Transform() with persist as True in order to save the result.
+        transform_result = Transform(data=iris_input,
+                                     data_partition_column='sepal_length',
+                                     data_order_column='sepal_length',
+                                     object=fit_df.result,
+                                     object_order_column='TargetColumn',
+                                     id_columns=['species', 'id'],
+                                     persist=True
+                                     )
+
+        # Print the result DataFrame.
+        print(transform_result.result)
+
+    """

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

@@ -0,0 +1,142 @@
+def UnivariateStatistics(newdata=None, target_columns=None, partition_columns=None,
+                         stats='ALL', centiles=[1, 5, 10, 25, 50, 75, 90, 95, 99],
+                         trim_percentile=20, **generic_arguments):
+    """
+    DESCRIPTION:
+        UnivariateStatistics() function displays descriptive statistics for each specified numeric input DataFrame column.
+
+    PARAMETERS:
+        newdata:
+            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 univariate
+            statistics need to be displayed.
+            Types: str OR list of Strings (str)
+
+        partition_columns:
+            Optional Argument.
+            Specifies the names of the input partition columns.
+            Types: str OR list of Strings (str)
+
+        stats:
+            Optional Argument.
+            Specifies the statistics to calculate.
+            Permitted Values:
+                * SUM
+                * COUNT or CNT
+                * MAXIMUM or MAX
+                * MINIMUM or MIN
+                * MEAN
+                * UNCORRECTED SUM OF SQUARES or USS
+                * NULL COUNT or NLC
+                * POSITIVE VALUES COUNT or PVC
+                * NEGATIVE VALUES COUNT or NVC
+                * ZERO VALUES COUNT or ZVC
+                * TOP5 or TOP
+                * BOTTOM5 or BTM
+                * RANGE or RNG
+                * GEOMETRIC MEAN or GM
+                * HARMONIC MEAN or HM
+                * VARIANCE or VAR
+                * STANDARD DEVIATION or STD
+                * STANDARD ERROR or SE
+                * SKEWNESS or SKW
+                * KURTOSIS or KUR
+                * COEFFICIENT OF VARIATION or CV
+                * CORRECTED SUM OF SQUARES or CSS
+                * MODE
+                * MEDIAN or MED
+                * UNIQUE ENTITY COUNT or UEC
+                * INTERQUARTILE RANGE or IQR
+                * TRIMMED MEAN or TM
+                * PERCENTILES or PRC
+                * ALL
+            Default Value: 'ALL'
+            Types: str OR list of Strings (str)
+
+        centiles:
+            Optional Argument.
+            Specifies the percentile to calculate.
+            The function ignores Centiles unless Stats specifies PERCENTILES, PRC, or ALL.
+            Default Value: [1, 5, 10, 25, 50, 75, 90, 95, 99]
+            Types: int or list of int
+
+        trim_percentile:
+            Optional Argument.
+            Specifies the trimmed lower percentile.
+            Default Value: 20
+            Types: int
+
+        **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 a table or not.
+                    When set to True, results are persisted in a 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 a volatile table or not.
+                    When set to True, results are stored in a 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 SQL Engine
+                function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of UnivariateStatistics.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as UnivariateStatisticsObj.<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: Display descriptive statistics of input DataFrame
+        #            column "fare" by partitioning "sex" and "age".
+        obj = UnivariateStatistics(newdata=titanic_data,
+                                   target_columns='fare',
+                                   partition_columns=['sex', 'age'],
+                                   stats='ALL',
+                                   centiles=[1, 5, 10, 25, 50, 75, 90, 95, 99],
+                                   trim_percentile=20)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """