def positive_real(number):
"""Ensure that a value is positive."""
try:
float_number = float(number)
except Exception as err:
raise TypeConversionError(
f"{number} not convertible to float.") from err
if float_number <= 0:
raise TypeConversionError("Expected a number greater than zero.")
return float_number
def nonnegative_real(number):
"""Ensure that a value is not negative."""
try:
float_number = float(number)
except Exception as err:
raise TypeConversionError(
f"{number} not convertible to float.") from err
if float_number < 0:
raise TypeConversionError("Expected a nonnegative real number.")
return float_number
def __call__(self, value):
"""Called when the value is set."""
try:
return self.converter(value)
except (TypeError, ValueError, TypeConversionError) as err:
if value is RequiredArg:
raise TypeConversionError("Value is a required argument")
raise TypeConversionError(
"Value {} of type {} cannot be converted using {}. Raised "
"error: {}".format(value, type(value), str(self.converter),
str(err)))
def __call__(self, sequence):
"""Called when the value is set."""
if not _is_iterable(sequence):
raise TypeConversionError(
"Expected a sequence like instance. Received {} of type {}."
"".format(sequence, type(sequence)))
else:
new_sequence = []
try:
for i, (v, c) in enumerate(zip(sequence, self)):
new_sequence.append(c(v))
except (TypeConversionError) as err:
raise TypeConversionError("In list item number {}: {}"
"".format(i, str(err)))
return new_sequence
def _validate(self, sequence):
"""Called when the value is set."""
if not _is_iterable(sequence):
raise TypeConversionError(
f"Expected a sequence like instance. Received {sequence} of "
f"type {type(sequence)}.")
else:
new_sequence = []
try:
for i, v in enumerate(sequence):
new_sequence.append(self.converter(v))
except (ValueError, TypeError) as err:
raise TypeConversionError(
f"In list item number {i}: {str(err)}") from err
return new_sequence
def __call__(self, mapping):
"""Called when the value is set."""
if not isinstance(mapping, Mapping):
raise TypeConversionError(
"Expected a dict like value. Recieved {} of type {}."
"".format(mapping, type(mapping)))
new_mapping = dict()
try:
for key, value in mapping.items():
if key in self:
new_mapping[key] = self.converter[key](value)
else:
new_mapping[key] = value
except (TypeConversionError) as err:
raise TypeConversionError("In key {}: {}"
"".format(str(key), str(err)))
return new_mapping
def _validate(self, mapping):
"""Called when the value is set."""
if not isinstance(mapping, Mapping):
raise TypeConversionError(
f"Expected a dict like value. Recieved {mapping} of type "
f"{type(mapping)}.")
new_mapping = {}
for key, value in mapping.items():
if key in self:
try:
new_mapping[key] = self.converter[key](value)
except (ValueError, TypeError) as err:
raise TypeConversionError(
f"In key {key}: {str(err)}") from err
else:
new_mapping[key] = value
return new_mapping
def __call__(self, sequence):
"""Called when the value is set."""
if not _is_iterable(sequence):
raise TypeConversionError(
"Expected a tuple like object. Received {} of type {}."
"".format(sequence, type(sequence)))
elif len(sequence) != len(self.converter):
raise TypeConversionError(
"Expected exactly {} items. Received {}.".format(
len(self.converter), len(sequence)))
else:
new_sequence = []
try:
for i, (v, c) in enumerate(zip(sequence, self)):
new_sequence.append(c(v))
except (TypeConversionError) as err:
raise TypeConversionError("In tuple item number {}: {}"
"".format(i, str(err)))
return tuple(new_sequence)
def __setitem__(self, key, val):
"""Set parameter by key."""
keys = self._yield_keys(key)
try:
val = self._validate_values(val)
except TypeConversionError as err:
raise TypeConversionError("For types {}, error {}.".format(
list(keys), str(err)))
for key in keys:
self._dict[key] = val
def __setitem__(self, keys, item):
"""Set parameter by key."""
keys = self._indexer(keys)
try:
validated_value = self._validate_values(item)
except ValueError as err:
raise TypeConversionError(
f"For types {list(keys)}: {str(err)}.") from err
for key in keys:
self._single_setitem(key, validated_value)
def _validate(self, sequence):
"""Called when the value is set."""
if not _is_iterable(sequence):
raise TypeConversionError(
f"Expected a tuple like object. Received {sequence} of type "
f"{type(sequence)}.")
elif len(sequence) != len(self.converter):
raise TypeConversionError(
f"Expected exactly {len(self.converter)} items. Received "
f"{len(sequence)}.")
else:
new_sequence = []
try:
for i, (v, c) in enumerate(zip(sequence, self)):
new_sequence.append(c(v))
except (ValueError, TypeError) as err:
raise TypeConversionError(
f"In tuple item number {i}: {str(err)}") from err
return tuple(new_sequence)
def __call__(self, value):
if value is RequiredArg:
return value
if value is None:
if not self._allow_none:
raise ValueError("None is not allowed.")
else:
return None
try:
return self._postprocess(self._validate(self._preprocess(value)))
except Exception as err:
if isinstance(err, TypeConversionError):
raise err
raise TypeConversionError(
f"Error raised in conversion: {str(err)}") from err
def _validate(self, value):
if isinstance(value, self.disallow_types):
raise TypeConversionError(
f"Value {value} cannot be of type {type(value)}")
if isinstance(value, self.types):
return value
elif self.strict:
raise ValueError(
f"Value {value} is not an instance of any of {self.types}.")
else:
for type_ in self.types:
try:
return type_(value)
except Exception:
pass
raise ValueError(
f"Value {value} is not convertable into any of these types "
f"{self.types}")
