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

teradataml/catalog/model_cataloging_utils.py

@@ -308,91 +308,6 @@ def __check_if_client_specific_use(key, function_arg_map, is_sql_name=False):
     else:
         return False, None
 
-
-def __get_model_parameters(model, function_arg_map):
-    """
-    DESCRIPTION:
-        Internal function to get parameter information of the model to be saved.
-
-    PARAMETERS:
-        model:
-            Required argument.
-            The model (analytic function object instance) to be saved.
-            Types: teradataml Analytic Function object.
-
-        function_arg_map:
-            Required argument.
-            The teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-    RETURNS:
-        A dict containing the information about parameters passed to model.
-
-    EXAMPLES:
-        >>> model_parameters = __get_model_parameters(model, function_arg_map)
-    """
-    parameter_json = {}
-
-    # Get the attributes that are specific to the SQL syntax of the model algorithm
-    sql_specific_attributes = model._get_sql_specific_attributes()
-
-    # First, let's identify the parameters
-    nonsql_argument_counter = 1
-    for key in model.__dict__:
-        if not key.startswith('_'):
-            member = getattr(model, key)
-            # Check if this is an attribute, not a DataFrame
-            if not isinstance(member, DataFrame) and key != "sqlmr_query":
-                # Check if it is a special or client specific argument
-                special_use, used_in = __check_if_client_specific_use(key, function_arg_map)
-
-                value = member
-                # Add quotes to Boolean values as they tend to be handled in unintended way with JSON.
-                if type(member) == bool or key == famc.TDML_FORMULA_NAME.value:
-                    value = str(member)
-                else:
-                    if isinstance(member, list):
-                        # We try to save the list as a string representation that could readily be used,
-                        # in SQL, and has no language specific representation.
-                        # Here, we remove the '[' and ']' from the string representation.
-                        # We also avoid adding quotes around single-item list.
-                        if len(member) == 1:
-                            value = str(member[0]) if type(member[0]) == bool else member[0]
-                        elif len(member) > 1:
-                            if type(member[0]) == bool:
-                                member = ['{}'.format(val) for val in member]
-                            value = str(member).lstrip('[').rstrip(']')
-                        else:
-                            # Empty list has no meaning, but no chance of running into this with the validation
-                            # in the function wrappers.
-                            value = None
-                if value is not None:
-                    if special_use:
-                        sql_name = '__nonsql_argument_{}__'.format(nonsql_argument_counter)
-                        nonsql_argument_counter = nonsql_argument_counter + 1
-                    else:
-                        sql_name = __get_arg_sql_name_from_tdml(function_arg_map,arg_type=famc.ARGUMENTS.value,name=key)
-                    parameter_json[sql_name] = {}
-                    parameter_json[sql_name]["value"] = value
-                    parameter_json[sql_name]["client_specific_name"] = key
-
-    sql_name = '__nonsql_argument_{}__'.format(nonsql_argument_counter)
-    parameter_json[sql_name] = {}
-    parameter_json[sql_name]["value"] = model.__class__.__name__
-    parameter_json[sql_name]["client_specific_name"] = "__class_name__"
-
-    # Add the SQL specific arguments
-    for sql_name in sql_specific_attributes:
-        parameter_json[sql_name] = {}
-        parameter_json[sql_name]["value"] = sql_specific_attributes[sql_name]
-        # Also save the formula related property names for corresponding SQL arguments
-        if hasattr(model, '_sql_formula_attribute_mapper'):
-            if sql_name in model._sql_formula_attribute_mapper:
-                parameter_json[sql_name]["client_specific_name"] = model._sql_formula_attribute_mapper[sql_name]
-
-    return parameter_json
-
-
 def __check_if_model_exists(name, created=False, accessible=False,
                             raise_error_if_exists=False, raise_error_if_model_not_found=False):
     """
@@ -477,89 +392,6 @@ def __check_if_model_exists(name, created=False, accessible=False,
                                                                name, ' or not created by user'),
                                           MessageCodes.MODEL_NOT_FOUND)
 
-
-def __check_if_model_cataloging_tables_exists(raise_error_if_does_not_exists=True):
-    """
-    DESCRIPTION:
-        Check whether Model Cataloging tables (one of the views - ModelCataloging.ModelsV) exists or not.
-
-    PARAMETERS:
-        raise_error_if_does_not_exists:
-            Optional Argument.
-            Specifies the flag to decide whether to raise error when Model Cataloging tables does not exist.
-            Default Value: True (Raise exception)
-            Types: bool
-
-    RAISES:
-        None.
-
-    RETURNS:
-        True, if the view exists, else False.
-
-    EXAMPLES:
-        >>>  __check_if_model_cataloging_tables_exists()
-    """
-    # Get current connection().
-    conn = get_connection()
-
-    # Check whether tables exists on the system or not.
-    model_table_exists = conn.dialect.has_view(conn, view_name=mac.MODELS.value,
-                                                schema=mac.MODEL_CATALOG_DB.value)
-
-    # If both tables exist, return True.
-    if model_table_exists:
-        return True
-
-    # We are here means the Model Cataloging view does not exist.
-    # Let's raise error if 'raise_error_if_does_not_exists' set to True.
-    if raise_error_if_does_not_exists:
-        # Raise error, as one or both Model Cataloging tables does not exist.
-        # MODEL_CATALOGING_TABLE_DOES_EXIST
-        raise TeradataMlException(
-            Messages.get_message(MessageCodes.MODEL_CATALOGING_TABLE_DOES_EXIST),
-            MessageCodes.MODEL_CATALOGING_TABLE_DOES_EXIST)
-
-
-def __get_tables_for_model(name, current_user):
-    """
-    DESCRIPTION:
-        Function to get model tables for a given model name.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name of the model to get the model tables for.
-            Types: str
-
-        current_user:
-            Required Argument.
-            Specifies the name of the current Vantage user.
-            Types: str
-
-    RETURNS:
-        A list of model tables associated with the model.
-
-    EXAMPLES:
-        >>> table_list = __get_tables_for_model(name, current_user)
-    """
-    # Get list of tables
-    model_object_info = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_OBJECTS.value))
-    model_info = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELSX.value))
-    model_info = model_info[model_info[mac.CREATED_BY.value].str.lower() == current_user.lower()]
-    model_info = model_info[model_info[mac.MODEL_NAME.value] == name]
-    model_objects_to_publish = model_info.join(model_object_info,
-                                               on=[model_info.Name == model_object_info.ModelName],
-                                               how='inner').select([mac.MODEL_OBJ_TABLE_NAME.value])
-
-    model_objects_to_publish = model_objects_to_publish.to_pandas().squeeze()
-    if isinstance(model_objects_to_publish, str):
-        # If there is only one output table
-        return [model_objects_to_publish]
-    else:
-        # For multiple or no output tables
-        return model_objects_to_publish.tolist()
-
-
 def __get_current_user(conn=None):
     """
     DESCRIPTION:
@@ -619,36 +451,6 @@ def __get_like_filter_expression_on_col(metaexpr, column_name, like):
     return metaexpr._filter(0, 'like', [column_name], like = like, match_arg='i')
 
 
-def __get_model_engine(model):
-    """
-    DESCRIPTION:
-        Internal function to return the engine name on which the model was generated.
-
-    PARAMETERS:
-        model:
-            Required Argument.
-            Model object, for which engine is to be found.
-            Types: str
-
-    RETURNS:
-        Engine name ('ML Engine' or 'Advanced SQL Engine')
-
-    RAISES:
-        TeradataMlException
-
-    EXAMPLES:
-        >>> __get_model_engine(model)
-    """
-    if ".mle." in str(type(model)):
-        return mac.MODEL_ENGINE_ML.value
-    elif ".sqle." in str(type(model)):
-        return mac.MODEL_ENGINE_ADVSQL.value
-    else:
-        raise TeradataMlException(Messages.get_message(MessageCodes.UNKNOWN_MODEL_ENGINE,
-                                                       str(type(model))),
-                                  MessageCodes.UNKNOWN_MODEL_ENGINE)
-
-
 def __get_wrapper_class(model_engine, model_class):
     """
     DESCRIPTION:
@@ -674,11 +476,9 @@ def __get_wrapper_class(model_engine, model_class):
         AttributeError - When model_class wrapper function, does is not from model_engine.
 
     EXAMPLES:
-        >>> __get_wrapper_class("ML Engine", "GLM")
+        >>> __get_wrapper_class("SQL Engine", "GLM")
     """
-    if model_engine == mac.MODEL_ENGINE_ML.value:
-        module_name = "teradataml.analytics.mle"
-    elif model_engine == mac.MODEL_ENGINE_ADVSQL.value:
+    if model_engine == mac.MODEL_ENGINE_ADVSQL.value:
         module_name = "teradataml.analytics.sqle"
     else:
         raise ValueError("Invalid Engine found in Model Cataloging table.")
@@ -688,823 +488,4 @@ def __get_wrapper_class(model_engine, model_class):
     return getattr(wrapper_module, model_class)
 
 
-def __is_view(tablename):
-    """
-    DESCRIPTION:
-        Internal function to check whether the object is view or not.
-
-    PARAMETERS:
-        tablename:
-            Required Argument.
-            Table name or view name to be checked.
-            Types: str
-
-    RAISES:
-        None.
-
-    RETURNS:
-        True when the tablename is view, else false.
-
-    EXAMPLES:
-        >>> __is_view('"dbaname"."tablename"')
-    """
-    db_name = UtilFuncs._teradata_unquote_arg(UtilFuncs._extract_db_name(tablename), "\"")
-    table_view_name = UtilFuncs._teradata_unquote_arg(UtilFuncs._extract_table_name(tablename), "\"")
-    query = SQLBundle._build_select_table_kind(db_name, "{0}".format(table_view_name), "'V'")
-
-    pdf = pd.read_sql(query, get_context())
-    if pdf.shape[0] > 0:
-        return True
-    else:
-        return False
-
-
-def __delete_model_tableview(tableviewname):
-    """
-    DESCRIPTION:
-        Internal function to remove table name or view.
-
-    PARAMETERS:
-        tableviewname:
-            Required Argument.
-            Table name or view name to be deleted.
-            Types: str
-
-    RAISES:
-        None.
-
-    RETURNS:
-        bool
-
-    EXAMPLES:
-        >>> __delete_model_tableview('"dbname"."tableviewname"')
-    """
-    if not __is_view(tableviewname):
-        try:
-            UtilFuncs._drop_table(tableviewname)
-        except:
-            return False
-    else:
-        try:
-            UtilFuncs._drop_view(tableviewname)
-        except:
-            return False
-
-    return True
-
-
-def __get_all_formula_related_args(function_arg_map):
-    """
-    DESCRIPTION:
-        Internal function to find a list of all formula related arguments for a function.
-
-    PARAMETERS:
-        function_arg_map:
-            Required Argument.
-            The teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-    RETURNS:
-         A dictionary mapping all SQL Arguments for the function related to formula to its role in formula.
-
-    EXAMPLE:
-        >>> __get_all_formula_related_args(function_arg_map)
-    """
-    formula_args = {}
-    for arg_name in function_arg_map[famc.ARGUMENTS.value][famc.SQL_TO_TDML.value]:
-        arg = function_arg_map[famc.ARGUMENTS.value][famc.SQL_TO_TDML.value][arg_name]
-        # Ignore alternate names
-        if famc.ALTERNATE_TO.value in arg:
-            alternate_name = arg[famc.ALTERNATE_TO.value]
-            arg = function_arg_map[famc.ARGUMENTS.value][famc.SQL_TO_TDML.value][alternate_name]
-
-        if famc.USED_IN_FORMULA.value in arg:
-            formula_args[arg_name] = {}
-            formula_args[arg_name][famc.USED_IN_FORMULA.value] = arg[famc.USED_IN_FORMULA.value]
-            formula_args[arg_name]['arg_value'] = None
-
-    return formula_args
-
-
-def __fix_imbalanced_quotes(arg):
-    """
-    DESCRIPTION:
-        Internal function to fix imbalanced quotes around a string.
-
-    PARAMETERS:
-        arg:
-            Required Argument.
-            The string to fix the imbalanced quotes for, if any.
-            Types: str
-
-    RETURNS:
-         The input string with any imbalanced quotes stripped.
-
-    EXAMPLE:
-        >>> __fix_imbalanced_quotes('hello"')
-        hello
-    """
-    for quote in ["'", '"']:
-        if (arg.startswith(quote) and not arg.endswith(quote)) or (not arg.startswith(quote) and arg.endswith(quote)):
-            return arg.strip(quote)
-
-    return arg
-
-
-def __get_tdml_parameter_value_for_sequence(function_arg_map, attr_value):
-    """
-    DESCRIPTION:
-        Internal function to form sequence_column teradataml argument from SQL arguments.
-
-    PARAMETERS:
-        function_arg_map:
-            Required Argument.
-            The teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-        attr_value:
-            Required Argument.
-            The value of the SQL sequence argument.
-
-    RETURNS:
-         A dictionary mapping the teradataml sequence argument to its values.
-
-    EXAMPLES:
-        >>> tdml_sequence_args = __get_tdml_parameter_value_for_sequence(function_arg_map, sql_sequence_arg)
-    """
-    sequence_dict = {}
-    tdml_name = None
-    for column in attr_value.split(','):
-        if len(column) == 0:
-            continue
-        if ':' in column:
-            input_name, col_val = column.split(':')
-            input_name = __fix_imbalanced_quotes(input_name)
-            col_val = __fix_imbalanced_quotes(col_val)
-            tdml_name = '{}_{}'.format(__get_arg_tdml_name_from_sql(function_arg_map, famc.INPUTS.value,
-                                                                    input_name.lower()),
-                                       'sequence_column')
-            tdml_name = __fix_imbalanced_quotes(tdml_name)
-            sequence_dict[tdml_name] = [col_val]
-        else:
-            if tdml_name not in sequence_dict:
-                # This means there is only one input and the input name was not specified in the
-                # SequenceInputBy clause. So we get the only input name.
-                tdml_name = list(function_arg_map[famc.INPUTS.value][famc.TDML_TO_SQL.value].keys())[0]
-                tdml_name = '{}_{}'.format(tdml_name, 'sequence_column')
-                sequence_dict[tdml_name] = []
-            column = __fix_imbalanced_quotes(column)
-            sequence_dict[tdml_name].append(column)
-
-    return sequence_dict
-
-
-def __get_target_column(name):
-    """
-    DESCRIPTION:
-        Internal function to get the target column of a saved model.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name used to save the model.
-            Types: str
-
-    RETURNS:
-         A String representing the name of the target column.
-
-    EXAMPLES:
-        >>> target_column = __get_target_column('GLMModel')
-    """
-    model_details = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_DETAILSX.value))
-    model_details = model_details[model_details[mac.MODEL_DERIVED_NAME.value] == name]
-    target_column = model_details.select([mac.MODEL_DERIVED_TARGET_COLUMN.value]).squeeze()
-    return target_column
-
-
-def __get_tdml_parameter_value_for_formula(formula_args, target_column):
-    """
-    DESCRIPTION:
-        Internal function to build the formula argument based on the SQL equivalent inputs.
-
-    PARAMETERS:
-        formula_args:
-            Required Argument.
-            A dictionary mapping all SQL Arguments for the function related to formula to its role in formula.
-            Types: dict
-
-        target_column:
-            Required Argument.
-            The target column for the model, if any.
-            Types: str
-
-    RETURNS:
-         A String representing the formula argument to be used with teradataml.
-
-    EXAMPLES:
-        >>> formula = __get_tdml_parameter_value_for_formula(formula_args, target_column)
-    """
-    dependent_var = target_column
-    all_vars = []
-
-    for arg in formula_args:
-        if formula_args[arg]['arg_value'] is not None:
-            if formula_args[arg][famc.USED_IN_FORMULA.value] == famc.DEPENDENT_ATTR.value:
-                dependent_var = formula_args[arg]['arg_value'].strip("'")
-            else:
-                all_vars.extend(formula_args[arg]['arg_value'].split(','))
-
-    # Remove duplicates
-    all_vars = list(set(all_vars))
-    all_vars = [var.strip("'") for var in all_vars]
-
-    # Remove dependent variable if it occurs in all_vars
-    if dependent_var in all_vars:
-        all_vars.pop(all_vars.index(dependent_var))
-
-    formula = '{} ~ {}'.format(dependent_var, ' + '. join(all_vars))
-    return formula
-
-
-def __cast_arg_values_to_tdml_types(value, type_):
-    """
-    DESCRIPTION:
-        Internal function used by retrieve_model() to cast the retrieved model parameters to the expected python types.
-
-    PARAMETERS:
-        value:
-            Required Argument.
-            Specifies the value retrieved that needs a type cast.
-            Types: str
-
-        type_:
-            Required Argument.
-            Specifies the Python type the value needs to be cast to.
-            Type: Python type or tuple of Python types
-
-    RETURNS:
-        The value cast to the required Python type.
-
-    RAISES:
-        None
-
-    EXAMPLE:
-        >>> cast_value = __cast_arg_values_to_tdml_types('0.1', float)
-    """
-    return_value = None
-    required_type = type_
-
-    accepted_bool_values = ['1', 't', 'true', 'y', 'yes']
-
-    # If the required_type is a tuple, we need to consider the possibility of the value being a list
-    if isinstance(required_type, tuple):
-        # The function_argument_mapper adds the type of the object in the list as the first value in the tuple
-        required_type = required_type[0]
-
-        # Use regex to split the string value into a list.
-        # This is required only when we expect the values to be a list as well, in which case,
-        # the 'value' will be a comma-separated list of strings.
-        # The pattern matches anything but whitespace and comma and not in quotes, or anything in quotes,
-        # basically avoiding splitting on a comma when surrounded by quotes.
-        pattern = r"[^',\s]+|'[^']*'"
-        values = re.findall(pattern, value)
-        if len(values) > 1:
-            if required_type == bool:
-                # Remove the quotes surrounding items in a list,
-                # and check for their presence in the acceptable TRUE values.
-                return_value = [val.strip().strip("'").lower() in accepted_bool_values for val in values]
-            else:
-                # Remove the quotes surrounding items in a list cast them to the required type.
-                return_value = [required_type(val.strip().strip("'")) for val in values]
-        else:
-            value = values[0]
-
-    if return_value is None:
-        if required_type == bool:
-            # Remove the quotes surrounding the value,
-            # and check for their presence in the acceptable TRUE values.
-            return_value = value.strip().strip("'").lower() in accepted_bool_values
-        else:
-            # Remove the quotes surrounding the value and cast it to the required type.
-            return_value = required_type(value.strip().strip("'"))
-
-    return return_value
-
-
-def __get_model_access(name):
-    """
-    DESCRIPTION:
-        Internal function to get the current access level of a saved model.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name of the saved model to get the access level for.
-            Types: str
-
-    RAISES:
-        None.
-
-    RETURNS:
-        A String representing the access level of the saved model.
-
-    EXAMPLES:
-        >>> __get_model_access('saved_glm_model')
-    """
-    df = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_DETAILS.value))
-    return df[df[mac.MODEL_DERIVED_NAME.value] == name].select([mac.MODEL_ACCESS.value]).squeeze()
-
-
-def __get_tdml_type_for_tdml_arg(name, function_arg_map):
-    """
-    DESCRIPTION:
-        Internal function to get the Python type for the given teradataml model class attribute.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the teradataml name for the attribute to get the expected python type for.
-            Types: str
-
-        function_arg_map:
-            Required Argument.
-            Specifies the teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-    RETURNS:
-        Python type for the given teradataml model class attribute name.
-        None when argument name not found.
-
-    RAISES:
-        None
-
-    EXAMPLES:
-        >>> from teradataml.catalog.function_argument_mapper import _argument_mapper
-        >>> function_arg_map = _argument_mapper._get_function_map('ML Engine', 'glm')
-        >>> tdml_type = __get_tdml_type_for_tdml_arg('linkfunction', function_arg_map)
-    """
-    # Let's check if the function argument mapper has the information about the argument we are looking for.
-    # If not, let's return None.
-    if name not in function_arg_map[famc.ARGUMENTS.value][famc.TDML_TO_SQL.value]:
-        return None
-
-    tdml_type = str
-    sql_name = function_arg_map[famc.ARGUMENTS.value][famc.TDML_TO_SQL.value][name]
-
-    # We can ignore formula letting it default to str
-    special_use, used_in = __check_if_client_specific_use(name, function_arg_map)
-    if not special_use or used_in == famc.USED_IN_SEQUENCE_INPUT_BY.value:
-        tdml_type = function_arg_map[famc.ARGUMENTS.value][famc.SQL_TO_TDML.value][sql_name][famc.TDML_TYPE.value]
-
-    return tdml_type
-
-
-def __retrieve_model_class(name, model_client, function_arg_map):
-    """
-    DESCRIPTION:
-        Internal function to get the teradataml class used for generating model given it's name.
-
-    PARAMETERS:
-        name:
-            Optional Argument. Required when model was saved by teradataml.
-            Specifies the name of the model to retrieve the model attributes and output information for.
-            Types: str
-
-        model_client:
-            Required Argument.
-            Specified the name of the client used to generate the model.
-            Types: str
-
-        function_arg_map:
-            Optional Argument. Required when model was not saved by teradataml.
-            Specifies the teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-    RETURNS:
-        A String representing the teradataml class name corresponding to the model.
-
-    EXAMPLES:
-        >>> model_class = __retrieve_model_class(name, model_client, function_arg_map)
-    """
-    if model_client == mac.MODEL_TDML.value:
-        # Create DF on top of ModelAttributesV view
-        model_arguments = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_ATTRS.value))
-        model_arguments = model_arguments[model_arguments[mac.MODEL_DERIVED_NAME.value] == name]
-        model_class = model_arguments[model_arguments.ClientSpecificAttributeName.str.
-                                          contains(mac.MODEL_CLIENT_CLASS_KEY.value) == 1].\
-            select([mac.MODEL_ATTR_VALUE.value]).squeeze()
-    else:
-        model_class = function_arg_map[famc.FUNCTION_TDML_NAME.value]
-
-    return model_class
-
-
-def __retrieve_model_client_engine_algorithm(name, return_details=False):
-    """
-    DESCRIPTION:
-        Internal function to get the the model generating engine, client, algorithm, and optionally the model details
-        given the model name.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name of the model to retrieve the model attributes and output information for.
-            Types: str
-
-        return_details:
-            Optional Argument.
-            Specifies whether to also return the row from the ModelDetailsV corresponding to the model.
-            Types: bool
-            Default Value: False
-
-    RETURNS:
-        A tuple containing:
-        * the name of the client that was used to generate the model,
-        * the name of the engine that generated the model, and
-        * the name of the algorithm used to generate the model.
-        * If return_details=True, then additionally, the ModelDetailsV row related to the model.
-
-    EXAMPLES:
-        >>> model_client, model_engine, algorithm = __retrieve_model_client_engine_algorithm(name)
-    """
-
-    model_details = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_DETAILS.value))
-    model_details = model_details[model_details[mac.MODEL_DERIVED_NAME.value] == name]
-    model_algorithm = model_details.select([mac.MODEL_DERIVED_ALGORITHM.value]).squeeze().lower()
-
-    model_client_and_eng = model_details.select([mac.MODEL_DERIVED_GENCLIENT.value,
-                                                 mac.MODEL_DERIVED_GENENG.value]).squeeze()
-
-    model_client = model_client_and_eng.select([mac.MODEL_DERIVED_GENCLIENT.value]).squeeze()
-    model_engine = model_client_and_eng.select([mac.MODEL_DERIVED_GENENG.value]).squeeze()
-
-    if return_details:
-        return model_client, model_engine, model_algorithm, model_details
-    else:
-        return model_client, model_engine, model_algorithm
-
-
-def __retrieve_model_attributes(name, model_client, function_arg_map):
-    """
-    DESCRIPTION:
-        Internal function to get the the attributes used for generating model given it's name.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name of the model to retrieve the model attributes and output information for.
-            Types: str
-
-        model_client:
-            Required Argument.
-            Specified the name of the engine that generated the model.
-            Types: str
-
-        function_arg_map:
-            Required Argument.
-            Specifies the teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-    RETURNS:
-        A tuple of dictionaries:
-        * the first one containing the attribute names and their values, and
-        * the second one containing the formula related properties and their values, if the model saving client was
-          teradataml.
-
-    EXAMPLES:
-        >>> model_parameters, formula_related_params = __retrieve_model_attributes(name, model_client, function_arg_map)
-    """
-    # Create DF on top of ModelAttributesV view and
-    # 1. get only rows related to the model named 'name'.
-    model_arguments = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_ATTRS.value))
-    model_arguments = model_arguments[model_arguments[mac.MODEL_DERIVED_NAME.value] == name]
-
-    if model_client == mac.MODEL_TDML.value:
-        attr_name_to_use = mac.MODEL_ATTR_CLIENT_NAME.value
-    else:
-        attr_name_to_use = mac.MODEL_ATTR_NAME.value
-
-    if model_client != mac.MODEL_TDML.value:
-        # 2. Filter out the the row where "AttributeName" is not like __nonsql_argument_
-        model_arguments = model_arguments.assign(notSqlonly=model_arguments.AttributeName.str.contains('__nonsql_argument_'))
-        model_arguments = model_arguments[model_arguments.notSqlonly == 0]
-    else:
-        # 2. Filter out the the row where "ClientSpecificAttributeName" is not NULL
-        model_arguments = model_arguments[model_arguments[attr_name_to_use] != None]
-
-    # Make sure the non-lazy view exists before SQLAlchemy construct can be used
-    if model_arguments._table_name is None:
-        model_arguments._table_name = df_utils._execute_node_return_db_object_name(model_arguments._nodeid,
-                                                                                   model_arguments._metaexpr)
-
-    # Since lengthier arguments can be a clob column, casting the smaller to clob
-    # to select one of the two as applicable without values being truncated.
-    select_expression = [model_arguments[attr_name_to_use].expression.label("AttrName"),
-                         case_when([(model_arguments[mac.MODEL_ATTR_VALUE.value].expression == None,
-                                     model_arguments[mac.MODEL_ATTR_VALUEC.value].expression)],
-                                   else_=func.cast(model_arguments[mac.MODEL_ATTR_VALUE.value].expression,
-                                                   type_=CLOB)).expression.label("AttrValue")]
-
-    # Get the final list of AttNames (Client/SQL) and their values  (CLOB type)
-    final_list = DataFrame.from_query(str(select(select_expression).compile(compile_kwargs={"literal_binds": True})))
-
-    # Model Parameters
-    final_list = final_list[final_list["AttrName"] != mac.MODEL_CLIENT_CLASS_KEY.value]
-    params = final_list.to_pandas().to_dict()
-    model_parameters = {}
-    formula_related_params = {}
-
-    index_len = len(params["AttrName"])
-    if model_client == mac.MODEL_TDML.value:
-        for i in range(index_len):
-            # Check if the arguments are related to formula
-            if params["AttrName"][i] == '__all_columns':
-                formula_related_params['__all_columns'] = __cast_arg_values_to_tdml_types(params["AttrValue"][i],
-                                                                                          (str, list))
-            elif params["AttrName"][i] == '__numeric_columns':
-                formula_related_params['__numeric_columns'] = __cast_arg_values_to_tdml_types(params["AttrValue"][i],
-                                                                                              (str, list))
-            elif params["AttrName"][i] == '__categorical_columns':
-                formula_related_params['__categorical_columns'] = __cast_arg_values_to_tdml_types(params["AttrValue"]
-                                                                                                  [i], (str, list))
-            elif params["AttrName"][i] == '__response_column':
-                formula_related_params['__response_column'] = __cast_arg_values_to_tdml_types(params["AttrValue"][i],
-                                                                                              str)
-            else:
-                tdml_type = __get_tdml_type_for_tdml_arg(params["AttrName"][i], function_arg_map)
-                # tdml_type can be None when we do not have information about the argument in
-                # the function argument mapper. Let's ignore it in the retrieval.
-                if tdml_type is not None:
-                    model_parameters[params["AttrName"][i]] = __cast_arg_values_to_tdml_types(params["AttrValue"][i],
-                                                                                              tdml_type)
-    else:
-        formula_args = None
-        for i in range(index_len):
-            model_param_name = __get_arg_tdml_name_from_sql(function_arg_map,
-                                                            arg_type=famc.ARGUMENTS.value,
-                                                            name=params["AttrName"][i].lower())
-
-            attr_value = params["AttrValue"][i]
-
-            special_use, used_in = __check_if_client_specific_use(params["AttrName"][i].lower(),
-                                                                  function_arg_map, is_sql_name=True)
-            if special_use:
-                if used_in == famc.USED_IN_FORMULA.value:
-                    # Get formula
-                    if formula_args is None:
-                        formula_args = __get_all_formula_related_args(function_arg_map)
-                    formula_args[params["AttrName"][i].lower()]['arg_value'] = attr_value
-                else:
-                    # Get dictionary of sequence_column arguments
-                    sequence_by = __get_tdml_parameter_value_for_sequence(function_arg_map, attr_value)
-                    if sequence_by:
-                        for seq_key in sequence_by:
-                            model_parameters[seq_key] = sequence_by[seq_key]
-            else:
-                # tdml_name can be None when we do not have information about the SQL argument in
-                # the function argument mapper. Let's ignore it in the retrieval.
-                if model_param_name is None:
-                    warnings.warn(Messages.get_message(MessageCodes.CANNOT_TRANSLATE_TO_TDML_NAME,
-                                                       params["AttrName"][i]))
-                    continue
-                model_param_type = model_param_name[famc.TDML_TYPE.value]
-                model_param_name = model_param_name[famc.TDML_NAME.value]
-                model_parameters[model_param_name] = __cast_arg_values_to_tdml_types(attr_value,
-                                                                                     model_param_type)
-
-        if formula_args is not None:
-            formula = __get_tdml_parameter_value_for_formula(formula_args, __get_target_column(name))
-            model_parameters[famc.TDML_FORMULA_NAME.value] = formula
-
-    return model_parameters, formula_related_params
-
-
-def __retrieve_model_outputs(name, model_client, function_arg_map):
-    """
-    DESCRIPTION:
-        Internal function to get the output DataFrames corresponding to a saved model given it's name.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name of the model to retrieve the model output information for.
-            Types: str
-
-        model_client:
-            Required Argument.
-            Specifies the name of the client that generated the model.
-            Types: str
-
-        function_arg_map:
-            Required Argument.
-            Specifies the teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-    RAISES:
-        TeradataMlException
-
-    RETURNS:
-        A Pandas DataFrame with the teradataml specific name for the output, and the underlying
-        table names corresponding to them.
-
-    EXAMPLES:
-        >>> output_df = __retrieve_model_outputs(name, model_client, function_arg_map)
-    """
-    # Let's also get the output table map
-    model_outputs = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_OBJECTS.value))
-    model_outputs = model_outputs[model_outputs[mac.MODEL_DERIVED_NAME.value] == name]
-    if model_client == mac.MODEL_TDML.value:
-        model_outputs = model_outputs.assign(drop_columns=True,
-                                             OutputName=model_outputs[mac.MODEL_OBJ_CLIENT_NAME.value],
-                                             OutputTableName=model_outputs[mac.MODEL_OBJ_TABLE_NAME.value]).to_pandas()
-    else:
-        model_outputs = model_outputs.assign(drop_columns=True,
-                                             OutputName=model_outputs[mac.MODEL_OBJ_NAME.value],
-                                             OutputTableName=model_outputs[mac.MODEL_OBJ_TABLE_NAME.value]).to_pandas()
-        output_names = []
-        output_table_names = []
-        index_len = len(model_outputs["OutputName"])
-        for i in range(index_len):
-            output_name = __get_arg_tdml_name_from_sql(function_arg_map, famc.OUTPUTS.value,
-                                                       model_outputs["OutputName"][i].lower())
-            # We raise an exception when we are not able to get the teradataml name
-            # for the SQL name of the output table.
-            if output_name is None:
-                raise TeradataMlException(Messages.get_message(MessageCodes.CANNOT_TRANSLATE_TO_TDML_NAME),
-                                          MessageCodes.CANNOT_TRANSLATE_TO_TDML_NAME)
-            output_names.append(output_name)
-            output_table_names.append(model_outputs["OutputTableName"][i])
-        model_outputs = pd.DataFrame({'OutputName': output_names, 'OutputTableName': output_table_names})
-
-    return model_outputs
-
-
-def __retrieve_model_inputs(name, model_client, function_arg_map):
-    """
-    DESCRIPTION:
-        Internal function to get the input DataFrames corresponding to a saved model given it's name.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name of the model to retrieve the model input information for.
-            Types: str
-
-        model_client:
-            Required Argument.
-            Specifies the name of the client that generated the model.
-            Types: str
-
-        function_arg_map:
-            Required Argument.
-            Specifies the teradataml-sql map for the function obtained using function_argument_mapper.
-            Types: dict
-
-    RETURNS:
-        A dict mapping the teradataml specific name for the input to actual input DataFrame.
-        The dictionary is of the following form:
-            {
-                <tdml_input_name> :
-                    {
-                        'TableName' : <actual_table_name>,
-                        'NRows': <number of rows>,
-                        'NCols': <number of columns>
-                    }
-            }
-
-    EXAMPLES:
-        >>> input_info = __retrieve_model_inputs(name, model_client, function_arg_map)
-    """
-    model_inputs = {}
-
-    # First get the model_id
-    model_id = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS.value))
-    model_id = model_id[model_id[mac.MODEL_NAME.value] == name].select([mac.MODEL_ID.value]).squeeze().item()
-
-    # Now find the inputs related to the model
-    model_training_data = DataFrame(in_schema(mac.MODEL_CATALOG_DB.value, mac.MODELS_INPUTSX.value))
-    model_training_data = model_training_data[model_training_data[mac.MODEL_ID.value] == model_id]
-    model_training_data = model_training_data.to_pandas().to_dict()
-
-    index_len = len(model_training_data[mac.MODEL_ID.value])
-    for i in range(index_len):
-        if model_client == mac.MODEL_TDML.value:
-            input_name = model_training_data[mac.MODEL_INPUT_CLIENT_NAME.value][i]
-            table_name = model_training_data[mac.MODEL_INPUT_TABLE_NAME.value][i]
-        else:
-            input_name = __get_arg_tdml_name_from_sql(function_arg_map, famc.INPUTS.value,
-                                                      model_training_data[mac.MODEL_INPUT_NAME.value][i].lower())
-            # if input_name is None then we have been unable to get the tdml name from the SQL name
-            # for the input. In this case, we ignore the input initialization and continue.
-            if input_name is None:
-                warnings.warn(Messages.get_message(MessageCodes.CANNOT_TRANSLATE_TO_TDML_NAME,
-                                                   model_training_data[mac.MODEL_INPUT_NAME.value][i]))
-                continue
-            table_name = model_training_data[mac.MODEL_INPUT_TABLE_NAME.value][i]
-
-        # No need for further processing if the TableName associated with an input is None.
-        if table_name is None:
-            continue
-
-        nrows = model_training_data[mac.MODEL_INPUT_NROWS.value][i]
-        ncols = model_training_data[mac.MODEL_INPUT_NCOLS.value][i]
-
-        model_inputs[input_name] = {}
-        model_inputs[input_name][mac.MODEL_OBJ_TABLE_NAME.value] = table_name
-        model_inputs[input_name][mac.MODEL_INPUT_NROWS.value] = nrows
-        model_inputs[input_name][mac.MODEL_INPUT_NCOLS.value] = ncols
-
-    return model_inputs
-
-
-def __retrieve_argument_and_output_map(name):
-    """
-    DESCRIPTION:
-        Internal function to get the teradataml function class corresponding to the model to retrieve,
-        along with the attributes and output objects to initialize the model with.
-
-    PARAMETERS:
-        name:
-            Required Argument.
-            Specifies the name of the model to retrieve the model attributes and output information for.
-            Types: str
-
-    RETURNS:
-        A tuple with the following elements:
-        * the function class to initialize for the model,
-        * the model generating engine to help with the initialization, and
-        * the dictionary containing the attributes and their values including output table objects.
-
-    EXAMPLES:
-        >>> model_class, model_engine, attribute_dictionary = __retrieve_argument_and_output_map(name)
-    """
-    # First, let's get the model engine, client, algorithm, and other details.
-    model_client, model_engine, model_algorithm, model_details = __retrieve_model_client_engine_algorithm(name, True)
-
-    # Get the build_time, algorithm_name/model_class, target_column, prediction_type to be returned later as parameters.
-    # model_algorithm is also use to figure out the Python class to be instantiated.
-    build_time = model_details.select([mac.MODEL_DERIVED_BUILD_TIME.value]).squeeze()
-    prediction_type = model_details.select([mac.MODEL_DERIVED_PREDICTION_TYPE.value]).squeeze()
-    target_column = model_details.select([mac.MODEL_DERIVED_TARGET_COLUMN.value]).squeeze()
-
-    # Get the teradataml model class corresponding to the model
-    function_arg_map = _argument_mapper._get_function_map(engine=model_engine,
-                                                          function_name=model_algorithm.lower())
-    model_class = __retrieve_model_class(name, model_client, function_arg_map)
-
-    # Get the model attributes and formula related arguments
-    model_parameters, formula_related_args = __retrieve_model_attributes(name, model_client, function_arg_map)
-    # Also append the algorithm_name, build_time, target_column, and prediction_type for the function
-    model_parameters['__algorithm_name'] = model_algorithm
-    if build_time is not None:
-        model_parameters['__build_time'] = build_time.item()
-    if target_column is not None:
-        model_parameters['__target_column'] = target_column
-    if prediction_type is not None:
-        model_parameters['__prediction_type'] = prediction_type
-
-    # Merge the formula related arguments
-    model_parameters = {**model_parameters, **formula_related_args}
-
-    # Try plugging in the input DataFrames as well
-    model_inputs = __retrieve_model_inputs(name, model_client, function_arg_map)
-    for input_name in model_inputs:
-        table_name = model_inputs[input_name][mac.MODEL_OBJ_TABLE_NAME.value]
-        sname = UtilFuncs._extract_db_name(table_name)
-        tname = UtilFuncs._extract_table_name(table_name)
-
-        # Add quoted around the DB and Table names if necessary.
-        tdp = preparer(td_dialect)
-        if sname is not None:
-            sname = tdp.quote(UtilFuncs._teradata_unquote_arg(sname, quote='"'))
-        if tname is not None:
-            tname = tdp.quote(UtilFuncs._teradata_unquote_arg(tname, quote='"'))
-
-        # Try creating the input DataFrames
-        try:
-            if sname is None:
-                input = DataFrame(tname)
-            else:
-                input = DataFrame(in_schema(sname, tname))
-
-            model_inputs[input_name] = input
-        except Exception as err:
-            # We are most likely not able to create a DataFrame on the input as the input may no longer be existent.
-            # In this case, we just initialize it to None.
-            warnings.warn("Unable to fetch input details for the '{}' argument "
-                          "from underlying object named '{}'".format(input_name, table_name))
-            model_inputs[input_name] = None
-
-    # Let's also get the output table map
-    model_outputs = __retrieve_model_outputs(name, model_client, function_arg_map)
-    tables = model_outputs.to_dict()
-    model_tables = {}
-    index_len = len(tables["OutputName"])
-    for i in range(index_len):
-        output_name = tables["OutputName"][i]
-        model_tables[output_name] = tables["OutputTableName"][i]
-
-    return model_class, model_engine, {**model_inputs, **model_parameters, **model_tables}
-
-
 from teradataml.dataframe.dataframe import DataFrame, in_schema