def filter_input(self, data: Any, error: bool) -> Any:
# If we were passed a BoundDictField, operate on its raw values
if isinstance(data, BoundDictField):
data = data.d_data
if not isinstance(data, dict):
if error:
raise TypeError('dict value expected')
logging.error('Ignoring non-dict data for %s: %s', self, data)
data = {}
data_out = {}
for key, val in data.items():
# For enum keys, make sure its a valid enum.
if issubclass(self._keytype, Enum):
# Our input data can either be an enum or the underlying type.
if isinstance(key, self._keytype):
key = dict_key_to_raw(key, self._keytype)
# key = key.value
else:
try:
_enumval = dict_key_from_raw(key, self._keytype)
# _enumval = enum_by_value(self._keytype, key)
except Exception as exc:
if error:
raise ValueError(
f'No enum of type {self._keytype}'
f' exists with value {key}') from exc
logging.error('Ignoring invalid key type for %s: %s',
self, data)
continue
# For all other keys we can check for exact types.
elif not isinstance(key, self._keytype):
if error:
raise TypeError(
f'Invalid key type; expected {self._keytype},'
f' got {type(key)}.')
logging.error('Ignoring invalid key type for %s: %s', self,
data)
continue
data_out[key] = self.d_value.filter_input(val, error=error)
return data_out
def keys(self) -> List[TKey]:
"""Return a list of our keys."""
return [
dict_key_from_raw(k, self.d_field.d_keytype)
for k in self.d_data.keys()
]
def items(self):
"""Return key/value pairs for all dict entries."""
return [(dict_key_from_raw(key, self.d_field.d_keytype),
BoundCompoundValue(self.d_field.d_value, value))
for key, value in self.d_data.items()]
def items(self) -> List[Tuple[TKey, T]]:
"""Return a list of item/value pairs."""
return [(dict_key_from_raw(key, self._keytype),
self.d_field.d_value.filter_output(value))
for key, value in self.d_data.items()]
def __repr__(self) -> str:
return '{' + ', '.join(
repr(dict_key_from_raw(key, self._keytype)) + ': ' +
repr(self.d_field.d_value.filter_output(val))
for key, val in self.d_data.items()) + '}'