def __validate_not_empty(parameter, suffix=None):
"""
Validates the parameter is not empty.
:param parameter: The parameter contains spaces
:return:
"""
length = len(parameter)
if length == 0:
raise InvalidValueError(NOT_EMPTY_MESSAGE_CANNED.format(suffix))
return True
def __validate_has_space(parameter, suffix=None):
"""
Validates the parameter contains spaces.
:param parameter: The parameter contains spaces
:return validity: Boolean value or error if failed
"""
parameter = str(parameter)
for alphabet in parameter:
if alphabet.isspace():
return True
raise InvalidValueError(HAS_SPACE_MESSAGE_CANNED.format(suffix))
def __validate_no_symbols(parameter, suffix=None):
"""
Validates the parameter does not contain any symbols.
:param parameter: The parameter contains spaces
:return:
"""
parameter = str(parameter)
parameter.strip()
for alphabet in parameter:
if not alphabet.isalnum():
raise InvalidValueError(NO_SYMBOL_MESSAGE_CANNED.format(suffix))
return True
def __validate_has_empty(parameter, suffix=None):
"""
Validates the parameter is empty by using the intrinsic truth value nature of python types.
:param parameter: The parameter to ensure emptiness of, this can be an
empty list, tuple, string or dictionary.
:type <type, 'Sequence'>
:return has_empty: Boolean indicating the emptiness value of the parameter
"""
if not bool(parameter): #: Using the truth valueness of python :-)
return True
raise InvalidValueError(HAS_EMPTY_MESSAGE_CANNED.format(suffix))
def __validate_no_numbers(parameter, suffix=None):
"""
Validates the parameter does not contain any numbers.
:param parameter: The parameter to validate for absence of numbers
:type <type, 'Sequence'>
:return:
"""
parameter = str(parameter)
parameter.strip()
for alphabet in parameter:
if alphabet.isdigit():
raise InvalidValueError(NO_NUMBER_MESSAGE_CANNED.format(suffix))
return True
def __validate_has_number(parameter, suffix=None):
"""
Validates the parameter has at least one number.
:param parameter: The parameter to validate for presence of a number
:type <type, 'Sequence'>
:return has_number: Boolean indicating presence or absence of a number
"""
parameter = str(parameter)
parameter.strip()
for alphabet in parameter:
if alphabet.isdigit():
return True
raise InvalidValueError(HAS_NUMBER_MESSAGE_CANNED.format(suffix))
def __validate_has_caps(parameter, suffix):
"""
Validates the parameter has at least a single capitalized character.
:param parameter: The parameter that should contains a capitalized
member.
:type <type, 'str'>
:return has_caps: Boolean indicating the presence or absence of caps
"""
parameter = str(parameter)
for alphabet in parameter:
if alphabet.isupper():
return True
raise InvalidValueError(HAS_CAPS_MESSAGE_CANNED.format(suffix))
def __validate_has_symbol(parameter, suffix=None, symbol=None, symbols=None):
"""
Validates the parameter contains any symbols.
:param parameter: The parameter that should contain spaces
:type <type, 'str'>
:param symbol: A symbol to use as validation check i.e. parameter has
the symbol.
:type <type, 'str'>
:return validity: Boolean value or error if failed
"""
for alphabet in parameter:
if not (alphabet.isalnum() or alphabet.isspace()):
return True
raise InvalidValueError(HAS_SYMBOL_MESSAGE_CANNED.format(suffix))
def __validate_has_length(parameter, suffix=None, min_length=6):
"""
Validates the parameter is longer than the specified length
:param parameter: The parameter to verify for length
:type <type, 'str'>
:type <type, 'list'>
:param min_length: The minimum length wanted
:type <type, 'int'>
:return has_length: Boolean indicating if the parameter met the minimum length
requirements as specificed by the :param min_length.
:type <type, 'Sequence'>
"""
if len(parameter) < min_length:
raise InvalidValueError(HAS_LENGTH_MESSAGE_CANNED.format(suffix))
return True