teradataml 20.0.0.8__py3-none-any.whl

teradataml/table_operators/templates/dataframe_apply.template

@@ -0,0 +1,184 @@
+import sys
+from pandas import DataFrame as pd_DataFrame, Series as pd_Series, read_csv as pd_read_csv, isna as pd_isna
+from numpy import ndarray as np_ndarray
+from pickle import loads as pickle_load
+from base64 import b64decode as base64_b64decode
+
+# Information that is required to help with the script usage.
+#  The delimiter to use with the input and output text.
+_template_delimiter = pickle_load(base64_b64decode({DELIMITER}))
+#  The operation that the user function is supposed to be applied for: map_row or map_partition.
+_operation = pickle_load(base64_b64decode({STO_OPERATION}))
+#  The deserialized and decoded user defined function.
+_func = pickle_load(base64_b64decode({USER_DEF_FUNC}))
+#  The names of columns in the input teradataml DataFrame.
+_col_names_list = pickle_load(base64_b64decode({DF_COL_NAMES_LIST}))
+#  The types of columns in the input teradataml DataFrame.
+_col_types_list = pickle_load(base64_b64decode({DF_COL_TYPES_LIST}))
+#  The names of the output columns expected from the user defined function.
+_output_col_names_list = pickle_load(base64_b64decode({OUTPUT_COL_NAMES_LIST}))
+#  The python types of the output columns expected from the user defined function.
+_output_converters = pickle_load(base64_b64decode({OUTPUT_CONVERTERS}))
+#  The quotechar to use.
+_quotechar = pickle_load(base64_b64decode({QUOTECHAR}))
+# converters to use for Pandas DataFrames with pd.read_csv.
+_input_converters = pickle_load(base64_b64decode({INPUT_CONVERTERS}))
+# chunk size to use with pd.read_csv.
+_chunk_size = pickle_load(base64_b64decode({CHUNK_SIZE}))
+
+
+class StdoutWriter:
+    def __init__(self, delimiter=_template_delimiter, quotechar=_quotechar):
+        """
+        DESCRIPTION:
+            A writer that helps to write delimited rows to sys.stdout.
+
+        PARAMETERS:
+            delimiter:
+                Optional Argument.
+                Specifies delimiter to use while writing the delimited string to stdout.
+                Default value: Value of _template_delimiter.
+                Types: string
+
+            quotechar:
+                Optional Argument.
+                Specifies delimiter to use while writing the delimited string to stdout.
+                Default value: Value of _quotechar.
+                Types: string
+
+        RETURNS:
+            An object of class StdoutWriter.
+
+        EXAMPLES:
+            >>> stdout_writer = StdoutWriter(delimiter="\t")
+        """
+        self.delimiter = delimiter
+        self.quotechar = quotechar
+
+    def write(self, data):
+        """
+        DESCRIPTION:
+            Function to write data to the Standard Output Stream as a delimited string.
+
+        PARAMETERS:
+            data:
+                The objects that needs to be written to the standard output stream as a delimited string.
+                Types: Pandas DataFrame, Pandas Series, or Numpy ndarray.
+
+        RETURNS:
+            None.
+
+        EXAMPLES:
+            >>> stdout_writer = StdoutWriter(delimiter="\t")
+
+            >>> # Write a numpy ndarray.
+            >>> import numpy as np
+            >>> x = np.arange(0.0,5.0,1.0)
+            >>> print(type(x))
+            <class 'numpy.ndarray'>
+            >>> stdout_writer.write(x)
+            0.0	1.0	2.0	3.0	4.0
+
+            >>> # Write a Pandas DataFrame
+            >>> import pandas as pd
+            >>> pdf = pd.DataFrame({{ 'id': [1, 2], 'value':[10, 20] }})
+            >>> stdout_writer.write(pdf)
+            1	10
+            2	20
+
+            >>> # Write a Pandas Series
+            >>> stdout_writer.write(pdf.id)
+            1	2
+        """
+        def write_np_array(row):
+            """
+            Helper function to write the numpy ndarray as a delimited string.
+
+            PARAMETERS:
+                row:
+                    Object of class numpy ndarray to write to stdout as delimited string.
+                    Types: numpy ndarray
+
+            RETURNS:
+                None.
+            """
+            # We check for NaNs and Nones in the output to make sure the output can be readily
+            # converted to the corresponding SQL type.
+            if self.quotechar is not None:
+                # A NULL value should not be enclosed in quotes.
+                # The CSV module has no support for such output with writer, and hence the custom formatting.
+                values = ['' if pd_isna(s) else "{{}}{{}}{{}}".format(self.quotechar,
+                                                                      str(_output_converters[ind](s)), self.quotechar)
+                                                                      for ind, s in enumerate(row)]
+            else:
+                values = ['' if pd_isna(s) else str(_output_converters[ind](s)) for ind, s in enumerate(row)]
+            print(self.delimiter.join(values), file=sys.stdout)
+
+        type_err_msg = "{{}} operation supports functions returning objects of type np.ndarray," \
+                       " pd.Series, or pd.DataFrame. Given: {{}}"
+
+        if data is None:
+            return
+        elif isinstance(data, pd_DataFrame):
+            # Iterate over rows and print the each row (numpy ndarray).
+            for _, row in data.iterrows():
+                write_np_array(row.values)
+        elif isinstance(data, pd_Series):
+            # Treat Series as a row - extract the numpy ndarray and write it.
+            write_np_array(data.values)
+        elif isinstance(data, np_ndarray):
+            # Print the numpy ndarray.
+            if data.ndim == 2:
+                # Two-dimensional array, with each array in the iteration
+                # representing an output row.
+                for inner_array in data:
+                    write_np_array(inner_array)
+            elif data.ndim == 1:
+                # One-dimensional array, representing an output row.
+                write_np_array(data)
+            else:
+                raise ValueError("Unsupported number of dimensions in numpy array: {{}}. "
+                                 "Expected one or two dimensions.".format(data.ndim))
+        else:
+            raise TypeError(type_err_msg.format(_operation, type(data).__name__))
+
+
+# The entry point to the script.
+if __name__ == "__main__":
+    kwargs = dict()
+    kwargs['chunksize'] = _chunk_size
+
+    # Also check if we need to use 'quotechar'.
+    if _quotechar is not None:
+        kwargs['quotechar'] = _quotechar
+        kwargs['quoting'] = 1  # QUOTE_ALL
+
+    # TODO: Add Jira number to remove the below block of code.
+    # For some reason, the STDOUT of SQL is sending a blank lines. Hence
+    # removing the blank lines and updating to file.
+    with open("/tmp/std_in.log", "w") as fp:
+        for line in sys.stdin.read().split("\n"):
+            if line.strip():
+                fp.writelines(line+"\n")
+
+    rows = pd_read_csv("/tmp/std_in.log", sep=_template_delimiter, header=None, names=_col_names_list,
+                       index_col=False, converters=_input_converters, **kwargs)
+
+    # Create the writer to write the output.
+    stdout_writer = StdoutWriter(delimiter=_template_delimiter)
+
+    if _operation == "map_row" or _operation == "apply":
+        # When the type of operation to be performed is "map_row", we first get
+        # a Pandas DataFrame of the given chunksize, and then we iterate over it
+        # to apply the user defined function each row in it.
+        for chunk in rows:
+            if chunk.shape[0] > 0:
+                for _, row in chunk.iterrows():
+                    stdout_writer.write(_func(row))
+    elif _operation == "map_partition":
+        # When the type of operation to be performed is "map_partition", we
+        # pass the input (iterator to get Pandas DataFrame in chunks or in
+        # a single call) to the user defined function.
+        stdout_writer.write(_func(rows))
+    else:
+        raise TypeError("Unknown operation: {{}}".format(_operation))

teradataml/table_operators/templates/dataframe_map.template

@@ -0,0 +1,176 @@
+import sys
+from pandas import DataFrame as pd_DataFrame, Series as pd_Series, read_csv as pd_read_csv, isna as pd_isna
+from numpy import ndarray as np_ndarray
+from pickle import loads as pickle_load
+from base64 import b64decode as base64_b64decode
+
+# Information that is required to help with the script usage.
+#  The delimiter to use with the input and output text.
+_template_delimiter = pickle_load(base64_b64decode({DELIMITER}))
+#  The operation that the user function is supposed to be applied for: map_row or map_partition.
+_operation = pickle_load(base64_b64decode({STO_OPERATION}))
+#  The deserialized and decoded user defined function.
+_func = pickle_load(base64_b64decode({USER_DEF_FUNC}))
+#  The names of columns in the input teradataml DataFrame.
+_col_names_list = pickle_load(base64_b64decode({DF_COL_NAMES_LIST}))
+#  The types of columns in the input teradataml DataFrame.
+_col_types_list = pickle_load(base64_b64decode({DF_COL_TYPES_LIST}))
+#  The names of the output columns expected from the user defined function.
+_output_col_names_list = pickle_load(base64_b64decode({OUTPUT_COL_NAMES_LIST}))
+#  The python types of the output columns expected from the user defined function.
+_output_converters = pickle_load(base64_b64decode({OUTPUT_CONVERTERS}))
+#  The quotechar to use.
+_quotechar = pickle_load(base64_b64decode({QUOTECHAR}))
+# converters to use for Pandas DataFrames with pd.read_csv.
+_input_converters = pickle_load(base64_b64decode({INPUT_CONVERTERS}))
+# chunk size to use with pd.read_csv.
+_chunk_size = pickle_load(base64_b64decode({CHUNK_SIZE}))
+
+
+class StdoutWriter:
+    def __init__(self, delimiter=_template_delimiter, quotechar=_quotechar):
+        """
+        DESCRIPTION:
+            A writer that helps to write delimited rows to sys.stdout.
+
+        PARAMETERS:
+            delimiter:
+                Optional Argument.
+                Specifies delimiter to use while writing the delimited string to stdout.
+                Default value: Value of _template_delimiter.
+                Types: string
+
+            quotechar:
+                Optional Argument.
+                Specifies delimiter to use while writing the delimited string to stdout.
+                Default value: Value of _quotechar.
+                Types: string
+
+        RETURNS:
+            An object of class StdoutWriter.
+
+        EXAMPLES:
+            >>> stdout_writer = StdoutWriter(delimiter="\t")
+        """
+        self.delimiter = delimiter
+        self.quotechar = quotechar
+
+    def write(self, data):
+        """
+        DESCRIPTION:
+            Function to write data to the Standard Output Stream as a delimited string.
+
+        PARAMETERS:
+            data:
+                The objects that needs to be written to the standard output stream as a delimited string.
+                Types: Pandas DataFrame, Pandas Series, or Numpy ndarray.
+
+        RETURNS:
+            None.
+
+        EXAMPLES:
+            >>> stdout_writer = StdoutWriter(delimiter="\t")
+
+            >>> # Write a numpy ndarray.
+            >>> import numpy as np
+            >>> x = np.arange(0.0,5.0,1.0)
+            >>> print(type(x))
+            <class 'numpy.ndarray'>
+            >>> stdout_writer.write(x)
+            0.0	1.0	2.0	3.0	4.0
+
+            >>> # Write a Pandas DataFrame
+            >>> import pandas as pd
+            >>> pdf = pd.DataFrame({{ 'id': [1, 2], 'value':[10, 20] }})
+            >>> stdout_writer.write(pdf)
+            1	10
+            2	20
+
+            >>> # Write a Pandas Series
+            >>> stdout_writer.write(pdf.id)
+            1	2
+        """
+        def write_np_array(row):
+            """
+            Helper function to write the numpy ndarray as a delimited string.
+
+            PARAMETERS:
+                row:
+                    Object of class numpy ndarray to write to stdout as delimited string.
+                    Types: numpy ndarray
+
+            RETURNS:
+                None.
+            """
+            # We check for NaNs and Nones in the output to make sure the output can be readily
+            # converted to the corresponding SQL type.
+            if self.quotechar is not None:
+                # A NULL value should not be enclosed in quotes.
+                # The CSV module has no support for such output with writer, and hence the custom formatting.
+                values = ['' if pd_isna(s) else "{{}}{{}}{{}}".format(self.quotechar,
+                                                                      str(_output_converters[ind](s)), self.quotechar)
+                                                                      for ind, s in enumerate(row)]
+            else:
+                values = ['' if pd_isna(s) else str(_output_converters[ind](s)) for ind, s in enumerate(row)]
+            print(self.delimiter.join(values), file=sys.stdout)
+
+        type_err_msg = "{{}} operation supports functions returning objects of type np.ndarray," \
+                       " pd.Series, or pd.DataFrame. Given: {{}}"
+
+        if data is None:
+            return
+        elif isinstance(data, pd_DataFrame):
+            # Iterate over rows and print the each row (numpy ndarray).
+            for _, row in data.iterrows():
+                write_np_array(row.values)
+        elif isinstance(data, pd_Series):
+            # Treat Series as a row - extract the numpy ndarray and write it.
+            write_np_array(data.values)
+        elif isinstance(data, np_ndarray):
+            # Print the numpy ndarray.
+            if data.ndim == 2:
+                # Two-dimensional array, with each array in the iteration
+                # representing an output row.
+                for inner_array in data:
+                    write_np_array(inner_array)
+            elif data.ndim == 1:
+                # One-dimensional array, representing an output row.
+                write_np_array(data)
+            else:
+                raise ValueError("Unsupported number of dimensions in numpy array: {{}}. "
+                                 "Expected one or two dimensions.".format(data.ndim))
+        else:
+            raise TypeError(type_err_msg.format(_operation, type(data).__name__))
+
+
+# The entry point to the script.
+if __name__ == "__main__":
+    kwargs = dict()
+    kwargs['chunksize'] = _chunk_size
+
+    # Also check if we need to use 'quotechar'.
+    if _quotechar is not None:
+        kwargs['quotechar'] = _quotechar
+        kwargs['quoting'] = 1  # QUOTE_ALL
+
+    rows = pd_read_csv(sys.stdin, sep=_template_delimiter, header=None, names=_col_names_list,
+                       index_col=False, converters=_input_converters, **kwargs)
+
+    # Create the writer to write the output.
+    stdout_writer = StdoutWriter(delimiter=_template_delimiter)
+
+    if _operation == "map_row" or _operation == "apply":
+        # When the type of operation to be performed is "map_row", we first get
+        # a Pandas DataFrame of the given chunksize, and then we iterate over it
+        # to apply the user defined function each row in it.
+        for chunk in rows:
+            if chunk.shape[0] > 0:
+                for _, row in chunk.iterrows():
+                    stdout_writer.write(_func(row))
+    elif _operation == "map_partition":
+        # When the type of operation to be performed is "map_partition", we
+        # pass the input (iterator to get Pandas DataFrame in chunks or in
+        # a single call) to the user defined function.
+        stdout_writer.write(_func(rows))
+    else:
+        raise TypeError("Unknown operation: {{}}".format(_operation))

teradataml/table_operators/templates/dataframe_register.template

@@ -0,0 +1,73 @@
+import json
+import sys, csv
+import datetime
+import urllib.parse
+import decimal
+
+td_buffer = {{}}
+
+
+{FUNCTION_DEFINITION}
+
+# Decode the URL encoded string and store it back as dictionary.
+dec = urllib.parse.unquote_plus(sys.argv[1])
+script_data = json.loads(dec)
+
+# Information that is required to help with the script usage.
+#  The delimiter to use with the input and output text.
+delimiter = script_data["delimiter"]
+#  The quotechar to use.
+quotechar = script_data["qoutechar"]
+#  The names of columns in the input teradataml DataFrame.
+_input_columns = script_data["input_cols"]
+#  The names of columns in the output teradataml DataFrame.
+_output_columns = script_data["output_cols"]
+#  The types of columns in the input/output teradataml DataFrame.
+# The mapper of output column name to function arguments
+function_args = script_data["function_args"]
+#  The definition for new columns in output.
+columns_definitions = {{_output_columns[-1]: "{FUNCTION_NAME}"}}
+output_type_converters = script_data["output_type_converters"]
+for k,v in output_type_converters.items():
+    if v == 'datetime.date' or v == 'datetime.time' or v == 'datetime.datetime':
+        output_type_converters[k] = 'str'
+output_type_converters = {{
+    k: (decimal.Decimal if v == 'decimal.Decimal' else getattr(__builtins__, v))
+    for k, v in output_type_converters.items()
+}}
+
+
+
+# The entry point to the script.
+if __name__ == "__main__":
+
+    records = csv.reader(sys.stdin.readlines(), delimiter=delimiter, quotechar=quotechar)
+    for record in records:
+        record = dict(zip(_input_columns, record))
+        out_rec = []
+        for column in _output_columns:
+
+            # If it is a new column, get the value from definition.
+            if column in columns_definitions:
+                f_args = tuple()
+                # Convert the argument types first.
+                for v in function_args[column]:
+                    if v in _input_columns:
+                        c_type_ = output_type_converters.get(v)
+                        if record[v]:
+                            # If it is a float, replace the empty character.
+                            if c_type_.__name__ == 'float':
+                                arg = output_type_converters.get(v)(record[v].replace(' ', ''))
+                            else:
+                                arg = output_type_converters.get(v)(record[v])
+                        else:
+                            arg = record[v] if c_type_.__name__ == 'str' else None
+                    else:
+                        arg = v
+                    f_args = f_args + (arg, )
+                func_ = globals()[columns_definitions[column]]
+                out_rec.append(output_type_converters[column](func_(*f_args)))
+            else:
+                out_rec.append(record[column])
+
+        print("{{}}".format(delimiter).join((str(i) for i in out_rec)))

teradataml/table_operators/templates/dataframe_udf.template

@@ -0,0 +1,67 @@
+import sys, csv
+import datetime
+import decimal
+
+td_buffer = {{}}
+
+
+{FUNCTION_DEFINITION}
+
+function_args = {FUNCTION_ARGS}
+# Information that is required to help with the script usage.
+#  The delimiter to use with the input and output text.
+delimiter = "{DELIMITER}"
+#  The names of columns in the input teradataml DataFrame.
+_input_columns = {INPUT_COLUMNS}
+#  The names of columns in the output teradataml DataFrame.
+_output_columns = {OUTPUT_COLUMNS}
+#  The definition for new columns in output.
+columns_definitions = {COLUMNS_DEFINITIONS}
+#  The types of columns in the input/output teradataml DataFrame.
+output_type_converters = {OUTPUT_TYPE_CONVERTERS}
+for k,v in output_type_converters.items():
+    if v == 'datetime.date' or v == 'datetime.time' or v == 'datetime.datetime':
+        output_type_converters[k] = 'str'
+output_type_converters = {{
+    k: (decimal.Decimal if v == 'decimal.Decimal' else getattr(__builtins__, v))
+    for k, v in output_type_converters.items()
+}}
+#  The quotechar to use.
+quotechar = "{QUOTECHAR}"
+if quotechar == "None":
+    quotechar = None
+
+
+# The entry point to the script.
+if __name__ == "__main__":
+
+    records = csv.reader(sys.stdin.readlines(), delimiter=delimiter, quotechar=quotechar)
+    for record in records:
+        record = dict(zip(_input_columns, record))
+        out_rec = []
+        for column in _output_columns:
+
+            # If it is a new column, get the value from definition.
+            if column in columns_definitions:
+                f_args = tuple()
+                # Convert the argument types first.
+                for v in function_args[column]:
+                    if v in _input_columns:
+                        c_type_ = output_type_converters.get(v)
+                        if record[v]:
+                            # If it is a float, replace the empty character.
+                            if c_type_.__name__ == 'float':
+                                arg = output_type_converters.get(v)(record[v].replace(' ', ''))
+                            else:
+                                arg = output_type_converters.get(v)(record[v])
+                        else:
+                            arg = record[v] if c_type_.__name__ == 'str' else None
+                    else:
+                        arg = v
+                    f_args = f_args + (arg, )
+                func_ = globals()[columns_definitions[column]]
+                out_rec.append(output_type_converters[column](func_(*f_args)))
+            else:
+                out_rec.append(record[column])
+
+        print("{{}}".format(delimiter).join((str(i) for i in out_rec)))

teradataml/table_operators/templates/script_executor.template

@@ -0,0 +1,170 @@
+import csv
+import os
+from pandas import isna as pd_isna
+import subprocess
+import sys
+import teradatasql
+from base64 import b64decode as base64_b64decode
+from io import StringIO
+from pickle import loads as pickle_load
+
+
+# Information that is required to help with the script usage.
+
+# Whether the input data must be read from file or AMP.
+_data_source = pickle_load(base64_b64decode({DATA_SOURCE}))
+#  The delimiter to use with the input and output text.
+_template_delimiter = pickle_load(base64_b64decode({DELIMITER}))
+#  The quotechar to use.
+_quotechar = pickle_load(base64_b64decode({QUOTECHAR}))
+# User script path.
+_user_script_path = pickle_load(base64_b64decode({USER_SCRIPT_PATH}))
+# Script args.
+_script_args = pickle_load(base64_b64decode({SCRIPT_ARGS}))
+# Input data file path.
+_data_file_path = pickle_load(base64_b64decode({DATA_FILE_PATH}))
+# Input data file delimiter.
+_input_data_file_delimiter = pickle_load(base64_b64decode({INPUT_DATA_FILE_DELIMITER}))
+# Input data file quotechar
+_input_data_file_quote_char = pickle_load(base64_b64decode({INPUT_DATA_FILE_QUOTE_CHAR}))
+# The boolean flag indicating whether the input data file has header
+_input_data_file_header = pickle_load(base64_b64decode({INPUT_DATA_FILE_HEADER}))
+# DB Host.
+_db_host = pickle_load(base64_b64decode({DB_HOST}))
+# DB User.
+_db_user = pickle_load(base64_b64decode({DB_USER}))
+# DB password.
+_db_pass = pickle_load(base64_b64decode({DB_PASS}))
+# DB name.
+_db_name = pickle_load(base64_b64decode({DB_NAME}))
+# Table name.
+_table_name = pickle_load(base64_b64decode({TABLE_NAME}))
+# Logmech.
+_logmech = pickle_load(base64_b64decode({LOGMECH}))
+# Logdata.
+_logdata = pickle_load(base64_b64decode({LOGDATA}))
+
+# Function for reading data from file and passing it as input to user script.
+def read_from_file(cmd):
+    # Check if input file path not exists.
+    if not os.path.isfile(_data_file_path):
+        print(_data_file_path + " is not a valid file path.")
+        sys.exit(1)
+
+    # Read data from input file.
+    with open(_data_file_path) as data_file:
+        data_handle = StringIO()
+
+        ip_data = csv.reader(data_file, delimiter=_input_data_file_delimiter,
+                             quotechar=_input_data_file_quote_char)
+        # Skip the first row of input file if input_data_file_header is True
+        if _input_data_file_header:
+            next(ip_data)
+        for row in ip_data:
+            if _quotechar is not None:
+                # A NULL value should not be enclosed in quotes.
+                # The CSV module has no support for such output with writer,
+                # and hence the custom formatting.
+                line = ['' if pd_isna(s) else "{{}}{{}}{{}}".format(_quotechar, str(s),
+                                                                    _quotechar)
+                        for s in row]
+            else:
+                line = ['' if pd_isna(s) else str(s) for s in row]
+
+            complete_line = (_template_delimiter.join(line))
+            data_handle.write(complete_line)
+            data_handle.write("\n")
+
+        # Launch a process for running user script
+        output = execute_user_script(cmd, data_handle)
+        print(output)
+
+# Function for reading data from db and passing it as input to user script.
+def read_from_db(cmd):
+    db_data_handle = StringIO()
+    try:
+        db_name = _db_user
+        if _db_name:
+            db_name = _db_name
+
+        # Connecting to database.
+        if _logmech == 'JWT':
+            conn = teradatasql.connect(database=db_name, host=_db_host, user=_db_user,
+                                       password=_db_pass, logmech=_logmech,
+                                       logdata=_logdata)
+        else:
+            conn = teradatasql.connect(database=db_name, host=_db_host, user=_db_user,
+                                       password=_db_pass, logmech=_logmech)
+
+        with conn.cursor() as cur:
+            # Query for reading data from DB.
+            query = ("SELECT * FROM {{}} ORDER BY 1;".format(_table_name))
+            cur.execute(query)
+            row = cur.fetchone()
+            while row:
+                if _quotechar is not None:
+                    # A NULL value should not be enclosed in quotes.
+                    # The CSV module has no support for such output with writer,
+                    # and hence the custom formatting.
+                    line = ['' if pd_isna(s) else "{{}}{{}}{{}}".format(_quotechar,
+                                                                        str(s),
+                                                                        _quotechar)
+                            for s in row]
+                else:
+                    line = ['' if pd_isna(s) else str(s) for s in row]
+
+                complete_line = (_template_delimiter.join(line))
+                db_data_handle.write(complete_line)
+                db_data_handle.write("\n")
+                row = cur.fetchone()
+        conn.close()
+    except teradatasql.OperationalError as exp:
+        print("Container: Error: {{}}".format(exp), file=sys.stderr)
+        # Exit code 2 indicates either username or password is invalid.
+        sys.exit(2)
+    except teradatasql.Error as exp:
+        print("Container: Error: {{}}".format(exp), file=sys.stderr)
+        # Exit code 3 indicates problem with query.
+        sys.exit(3)
+    except Exception as exp:
+        print("Container: Error: {{}}".format(exp), file=sys.stderr)
+        # Exit code 4 indicates all other exceptions / errors.
+        sys.exit(4)
+
+    # Launching a new process to run user script.
+    output = execute_user_script(cmd, db_data_handle)
+    print(output)
+
+# Function to run user script.
+def execute_user_script(cmd, data_handle):
+    # Launch a process for running user script.
+    proc = subprocess.Popen(cmd, stdin=subprocess.PIPE,
+                            stdout=subprocess.PIPE)
+    process_output, process_error = proc.communicate(
+        data_handle.getvalue().encode())
+    data_handle.close()
+
+    if proc.returncode != 0 or process_error:
+        print("Container: Error: {{}}".format(process_error), file=sys.stderr)
+        # Exit code 1 indicates any error thrown by subprocess.
+        sys.exit(1)
+    else:
+        return(process_output.decode("utf-8").rstrip("\r|\n"))
+
+if __name__ == "__main__":
+    # Check if python file path exists.
+    if not os.path.isfile(_user_script_path):
+        print(_user_script_path + " is not a valid file path.")
+        sys.exit(1)
+
+    # Launch a new process to run user script.
+    script_args = ""
+    if _script_args:
+        script_args = _script_args.split()
+    cmd = ["python3", _user_script_path]
+    cmd.extend(script_args)
+
+    if _data_source == "file":
+        read_from_file(cmd)
+    elif _data_source == "db":
+        read_from_db(cmd)