def __repr_args__(
self,
to_dict: bool = False,
by_alias: bool = False,
include=None,
exclude=None,
exclude_unset: bool = True,
exclude_defaults: bool = False,
exclude_none: bool = True,
):
from pydantic.main import _missing
allowed_keys = self._calculate_keys(include=include,
exclude=exclude,
exclude_unset=exclude_unset)
if allowed_keys is None and not (to_dict or by_alias or exclude_unset
or exclude_defaults or exclude_none):
# huge boost for plain _iter()
yield from self.__dict__.items()
return
value_exclude = ValueItems(self, exclude) if exclude else None
value_include = ValueItems(self, include) if include else None
for field_key, v in self.__dict__.items():
if ((allowed_keys is not None and field_key not in allowed_keys)
or (exclude_none and v is None) or
(exclude_defaults
and self.__field_defaults__.get(field_key, _missing) == v)):
continue
if by_alias and field_key in self.__fields__:
dict_key = self.__fields__[field_key].alias
else:
dict_key = field_key
if to_dict or value_include or value_exclude:
v = self._get_value(
v,
to_dict=to_dict,
by_alias=by_alias,
include=value_include
and value_include.for_element(field_key),
exclude=value_exclude
and value_exclude.for_element(field_key),
exclude_unset=exclude_unset,
exclude_defaults=exclude_defaults,
exclude_none=exclude_none,
)
yield dict_key, v
def test_value_items_error():
with pytest.raises(TypeError) as e:
ValueItems(1, (1, 2, 3))
assert str(e.value) == "Unexpected type of exclude value <class 'tuple'>"
def test_value_items():
v = ['a', 'b', 'c']
vi = ValueItems(v, {0, -1})
assert vi.is_excluded(2)
assert [v_ for i, v_ in enumerate(v) if not vi.is_excluded(i)] == ['b']
assert vi.is_included(2)
assert [v_ for i, v_ in enumerate(v) if vi.is_included(i)] == ['a', 'c']
v2 = {'a': v, 'b': {'a': 1, 'b': (1, 2)}, 'c': 1}
vi = ValueItems(v2, {'a': {0, -1}, 'b': {'a':..., 'b': -1}})
assert not vi.is_excluded('a')
assert vi.is_included('a')
assert not vi.is_excluded('c')
assert not vi.is_included('c')
assert str(vi) == "{'a': {0, -1}, 'b': {'a': Ellipsis, 'b': -1}}"
assert repr(
vi) == "ValueItems({'a': {0, -1}, 'b': {'a': Ellipsis, 'b': -1}})"
excluded = {k_: v_ for k_, v_ in v2.items() if not vi.is_excluded(k_)}
assert excluded == {'a': v, 'b': {'a': 1, 'b': (1, 2)}, 'c': 1}
included = {k_: v_ for k_, v_ in v2.items() if vi.is_included(k_)}
assert included == {'a': v, 'b': {'a': 1, 'b': (1, 2)}}
sub_v = included['a']
sub_vi = ValueItems(sub_v, vi.for_element('a'))
assert repr(sub_vi) == 'ValueItems({0, 2})'
assert sub_vi.is_excluded(2)
assert [v_ for i, v_ in enumerate(sub_v)
if not sub_vi.is_excluded(i)] == ['b']
assert sub_vi.is_included(2)
assert [v_ for i, v_ in enumerate(sub_v)
if sub_vi.is_included(i)] == ['a', 'c']
def test_value_items_merge(base, override, intersect, expected):
actual = ValueItems.merge(base, override, intersect=intersect)
assert actual == expected
