def _convert_values_to_log_form(value):
"""Function for making state loggable quantity conform to spec.
Since the state dictionary is composed of properties for a given class
instance that does not have flags associated with it, we need to add the
flags when querying for the state. This does makes state logger type flag
generation dynamic meaning that we must be careful that we won't wrongly
detect different flags for the same attribute. In general this shouldn't
be a concern, though.
"""
if value is RequiredArg:
return RequiredArg
elif isinstance(value, Variant):
if isinstance(value, Constant):
return (value.value, 'scalar')
else:
return (value, 'object')
elif isinstance(value, Trigger) or isinstance(value, ParticleFilter):
return (value, 'object')
elif isinstance(value, Operation):
return (value, 'object')
elif isinstance(value, str):
return (value, 'string')
elif (is_iterable(value) and len(value) != 0
and all([isinstance(v, str) for v in value])):
return (value, 'strings')
elif not is_iterable(value):
return (value, 'scalar')
else:
return (value, 'sequence')
def _validate_and_split_len(self, key):
'''Validate all key lengths greater than one, N.
Valid input is an arbitrarily deep series of iterables that culminate
in N length tuples, this includes an iterable depth of zero. The N
length tuples can contain for each member either a type string or an
iterable of type strings.
'''
if isinstance(key, tuple) and len(key) == self._len_keys:
fst, snd = key
if any([
not is_good_iterable(v) and not isinstance(v, str)
for v in key
]):
raise KeyError("The key {} is not valid.".format(key))
key = list(key)
for ind in range(len(key)):
if isinstance(key[ind], str):
key[ind] = [key[ind]]
return list(product(*key))
elif is_iterable(key):
keys = []
for k in key:
keys.extend(self._validate_and_split_len(k))
return keys
else:
raise KeyError("The key {} is not valid.".format(key))
def __init__(self, sequence, default):
if is_iterable(default):
dft_iter = cycle(default)
else:
dft_iter = repeat(default)
self.default = tuple(
[toDefault(item, dft) for item, dft in zip(sequence, dft_iter)])
def toDefault(value, defaults=NoDefault):
if isinstance(value, tuple):
if defaults is NoDefault or is_iterable(defaults):
return SmartDefaultFixedLengthSequence(value, defaults)
else:
return defaults
if is_iterable(value):
if defaults is NoDefault or is_iterable(defaults):
return SmartDefaultSequence(value, defaults)
else:
return defaults
elif isinstance(value, Mapping):
if defaults is NoDefault or isinstance(defaults, Mapping):
return SmartDefaultMapping(value, defaults)
else:
return defaults
elif isclass(value) or callable(value):
return RequiredArg if defaults is NoDefault else defaults
else:
return value if defaults is NoDefault else defaults
def _convert_values_to_log_form(value):
if value is RequiredArg:
return RequiredArg
elif isinstance(value, Variant):
if isinstance(value, Constant):
return (value.value, 'scalar')
else:
return (value, 'object')
elif isinstance(value, Trigger) or isinstance(value, ParticleFilter):
return (value, 'object')
elif isinstance(value, Operation):
return (value, 'object')
elif isinstance(value, str):
return (value, 'string')
elif is_iterable(value) and all([isinstance(v, str) for v in value]):
return (value, 'strings')
elif not is_iterable(value):
return (value, 'scalar')
else:
return (value, 'multi')
def __call__(self, sequence):
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_and_split_len_one(self, key):
'''Validate single type keys.
Accepted input is a type string, and arbitrarily nested interators that
culminate in str types.
'''
if isinstance(key, str):
return [key]
elif is_iterable(key):
keys = []
for k in key:
keys.extend(self._validate_and_split_len_one(k))
return keys
else:
raise KeyError("The key {} is not valid.".format(key))
def __call__(self, sequence):
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 to_type_converter(value):
"""The function to use for creating a structure of `TypeConverter` objects.
This is the function to use when defining validation not any of the
`TypeConverter` subclasses.
.. code-block:: python
# list take a list of tuples of 3 floats each
validation = to_type_converter(
{'str': str, 'list': [(float, float, float)]})
"""
if isinstance(value, tuple):
return TypeConverterFixedLengthSequence(value)
if is_iterable(value):
return TypeConverterSequence(value)
elif isinstance(value, Mapping):
return TypeConverterMapping(value)
else:
return TypeConverterValue(value)
def is_good_iterable(obj):
'''Returns True if object is iterable with respect to types.'''
return is_iterable(obj) and has_str_elems(obj)