teradataml 20.0.0.3__py3-none-any.whl → 20.0.0.4__py3-none-any.whl

teradataml/scriptmgmt/lls_utils.py

@@ -74,6 +74,11 @@ def list_base_envs():
             5        r_4.0.2        R   4.0.2
             >>>
     """
+    # Check if the cache data is available and is not stale.
+    # If available, return the data.
+    if _InternalBuffer.get('list_base_envs') is not None:
+        return _InternalBuffer.get('list_base_envs')
+
     try:
         response = UtilFuncs._http_request(_get_ues_url("base_environments"), headers=_get_auth_token())
 
@@ -86,7 +91,8 @@ def list_base_envs():
             return
 
         # Create a pandas DataFrame from data.
-        return pd.DataFrame.from_records(data)
+        _InternalBuffer.add(list_base_envs=pd.DataFrame.from_records(data))
+        return _InternalBuffer.get('list_base_envs')
 
     except (TeradataMlException, RuntimeError):
         raise
@@ -417,21 +423,20 @@ def __create_envs(template):
                 # Install files if requested any.
                 if files:
                     print("Installing files in environment '{}'...".format(env_name))
-                    try:
-                        if isinstance(files, str):
-                            files = [files]
+                    if isinstance(files, str):
+                        files = [files]
 
-                        for file in files:
+                    for file in files:
+                        try:
                             if os.path.isfile(file):
                                 env_handle.install_file(file)
                             elif os.path.isdir(file):
-                                __install_files(env_handle, file)
-                        print("File installation in environment '{}' - Completed.".format(env_name))
-                    except Exception as file_installation_failure:
-                        print("Failed to process file installation request for environment: '{}'".format(env_name))
-                        print(str(file_installation_failure))
-                        errored = errored or True
-                        pass
+                                errored = __install_files(env_handle, file)
+                        except Exception as file_installation_failure:
+                            print("Failed to install file '{}' in environment '{}'.".format(file, env_name))
+                            print(str(file_installation_failure))
+                            errored = True
+                            pass
 
                 # Install libraries if requested any.
                 if libs or libs_file_path:
@@ -472,6 +477,10 @@ def __get_default_base_env():
     Function returns the latest python environment available with
     Open Analytics Framework.
     """
+    # Check if the default base environment is already available.
+    if _InternalBuffer.get('default_base_env') is not None:
+        return _InternalBuffer.get('default_base_env')
+
     try:
         base_envs = list_base_envs()
         python_versions = base_envs[base_envs.language == 'Python']['version']
@@ -481,7 +490,9 @@ def __get_default_base_env():
         latest_version_tuple = max(version_tuples)
         # Convert the latest version tuple back to a string
         latest_version = '.'.join(map(str, latest_version_tuple))
-        return base_envs[base_envs.version == latest_version]['base_name'].to_list()[0]
+        # Get the base environment name for the latest version
+        _InternalBuffer.add(default_base_env=base_envs[base_envs.version == latest_version]['base_name'].to_list()[0])
+        return _InternalBuffer.get('default_base_env')
     except Exception as base_env_err:
         raise Exception("Failed to obtain default base environment.", str(base_env_err.exception))
 
@@ -491,9 +502,20 @@ def __install_files(env, directory):
     Function to install files under given directory and
     all the subdirectories recursively.
     """
+    errored = False
     for (dir_path, dir_names, file_names) in os.walk(directory):
+        # install the files under all the directories.
+        # If any problem with any file installation, skip the error
+        # and proceed to install other files.
         for file_name in file_names:
-            env.install_file(os.path.join(dir_path, file_name))
+            try:
+                env.install_file(os.path.join(dir_path, file_name))
+            except Exception as file_installation_failure:
+                print("Failed to install file '{}' in environment '{}'.".format(file_name, env.env_name))
+                print(str(file_installation_failure))
+                errored = True
+
+    return errored
 
 
 @collect_queryband(queryband="CrtEnv")
@@ -751,9 +773,27 @@ def create_env(env_name=None, base_env=None, desc=None, template=None, conda_env
         # Get the latest python base env in OpenAF, if base_env is not provided,
         # Or if base_env is provided and not in the list of base envs.
         # Note: By default python base env is obtained.
-        if not base_env or \
-        (base_env and  base_env.lower() not in list_base_envs()['base_name'].str.lower().to_list()):
-            base_env = __get_default_base_env()
+        if configure.ues_url is not None and \
+        get_connection() is not None:
+            # Check if base_env is provided or not in the list of base envs.
+
+            # Check if user requested for conda environment but do not specify the base_env.
+            # In such case, set base_env to the default python base environment.
+            if conda_env:
+                if base_env is None:
+                    base_env = __get_default_base_env()
+            # Not a conda environment.
+            else:
+                # Check if base_env provided or not. If provided, check if it is available in
+                # the list of base envs. If not available, set base_env to the default python base env.
+                if not base_env or \
+                    base_env.lower() not in list_base_envs()['base_name'].str.lower().to_list():
+                    # Print warning message if base_env provided is not available.
+                    if base_env:
+                        print(f"Note: The specified base environment '{base_env}' is unavailable. "\
+                               "Using the default base environment as specified in the documentation.")
+                    # Set base_env to the default
+                    base_env = __get_default_base_env()
         if not desc:
             desc = "This env '{}' is created with base env '{}'.".format(env_name, base_env)
         try:
@@ -1559,7 +1599,6 @@ def get_user_env():
 
 
 @collect_queryband(queryband="StAthTkn")
-@argument_deprecation("20.00.00.04", "ues_url", False, "base_url")
 def set_auth_token(base_url=None, client_id=None, pat_token=None, pem_file=None, **kwargs):
     """
     DESCRIPTION:
@@ -1568,17 +1607,11 @@ def set_auth_token(base_url=None, client_id=None, pat_token=None, pem_file=None,
         Note:
             User must have a privilege to login with a NULL password to use set_auth_token().
             Please refer to GRANT LOGON section in Teradata Documentation for more details.
-            If ues_url and client_id are specified then authentication is through OAuth.
-            If ues_url, pat_token, pem_file are specified then authentication is through PAT.
+            If base_url and client_id are specified then authentication is through OAuth.
+            If base_url, pat_token, pem_file are specified then authentication is through PAT.
             Refresh token still works but only for OAuth authentication.
 
     PARAMETERS:
-
-        ues_url:
-            Required Argument.
-            Specifies the URL for User Environment Service in VantageCloud Lake.
-            Types: str
-
         base_url:
             Required Argument.
             Specifies the CCP endpoint URL.
@@ -1769,5 +1802,9 @@ def set_auth_token(base_url=None, client_id=None, pat_token=None, pem_file=None,
         token_data = auth_wf._proxy_jwt()
         # Store the jwt token in internal class attribute.
         _InternalBuffer.add(auth_token=_AuthToken(token=token_data))
+    # If set_auth_token is triggered then it will be ccp_enabled = True.
+    # The function returns if we have just passed the auth_token, thus
+    # having ccp_enabled = False.
+    configure._ccp_enabled = True
 
     return True

teradataml/store/__init__.py

@@ -9,5 +9,4 @@ This file imports components from Feature Store and Vector Store.
 """
 
 from teradataml.store.feature_store.feature_store import FeatureStore
-from teradataml.store.feature_store.models import *
-from teradataml.store.vector_store import *
+from teradataml.store.feature_store.models import *

teradataml/store/feature_store/feature_store.py

@@ -66,8 +66,7 @@ class FeatureStore:
         self.__df_container = {}
 
         # Store the table names here. Then use this where ever required.
-        self.__table_names = {name: UtilFuncs._get_qualified_table_name(self.__repo, table_name)
-                              for name, table_name in EFS_TABLES.items()}
+        self.__table_names = EFS_TABLES
 
         # Declare getter's for getting the corresponding DataFrame's.
         self.__get_features_df = lambda : self.__get_obj_df("feature")
@@ -1560,6 +1559,7 @@ class FeatureStore:
                 table_name = self.__table_names["{}_staging".format(type_)]
 
             res = _delete_data(table_name=table_name,
+                               schema_name=self.__repo,
                                delete_conditions=(Col("name") == name)
                                )
 
@@ -1606,11 +1606,13 @@ class FeatureStore:
 
         # remove it from xref table first.
         _delete_data(table_name=ent_table_xref,
+                     schema_name=self.__repo,
                      delete_conditions=(Col("entity_name") == name)
                      )
 
         # remove from entity table.
         res = _delete_data(table_name=ent_table,
+                           schema_name=self.__repo,
                            delete_conditions=(Col("name") == name)
                            )
 
@@ -1758,6 +1760,96 @@ class FeatureStore:
         """
         return self.__remove_obj(name=feature, type_="feature")
 
+    def delete(self):
+        """
+        DESCRIPTION:
+            Removes the FeatureStore and its components from repository.
+            Notes:
+                 * The function removes all the associated database objects along with data.
+                   Be cautious while using this function.
+                 * The function tries to remove the underlying Database also once
+                   all the Feature Store objects are removed.
+                 * The user must have permission on the database used by this Feature Store
+                    * to drop triggers.
+                    * to drop the tables.
+                    * to drop the Database.
+                 * If the user lacks any of the mentioned permissions, Teradata recommends
+                   to not use this function.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            bool.
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Setup FeatureStore for repo 'vfs_v1'.
+            >>> from teradataml import FeatureStore
+            >>> fs = FeatureStore("vfs_v1")
+            >>> fs.setup()
+            True
+            >>> # Delete FeatureStore.
+            >>> fs.delete()
+            True
+            >>>
+        """
+        confirmation = input("The function removes Feature Store and drops the "
+                             "corresponding repo also. Are you sure you want to proceed? (Y/N): ")
+
+        if confirmation in ["Y", "y"]:
+            return self.__drop_feature_store_objects(self.__repo)
+
+        return False
+
+    @staticmethod
+    def __drop_feature_store_objects(repo_name):
+        """
+        DESCRIPTION:
+            Removes the FeatureStore and it's components from repository.
+
+        PARAMETERS:
+            repo_name:
+                Required Argument.
+                Specifies the name of the repository.
+                Types: str
+
+        RETURNS:
+            bool
+        """
+        # Drop all the tables and staging tables.
+        tables_ = [
+            EFS_GROUP_FEATURES_SPEC["table_name"],
+            EFS_FEATURE_GROUP_SPEC["table_name"],
+            EFS_FEATURES_SPEC['table_name'],
+            EFS_ENTITY_XREF_SPEC['table_name'],
+            EFS_ENTITY_SPEC["table_name"],
+            EFS_DATA_SOURCE_SPEC["table_name"]
+        ]
+
+        tables_stg_ = [
+            EFS_FEATURES_STAGING_SPEC['table_name'],
+            EFS_ENTITY_STAGING_SPEC["table_name"],
+            EFS_ENTITY_XREF_STAGING_SPEC["table_name"],
+            EFS_DATA_SOURCE_STAGING_SPEC["table_name"],
+            EFS_FEATURE_GROUP_STAGING_SPEC["table_name"],
+            EFS_GROUP_FEATURES_STAGING_SPEC["table_name"]
+        ]
+
+        # Drop all the triggers first. So that tables can be dropped.
+        triggers = ["{}_trg".format(table) for table in tables_]
+        for trigger in triggers:
+            execute_sql("drop trigger {}.{}".format(repo_name, trigger))
+
+        for table in (tables_ + [EFS_VERSION_SPEC["table_name"]] + tables_stg_):
+            db_drop_table(table, schema_name=repo_name)
+
+        execute_sql("DROP DATABASE {}".format(repo_name))
+
+        return True
+
     def delete_feature(self, feature):
         """
         DESCRIPTION:
@@ -2134,10 +2226,12 @@ class FeatureStore:
 
         # Remove data for FeatureGroup.
         _delete_data(table_name=self.__table_names["group_features_staging"],
+                     schema_name=self.__repo,
                      delete_conditions=(Col("group_name") == fg_name)
                      )
 
         res = _delete_data(table_name=self.__table_names["feature_group_staging"],
+                           schema_name=self.__repo,
                            delete_conditions=(Col("name") == fg_name)
                            )
 
@@ -2175,25 +2269,26 @@ class FeatureStore:
             fs.__get_features_df()
         """
         if obj_type not in self.__df_container:
+            from teradataml.dataframe.dataframe import in_schema
 
             # For feature or feature_staging, join it with xref table
             # so group name appears while listing features.
             map_ = {"feature": "group_features", "feature_staging": "group_features_staging"}
             if obj_type in map_:
-                features = DataFrame(self.__table_names[obj_type])
-                features_xref = DataFrame(self.__table_names[map_[obj_type]]).select(
+                features = DataFrame(in_schema(self.__repo, self.__table_names[obj_type]))
+                features_xref = DataFrame(in_schema(self.__repo, self.__table_names[map_[obj_type]])).select(
                     ["feature_name", "group_name"])
                 df = features.join(features_xref, on="name==feature_name", how='left')
                 self.__df_container[obj_type] = df.select(features.columns+["group_name"])
             # For entity, join with xref table.
             elif obj_type == "entity" or obj_type == "entity_staging":
-                ent_df = DataFrame(self.__table_names[obj_type])
-                xref_df = DataFrame(self.__table_names["{}_xref".format(obj_type)]).select(
+                ent_df = DataFrame(in_schema(self.__repo, self.__table_names[obj_type]))
+                xref_df = DataFrame(in_schema(self.__repo, self.__table_names["{}_xref".format(obj_type)])).select(
                     ['entity_name', 'entity_column'])
                 df = ent_df.join(xref_df, on="name==entity_name", how="inner")
                 self.__df_container[obj_type] = df.select(ent_df.columns+["entity_column"])
             else:
-                self.__df_container[obj_type] = DataFrame(self.__table_names[obj_type])
+                self.__df_container[obj_type] = DataFrame(in_schema(self.__repo, self.__table_names[obj_type]))
 
         return self.__df_container[obj_type]
 

teradataml/table_operators/Apply.py

@@ -316,14 +316,6 @@ class Apply(TableOperator):
                                     is_local_order,
                                     sort_ascending,
                                     nulls_first)
-
-        # Set the variable specific to this child class.
-        self.apply_command = apply_command
-        self.env_name = env_name if env_name is not None else get_user_env()
-        self.style = style
-        self.returns = returns
-        self._skip_argument_validation = False
-
         # Create AnalyticsWrapperUtils instance which contains validation functions.
         # This is required for is_default_or_not check.
         # Rest all validation is done using _Validators
@@ -332,20 +324,42 @@ class Apply(TableOperator):
         # Perform argument validation for arguments specific to this class.
         self.__arg_info_matrix = []
 
-        self.__arg_info_matrix.append(["style", self.style, True, (str), True, ['CSV']])
-        self.__arg_info_matrix.append(["env_name", self.env_name, False, (str, UserEnv), True])
-        self.__arg_info_matrix.append(["apply_command", self.apply_command, False, (str), True])
-        self.__arg_info_matrix.append(["returns", self.returns, True, (dict), True])
-
+        self.__arg_info_matrix.append(["style", style, True, (str), True, ['CSV']])
+        self.__arg_info_matrix.append(["env_name", env_name, False, (str, UserEnv), True])
+        self.__arg_info_matrix.append(["apply_command", apply_command, False, (str), True])
+        self.__arg_info_matrix.append(["returns", returns, True, (dict), True])
+        self._skip_argument_validation = False
         # Perform the function argument validations.
         self.__apply__validate()
 
-        self.env = self.env_name if isinstance(self.env_name, UserEnv) else get_env(self.env_name)
+        # If user do not pass environment, get the default environment.
+        if env_name is None:
+            env_name = get_user_env()
+        self._open_af_env = env_name
+
+        # Set the variable specific to this child class.
+        self.apply_command = apply_command
+        self.env_name = env_name if isinstance(env_name, str) else env_name.env_name
+        self.style = style
+        self.returns = returns
+
+
+    @property
+    def env(self):
+        """
+        DESCRIPTION:
+            Getter to get environment.
+
+        RETURNS:
+            bool
+
+        RAISES:
+            None
+        """
+        if isinstance(self._open_af_env, str):
+            self._open_af_env = get_env(self._open_af_env)
 
-        # User can specify object of UserEnv class. Or if environment is already created just pass
-        # remote user environment name as string.
-        if isinstance(self.env_name, UserEnv):
-            self.env_name = self.env_name.env_name
+        return self._open_af_env
 
     @property
     def skip_argument_validation(self):

teradataml/table_operators/Script.py

@@ -1701,7 +1701,9 @@ class Script(TableOperator):
                                                 gc_on_quit=True, quote=False,
                                                 table_type=table_type)
         try:
-            if output_style == OutputStyle.OUTPUT_TABLE.value:
+            if configure.temp_object_type == TeradataConstants.TERADATA_VOLATILE_TABLE:
+                UtilFuncs._create_table(tblop_stdout_temp_tablename, self._tblop_query, volatile=True)
+            elif output_style == OutputStyle.OUTPUT_TABLE.value:
                 UtilFuncs._create_table(tblop_stdout_temp_tablename, self._tblop_query)
             else:
                 UtilFuncs._create_view(tblop_stdout_temp_tablename, self._tblop_query)

teradataml/table_operators/TableOperator.py

@@ -458,7 +458,9 @@ class TableOperator:
                                                                           )
 
         try:
-            if output_style == OutputStyle.OUTPUT_TABLE.value:
+            if configure.temp_object_type == TeradataConstants.TERADATA_VOLATILE_TABLE:
+                UtilFuncs._create_table(tblop_stdout_temp_tablename, self._tblop_query, volatile=True)
+            elif output_style == OutputStyle.OUTPUT_TABLE.value:
                 UtilFuncs._create_table(tblop_stdout_temp_tablename, self._tblop_query)
             else:
                 UtilFuncs._create_view(tblop_stdout_temp_tablename, self._tblop_query)

teradataml/utils/dtypes.py

@@ -293,10 +293,57 @@ class _DtypesMappers:
         VARCHAR: lambda x: "{0},{1}".format(x.__class__.__name__, x.length)
     }
 
+    # Holds mapping between string representation of teradatasqlalchemy type
+    # and actual teradatasqlalchemy type.
+    DATALAKE_STR_to_TDSQLALCHEMY_DATATYPE_MAPPER = {
+        "CHAR": CHAR,
+        "VARCHAR": VARCHAR,
+
+        "BYTEINT": BYTEINT,
+        "SMALLINT": SMALLINT,
+        "INTEGER": INTEGER,
+        "BIGINT": BIGINT,
+
+        "REAL": FLOAT,
+        "FLOAT": FLOAT,
+        "DOUBLE": FLOAT,
+        "DECIMAL": DECIMAL,
+        "NUMBER": NUMBER,
+
+        "DATE": DATE,
+        "TIME": TIME,
+        "TIMESTAMP": TIMESTAMP,
+        "TIMESTAMP_WTZ": TIMESTAMP,
+
+        "BYTE": BYTE,
+        "VARBYTE": VARBYTE,
+        "BLOB": BLOB,
+        # TODO: Add CLOB type when support is added from OTF.
+
+        # TODO: Check these types when corresponding data type support
+        #  is available from OTF support or not.
+        "INTERVAL_YEAR": INTERVAL_YEAR,
+        "INTERVAL_YTM": INTERVAL_YEAR_TO_MONTH,
+        "INTERVAL_MONTH": INTERVAL_MONTH,
+        "INTERVAL_DAY": INTERVAL_DAY,
+
+        "INTERVAL_DTH": INTERVAL_DAY_TO_HOUR,
+        "INTERVAL_DTM": INTERVAL_DAY_TO_MINUTE,
+        "INTERVAL_DTS": INTERVAL_DAY_TO_SECOND,
+        "INTERVAL_HOUR": INTERVAL_HOUR,
+        "INTERVAL_HTM": INTERVAL_HOUR_TO_MINUTE,
+        "INTERVAL_HTS": INTERVAL_HOUR_TO_SECOND,
+        "INTERVAL_MINUTE": INTERVAL_MINUTE,
+        "INTERVAL_MTS": INTERVAL_MINUTE_TO_SECOND,
+        "INTERVAL_SECOND": INTERVAL_SECOND
+    }
+
+
 class _SuppArgTypes:
     VAL_ARG_DATATYPE = (str, BIGINT, BYTEINT, CHAR, DATE, DECIMAL, FLOAT, INTEGER, NUMBER, SMALLINT, TIME,
                         TIMESTAMP, VARCHAR)
 
+
 class _Dtypes:
 
     @staticmethod

teradataml/utils/internal_buffer.py

@@ -82,3 +82,21 @@ class _InternalBuffer:
         """
         if key in cls.__data:
             return cls.__data.get(key)
+
+    @classmethod
+    def remove_key(cls, key):
+        """
+        DESCRIPTION:
+            Remove a particular key from the internal buffer.
+
+        RETURNS:
+            None
+
+        RAISES:
+            None
+
+        EXAMPLES:
+            # Remove all json objects from _InternalBuffer.
+            _InternalBuffer.remove_key("vs_session_id")
+        """
+        del cls.__data[key]

teradataml/utils/validators.py

@@ -286,7 +286,8 @@ class _Validators:
 
     @staticmethod
     @skip_validation()
-    def _validate_dataframe_has_argument_columns(columns, column_arg, data, data_arg, is_partition_arg=False):
+    def _validate_dataframe_has_argument_columns(columns, column_arg, data, data_arg, is_partition_arg=False, 
+                                                 case_insensitive=False):
         """
         Function to check whether column names in columns are present in given dataframe or not.
         This function is used currently only for Analytics wrappers.
@@ -312,12 +313,19 @@ class _Validators:
                 Specifies the name of the dataframe argument.
                 Types: str
 
-            isPartitionArg:
+            is_partition_arg:
                 Optional Argument.
                 Specifies a bool argument notifying, whether argument being validate is
                 Partition argument or not.
                 Types: bool
 
+            case_insensitive:
+                Optional Argument.
+                Specifies a bool argument notifying, whether to check column names
+                in case-insensitive manner or not.
+                Default Value: False
+                Types: bool
+
         RAISES:
             TeradataMlException - TDMLDF_COLUMN_IN_ARG_NOT_FOUND column(s) does not exist in a dataframe.
 
@@ -359,7 +367,7 @@ class _Validators:
                     try:
                         # Check if its a sinlge column with one separator. For e.g. column:A.
                         # If yes, just continue.
-                        _Validators._validate_column_exists_in_dataframe(column, data._metaexpr)
+                        _Validators._validate_column_exists_in_dataframe(column, data._metaexpr, case_insensitive=case_insensitive)
                         continue
                     except:
                         # User has provided range value.
@@ -382,7 +390,8 @@ class _Validators:
                     total_columns.append(column)
 
         return _Validators._validate_column_exists_in_dataframe(total_columns, data._metaexpr, column_arg=column_arg,
-                                                                data_arg=data_arg)
+                                                                data_arg=data_arg, case_insensitive=case_insensitive)
+    
 
     @staticmethod
     @skip_validation()
@@ -1398,7 +1407,8 @@ class _Validators:
 
     @staticmethod
     @skip_validation()
-    def _validate_unexpected_column_type(df, col, col_arg, unexpected_types, check_exist=True, raise_error=True):
+    def _validate_unexpected_column_type(df, col, col_arg, unexpected_types, check_exist=True, raise_error=True,
+                                         case_insensitive=False):
         """
         Internal function to validate the column existence and type of an input DataFrame column against
         a list of unexpected types.
@@ -1464,7 +1474,7 @@ class _Validators:
 
             # Check for column existence.
             if check_exist:
-                _Validators._validate_column_exists_in_dataframe(col, df._metaexpr)
+                _Validators._validate_column_exists_in_dataframe(col, df._metaexpr, case_insensitive=case_insensitive)
 
             if isinstance(df[col].type, unexpected_types):
                 if raise_error:
@@ -2303,7 +2313,56 @@ class _Validators:
             >>> _Validators._check_auth_token("udf")
         """
         if _InternalBuffer.get("auth_token") is None:
-            raise TeradataMlException(Messages.get_message(MessageCodes.AUTH_TOKEN_REQUIRED,\
-                                                           func_name), MessageCodes.AUTH_TOKEN_REQUIRED)
+            raise TeradataMlException(Messages.get_message(MessageCodes.SET_REQUIRED_PARAMS,\
+                                                           'Auth Token', func_name,
+                                                           'set_auth_token'),
+                                      MessageCodes.SET_REQUIRED_PARAMS)
         
-        return True
+        return True
+
+    @staticmethod
+    def _check_required_params(arg_value, arg_name, caller_func_name, target_func_name):
+        """
+        DESCRIPTION:
+            Check if the required argument is not None.
+
+        PARAMETERS:
+            arg_value:
+                Required Argument.
+                Specifies the argument value to be
+                checked for non None values.
+                Types: str, float, int, bool
+
+            arg_name:
+                Required Argument.
+                Specifies the argument name.
+                Types: str
+
+            caller_func_name:
+                Required Argument.
+                Specifies the function name which calls this function.
+                This is required for the error message.
+                Types: str
+
+            target_func_name:
+                Required Argument.
+                Specifies the function name which the user needs to call
+                so that the error is fixed.
+                This is required for the error message.
+                Types: str
+
+        RAISES:
+            TeradataMLException
+
+        RETURNS:
+            True.
+
+        EXAMPLES:
+            >>> _Validators._check_required_params("udf", "arg_name")
+        """
+        if arg_value is None:
+            raise TeradataMlException(Messages.get_message(MessageCodes.SET_REQUIRED_PARAMS, \
+                                                           arg_name, caller_func_name,
+                                                           target_func_name),
+                                      MessageCodes.SET_REQUIRED_PARAMS)
+        return True