def METHOD_NAME(arg, enforce_type=None, enforce_subtype=None, cast_subtype: bool = True):
    r"""
    Verify if the type is an iterator. If it is `None`, convert to an empty list/tuple. If it is
    not a list/tuple/str, try to convert to an iterator. If it is a str or cannot be converted to
    an iterator, then put the `arg` inside an iterator.
    Possibly enforce the iterator type to `list` or `tuple`, if `enfoce_type` is not None.
    Possibly enforce the subtype to any given type if `enforce_subtype` is not None,
    and decide whether to cast the subtype or to throw an error.
    Parameters:
        arg (any type):
            The input to verify/convert to an iterator (list or tuple). If None, an empty iterator
            is returned.
        enforce_type (str or type):
            The type to enforce the iterator. The valid choices are :
            `None`, `list`, `tuple`, `'none'`, `'list'`, `'tuple'`.
            If `None`, then the iterator type is not enforced.
        enforce_subtype (type, np.dtype or str representing basic type):
            Verify if all the elements inside the iterator are the desired type.
            If `None`, then the sub-type is not enforced.
            Accepted strings are ['none', 'str', 'list', 'tuple', 'dict', 'int',
            'float', 'complex', 'bool', 'callable']
        cast_subtype:
            If True, then the type specified by `enforce_subtype` is used to cast the
            elements inside the iterator. If False, then an error is thrown if the
            types do not match.
    Returns:
        output (iterator):
            An iterator based on the input of the desired type (list or tuple) and
            the desired subtypes.
    """
    # If not list or tuple, put into a list
    if arg is None:
        arg = []
    elif isinstance(arg, str):
        arg = [arg]
    elif isinstance(arg, tuple):
        if enforce_type is None:
            enforce_type = tuple
        arg = list(arg)
    elif not isinstance(arg, (tuple, list)):
        try:
            arg = list(arg)
        except Exception:
            arg = [arg]
    output = arg
    # Make sure that enforce_type and enforce_subtype are a good inputs
    enforce_type = _parse_type(enforce_type, (type, str))
    enforce_subtype = _parse_type(enforce_subtype, (type, str, np.dtype))
    # Cast all the subtypes of the list/tuple into the desired subtype
    if enforce_subtype is not None:
        if enforce_type is None:
            arg2 = output
        elif not isinstance(output, enforce_type):
            arg2 = list(output)
        else:
            arg2 = output
        try:
            for idx, a in enumerate(output):
                if not isinstance(a, enforce_subtype):
                    if cast_subtype:
                        arg2[idx] = enforce_subtype(a)
                    else:
                        raise TypeError(
                            "iter subtype is {}, desired subtype is {}, "
                            "but cast_subtype is set to False".format(type(arg2[idx]), enforce_subtype)
                        )
        except Exception as e:
            raise TypeError(
                "iterator subtype is {} and cannot be casted to {}\n{}".format(type(a), enforce_subtype, e)
            )
        output = _enforce_iter_type(arg2, enforce_type)
    output = _enforce_iter_type(output, enforce_type)
    return output