def valid_float(var_value, lower=None, upper=None, var_name=None): r""" The variable value is valid if it is a floating point value or can be interpreted as a floating point value (e.g. 7.5, "7.5", etc.). This function also calls valid_range to make sure the float value is within the specified range (if any). Description of argument(s): var_value The value being validated. lower The lower end of the range. If not None, the var_value must be greater than or equal to lower. upper The upper end of the range. If not None, the var_value must be less than or equal to upper. """ error_message = "" var_name = get_var_name(var_name) try: var_value = float(str(var_value)) except ValueError: error_message += "Invalid float value:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) return process_error_message(error_message) # Check the range (if any). if lower: lower = float(str(lower)) if upper: upper = float(str(upper)) error_message = valid_range(var_value, lower, upper, var_name=var_name) return process_error_message(error_message)
def valid_type(var_value, required_type, var_name=None): r""" The variable value is valid if it is of the required type. Examples: valid_type(var1, int) valid_type(var1, (list, dict)) Description of argument(s): var_value The value being validated. required_type A type or a tuple of types (e.g. str, int, etc.). """ error_message = "" if type(required_type) is tuple: if type(var_value) in required_type: return process_error_message(error_message) else: if type(var_value) is required_type: return process_error_message(error_message) # If we get to this point, the validation has failed. var_name = get_var_name(var_name) error_message += "Invalid variable type:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += gp.sprint_var(required_type) return process_error_message(error_message)
def valid_range(var_value, lower=None, upper=None, *args, **kwargs): r""" The variable value is valid if it is within the specified range. This function can be used with any type of operands where they can have a greater than/less than relationship to each other (e.g. int, float, str). Description of argument(s): var_value The value being validated. lower The lower end of the range. If not None, the var_value must be greater than or equal to lower. upper The upper end of the range. If not None, the var_value must be less than or equal to upper. """ error_message = "" if lower is None and upper is None: return process_error_message(error_message) if lower is None and var_value <= upper: return process_error_message(error_message) if upper is None and var_value >= lower: return process_error_message(error_message) if lower and upper: if lower > upper: var_name = get_var_name(*args, **kwargs) error_message += "Programmer error - the lower value is greater" error_message += " than the upper value:\n" error_message += gp.sprint_vars(lower, upper, fmt=gp.show_type()) return process_error_message(error_message) if lower <= var_value <= upper: return process_error_message(error_message) var_name = get_var_name(*args, **kwargs) error_message += "The following variable is not within the expected" error_message += " range:\n" error_message += gp.sprint_varx(var_name, var_value, gp.show_type()) error_message += "\n" error_message += "range:\n" error_message += gp.sprint_vars(lower, upper, fmt=gp.show_type(), indent=2) return process_error_message(error_message)
def valid_dict(var_value, required_keys=[], var_name=None): r""" The variable value is valid if it is a dictionary containing all of the required keys. Description of argument(s): var_value The value being validated. required_keys A list of keys which must be found in the dictionary for it to be considered valid. """ error_message = "" missing_keys = list(set(required_keys) - set(var_value.keys())) if len(missing_keys) > 0: var_name = get_var_name(var_name) error_message += "The following dictionary is invalid because it is" error_message += " missing required keys:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += gp.sprint_var(missing_keys, gp.show_type()) return process_error_message(error_message)
def valid_date_time(var_value, var_name=None): r""" The variable value is valid if it can be interpreted as a date/time (e.g. "14:49:49.981", "tomorrow", etc.) by the linux date command. Description of argument(s): var_value The value being validated. """ error_message = "" rc, out_buf = gc.shell_cmd("date -d '" + str(var_value) + "'", quiet=1, show_err=0, ignore_err=1) if rc: var_name = get_var_name(var_name) error_message += "Invalid date/time value:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) return process_error_message(error_message) return process_error_message(error_message)
def valid_dict(var_value, required_keys=[], valid_values={}, invalid_values={}, var_name=None): r""" The dictionary variable value is valid if it contains all required keys and each entry passes the valid_value() call. Examples: person_record = {'last_name': 'Jones', 'first_name': 'John'} valid_values = {'last_name': ['Doe', 'Jones', 'Johnson'], 'first_name': ['John', 'Mary']} invalid_values = {'last_name': ['Manson', 'Hitler', 'Presley'], 'first_name': ['Mickey', 'Goofy']} valid_dict(person_record, valid_values=valid_values) valid_dict(person_record, invalid_values=invalid_values) Description of argument(s): var_value The value being validated. required_keys A list of keys which must be found in the dictionary for it to be considered valid. valid_values A dictionary whose entries correspond to the entries in var_value. Each value in valid_values is itself a valid_values list for the corresponding value in var_value. For any var_value[key] to be considered valid, its value must be found in valid_values[key]. invalid_values A dictionary whose entries correspond to the entries in var_value. Each value in invalid_values is itself an invalid_values list for the corresponding value in var_value. For any var_value[key] to be considered valid, its value must NOT be found in invalid_values[key]. """ error_message = "" missing_keys = list(set(required_keys) - set(var_value.keys())) if len(missing_keys) > 0: var_name = get_var_name(var_name) error_message += "The following dictionary is invalid because it is" error_message += " missing required keys:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += gp.sprint_var(missing_keys, gp.show_type()) return process_error_message(error_message) var_name = get_var_name(var_name) if len(valid_values): keys = valid_values.keys() error_message = valid_dict(var_value, required_keys=keys, var_name=var_name) if error_message: return process_error_message(error_message) for key, value in valid_values.items(): key_name = " [" + key + "]" sub_error_message = valid_value(var_value[key], valid_values=value, var_name=key_name) if sub_error_message: error_message += "The following dictionary is invalid because one of its entries is invalid:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += sub_error_message return process_error_message(error_message) for key, value in invalid_values.items(): if key not in var_value: continue key_name = " [" + key + "]" sub_error_message = valid_value(var_value[key], invalid_values=value, var_name=key_name) if sub_error_message: error_message += "The following dictionary is invalid because one of its entries is invalid:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += sub_error_message return process_error_message(error_message) return process_error_message(error_message)
def valid_list(var_value, valid_values=[], invalid_values=[], required_values=[], fail_on_empty=False, var_name=None): r""" The variable value is valid if it is a list where each entry can be found in the valid_values list or if none of its values can be found in the invalid_values list or if all of the values in the required_values list can be found in var_value. The caller may only specify one of these 3 arguments: valid_values, invalid_values, required_values. Description of argument(s): var_value The value being validated. valid_values A list of valid values. Each element in the var_value list must be equal to one of these values to be considered valid. invalid_values A list of invalid values. If any element in var_value is equal to any of the values in this argument, var_value is considered invalid. required_values Every value in required_values must be found in var_value. Otherwise, var_value is considered invalid. fail_on_empty Indicates that an empty list for the variable value should be considered an error. """ error_message = "" # Validate this function's arguments. if not (bool(len(valid_values)) ^ bool(len(invalid_values)) ^ bool(len(required_values))): error_message += "Programmer error - You must provide only one of the" error_message += " following: valid_values, invalid_values," error_message += " required_values.\n" error_message += gp.sprint_var(invalid_values, gp.show_type()) error_message += gp.sprint_var(valid_values, gp.show_type()) error_message += gp.sprint_var(required_values, gp.show_type()) return process_error_message(error_message) if type(var_value) is not list: var_name = get_var_name(var_name) error_message = valid_type(var_value, list, var_name=var_name) if error_message: return process_error_message(error_message) if fail_on_empty and len(var_value) == 0: var_name = get_var_name(var_name) error_message += "Invalid empty list:\n" error_message += gp.sprint_varx(var_name, var_value, gp.show_type()) return process_error_message(error_message) if len(required_values): found_error = 0 display_required_values = list(required_values) for ix in range(0, len(required_values)): if required_values[ix] not in var_value: found_error = 1 display_required_values[ix] = \ str(display_required_values[ix]) + "*" if found_error: var_name = get_var_name(var_name) error_message += "The following list is invalid:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += "Because some of the values in the " error_message += "required_values list are not present (see" error_message += " entries marked with \"*\"):\n" error_message += "\n" error_message += gp.sprint_varx('required_values', display_required_values, gp.blank() | gp.show_type()) error_message += "\n" return process_error_message(error_message) if len(invalid_values): found_error = 0 display_var_value = list(var_value) for ix in range(0, len(var_value)): if var_value[ix] in invalid_values: found_error = 1 display_var_value[ix] = str(var_value[ix]) + "*" if found_error: var_name = get_var_name(var_name) error_message += "The following list is invalid (see entries" error_message += " marked with \"*\"):\n" error_message += gp.sprint_varx(var_name, display_var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += gp.sprint_var(invalid_values, gp.show_type()) return process_error_message(error_message) found_error = 0 display_var_value = list(var_value) for ix in range(0, len(var_value)): if var_value[ix] not in valid_values: found_error = 1 display_var_value[ix] = str(var_value[ix]) + "*" if found_error: var_name = get_var_name(var_name) error_message += "The following list is invalid (see entries marked" error_message += " with \"*\"):\n" error_message += gp.sprint_varx(var_name, display_var_value, gp.blank() | gp.show_type()) error_message += "\n" error_message += gp.sprint_var(valid_values, gp.show_type()) return process_error_message(error_message) return process_error_message(error_message)
def valid_value(var_value, valid_values=[], invalid_values=[], var_name=None): r""" The variable value is valid if it is either contained in the valid_values list or if it is NOT contained in the invalid_values list. If the caller specifies nothing for either of these 2 arguments, invalid_values will be initialized to ['', None]. This is a good way to fail on variables which contain blank values. It is illegal to specify both valid_values and invalid values. Example: var1 = '' valid_value(var1) This code would fail because var1 is blank and the default value for invalid_values is ['', None]. Example: var1 = 'yes' valid_value(var1, valid_values=['yes', 'true']) This code would pass. Description of argument(s): var_value The value being validated. valid_values A list of valid values. The variable value must be equal to one of these values to be considered valid. invalid_values A list of invalid values. If the variable value is equal to any of these, it is considered invalid. """ error_message = "" # Validate this function's arguments. len_valid_values = len(valid_values) len_invalid_values = len(invalid_values) if len_valid_values > 0 and len_invalid_values > 0: error_message += "Programmer error - You must provide either an" error_message += " invalid_values list or a valid_values" error_message += " list but NOT both:\n" error_message += gp.sprint_var(invalid_values) error_message += gp.sprint_var(valid_values) return process_error_message(error_message) error_message = valid_type(valid_values, list, var_name='valid_values') if error_message: return process_error_message(error_message) error_message = valid_type(invalid_values, list, var_name='invalid_values') if error_message: return process_error_message(error_message) if len_valid_values > 0: # Processing the valid_values list. if var_value in valid_values: return process_error_message(error_message) var_name = get_var_name(var_name) error_message += "Invalid variable value:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.verbose() | gp.show_type()) error_message += "\n" error_message += "It must be one of the following values:\n" error_message += "\n" error_message += gp.sprint_var(valid_values, gp.blank() | gp.show_type()) return process_error_message(error_message) if len_invalid_values == 0: # Assign default value. invalid_values = ["", None] # Assertion: We have an invalid_values list. Processing it now. if var_value not in invalid_values: return process_error_message(error_message) var_name = get_var_name(var_name) error_message += "Invalid variable value:\n" error_message += gp.sprint_varx(var_name, var_value, gp.blank() | gp.verbose() | gp.show_type()) error_message += "\n" error_message += "It must NOT be any of the following values:\n" error_message += "\n" error_message += gp.sprint_var(invalid_values, gp.blank() | gp.show_type()) return process_error_message(error_message)