`ValidatedDict`

class openff.toolkit.utils.collections.ValidatedDict(mapping, converter=None, validator=None)[source]

A dict that runs custom converter and validators when new elements are added.

Multiple converters and validators can be assigned to the dict. These are executed in the given order with converters run before validators.

Validators must take the new element as the first argument and raise an exception if validation fails.

validator(new_element) -> None

Converters must also take the new element as the first argument, but they have to return the converted value.

converter(new_element) -> converted_value

Examples

We can define validator and converter functions that are run on each value of the dict.

>>> def is_positive_validator(value):
...     if value <= 0:
...         raise TypeError('value must be positive')
...
>>> vl = ValidatedDict({'a': 1, 'b': -1}, validator=is_positive_validator)
Traceback (most recent call last):
...
TypeError: value must be positive

Multiple converters that are run before the validators can be specified.

>>> vl = ValidatedDict({'c': -1, 'd': '2', 'e': 3.0}, converter=[float, abs],
...                    validator=is_positive_validator)
>>> vl
{'c': 1.0, 'd': 2.0, 'e': 3.0}

__init__(mapping, converter=None, validator=None)[source]

Initialize the dict.

Parameters:

mapping – A mapping of elements, probably a dict.
converter – Functions that will be used to convert each new element of the dict.
validator – Functions that will be used to convert each new element of the dict.

Methods

`__init__`(mapping[, converter, validator])	Initialize the dict.
`clear`()
`copy`()
`fromkeys`([value])	Create a new dictionary with keys from iterable and values set to value.
`get`(key[, default])	Return the value for key if key is in the dictionary, else default.
`items`()
`keys`()
`pop`(k[,d])	If the key is not found, return the default if given; otherwise, raise a KeyError.
`popitem`()	Remove and return a (key, value) pair as a 2-tuple.
`setdefault`(key[, default])	Insert key with a value of default if key is not in the dictionary.
`update`([E, ]**F)	If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]
`values`()

update([E, ]**F) → None. Update D from dict/iterable E and F.[source]: If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

copy() → a shallow copy of D[source]

clear() → None. Remove all items from D.

fromkeys(value=None, /): Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /): Return the value for key if key is in the dictionary, else default.

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

pop(k[, d]) → v, remove specified key and return the corresponding value.: If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

values() → an object providing a view on D's values