From 9f4813d9219de3aceffc439f6080aebaf41a6bda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Lafr=C3=A9choux?= Date: Wed, 29 May 2019 17:38:24 +0200 Subject: [PATCH] Rename container into inner in container fields --- src/marshmallow/fields.py | 106 +++++++++++++++++++------------------- tests/test_fields.py | 38 +++++++------- 2 files changed, 72 insertions(+), 72 deletions(-) diff --git a/src/marshmallow/fields.py b/src/marshmallow/fields.py index 88ca83440..cafe40ed5 100644 --- a/src/marshmallow/fields.py +++ b/src/marshmallow/fields.py @@ -56,7 +56,7 @@ ) -CONTAINER_MODIFIERS = ['only', 'exclude'] +INNER_MODIFIERS = ['only', 'exclude'] class Field(FieldABC): @@ -356,7 +356,7 @@ def _deserialize(self, value, attr, data, **kwargs): return value def get_modifiers(self): - return {attr: None for attr in CONTAINER_MODIFIERS} + return {attr: None for attr in INNER_MODIFIERS} def set_modifiers(self, modifiers): pass @@ -516,7 +516,7 @@ def _deserialize(self, value, attr, data, partial=None, **kwargs): return self._load(value, data, partial=partial) def get_modifiers(self): - return {attr: getattr(self, attr) for attr in CONTAINER_MODIFIERS} + return {attr: getattr(self, attr) for attr in INNER_MODIFIERS} def set_modifiers(self, modifiers): for attr, value in modifiers.items(): @@ -567,13 +567,13 @@ def _deserialize(self, value, attr, data, partial=None, **kwargs): class ContainerMixin: """Common methods for container fields""" - def init_container_modifiers(self, container): - for attr, value in container.get_modifiers().items(): + def init_inner_modifiers(self, inner): + for attr, value in inner.get_modifiers().items(): setattr(self, attr, value) - def set_container_modifiers(self, container): - container.set_modifiers({ - attr: getattr(self, attr) for attr in CONTAINER_MODIFIERS + def set_inner_modifiers(self, inner): + inner.set_modifiers({ + attr: getattr(self, attr) for attr in INNER_MODIFIERS }) @@ -599,29 +599,29 @@ class List(ContainerMixin, Field): def __init__(self, cls_or_instance, **kwargs): super().__init__(**kwargs) try: - self.container = resolve_field_instance(cls_or_instance) + self.inner = resolve_field_instance(cls_or_instance) except FieldInstanceResolutionError: raise ValueError( 'The list elements must be a subclass or instance of ' 'marshmallow.base.FieldABC.', ) - self.init_container_modifiers(self.container) + self.init_inner_modifiers(self.inner) def _bind_to_schema(self, field_name, schema): super()._bind_to_schema(field_name, schema) - self.container = copy.deepcopy(self.container) - self.container.parent = self - self.container.name = field_name - self.set_container_modifiers(self.container) + self.inner = copy.deepcopy(self.inner) + self.inner.parent = self + self.inner.name = field_name + self.set_inner_modifiers(self.inner) def _serialize(self, value, attr, obj, **kwargs): if value is None: return None if utils.is_collection(value): return [ - self.container._serialize(each, attr, obj, **kwargs) for each in value + self.inner._serialize(each, attr, obj, **kwargs) for each in value ] - return [self.container._serialize(value, attr, obj, **kwargs)] + return [self.inner._serialize(value, attr, obj, **kwargs)] def _deserialize(self, value, attr, data, **kwargs): if not utils.is_collection(value): @@ -631,7 +631,7 @@ def _deserialize(self, value, attr, data, **kwargs): errors = {} for idx, each in enumerate(value): try: - result.append(self.container.deserialize(each)) + result.append(self.inner.deserialize(each)) except ValidationError as error: if error.valid_data is not None: result.append(error.valid_data) @@ -682,18 +682,18 @@ def __init__(self, tuple_fields, *args, **kwargs): ) self.validate_length = Length(equal=len(self.tuple_fields)) - for container in self.tuple_fields: - self.init_container_modifiers(container) + for inner in self.tuple_fields: + self.init_inner_modifiers(inner) def _bind_to_schema(self, field_name, schema): super()._bind_to_schema(field_name, schema) new_tuple_fields = [] - for container in self.tuple_fields: - container = copy.deepcopy(container) - container.parent = self - container.name = field_name - new_tuple_fields.append(container) - self.set_container_modifiers(container) + for inner in self.tuple_fields: + inner = copy.deepcopy(inner) + inner.parent = self + inner.name = field_name + new_tuple_fields.append(inner) + self.set_inner_modifiers(inner) self.tuple_fields = new_tuple_fields def _serialize(self, value, attr, obj, **kwargs): @@ -701,8 +701,8 @@ def _serialize(self, value, attr, obj, **kwargs): return None return tuple( - container._serialize(each, attr, obj, **kwargs) - for container, each in zip(self.tuple_fields, value) + inner._serialize(each, attr, obj, **kwargs) + for inner, each in zip(self.tuple_fields, value) ) def _deserialize(self, value, attr, data, **kwargs): @@ -714,9 +714,9 @@ def _deserialize(self, value, attr, data, **kwargs): result = [] errors = {} - for idx, (container, each) in enumerate(zip(self.tuple_fields, value)): + for idx, (inner, each) in enumerate(zip(self.tuple_fields, value)): try: - result.append(container.deserialize(each)) + result.append(inner.deserialize(each)) except ValidationError as error: if error.valid_data is not None: result.append(error.valid_data) @@ -1302,10 +1302,10 @@ class Mapping(ContainerMixin, Field): def __init__(self, keys=None, values=None, **kwargs): super().__init__(**kwargs) if keys is None: - self.key_container = None + self.key_inner = None else: try: - self.key_container = resolve_field_instance(keys) + self.key_inner = resolve_field_instance(keys) except FieldInstanceResolutionError: raise ValueError( '"keys" must be a subclass or instance of ' @@ -1313,55 +1313,55 @@ def __init__(self, keys=None, values=None, **kwargs): ) if values is None: - self.value_container = None + self.value_inner = None else: try: - self.value_container = resolve_field_instance(values) + self.value_inner = resolve_field_instance(values) except FieldInstanceResolutionError: raise ValueError( '"values" must be a subclass or instance of ' 'marshmallow.base.FieldABC.', ) - self.init_container_modifiers(self.value_container) + self.init_inner_modifiers(self.value_inner) def _bind_to_schema(self, field_name, schema): super()._bind_to_schema(field_name, schema) - if self.value_container: - self.value_container = copy.deepcopy(self.value_container) - self.value_container.parent = self - self.value_container.name = field_name - self.set_container_modifiers(self.value_container) - if self.key_container: - self.key_container = copy.deepcopy(self.key_container) - self.key_container.parent = self - self.key_container.name = field_name + if self.value_inner: + self.value_inner = copy.deepcopy(self.value_inner) + self.value_inner.parent = self + self.value_inner.name = field_name + self.set_inner_modifiers(self.value_inner) + if self.key_inner: + self.key_inner = copy.deepcopy(self.key_inner) + self.key_inner.parent = self + self.key_inner.name = field_name def _serialize(self, value, attr, obj, **kwargs): if value is None: return None - if not self.value_container and not self.key_container: + if not self.value_inner and not self.key_inner: return value if not isinstance(value, _Mapping): self.fail('invalid') #  Serialize keys - if self.key_container is None: + if self.key_inner is None: keys = {k: k for k in value.keys()} else: keys = { - k: self.key_container._serialize(k, None, None, **kwargs) + k: self.key_inner._serialize(k, None, None, **kwargs) for k in value.keys() } #  Serialize values result = self.mapping_type() - if self.value_container is None: + if self.value_inner is None: for k, v in value.items(): if k in keys: result[keys[k]] = v else: for k, v in value.items(): - result[keys[k]] = self.value_container._serialize( + result[keys[k]] = self.value_inner._serialize( v, None, None, **kwargs ) @@ -1370,32 +1370,32 @@ def _serialize(self, value, attr, obj, **kwargs): def _deserialize(self, value, attr, data, **kwargs): if not isinstance(value, _Mapping): self.fail('invalid') - if not self.value_container and not self.key_container: + if not self.value_inner and not self.key_inner: return value errors = collections.defaultdict(dict) #  Deserialize keys - if self.key_container is None: + if self.key_inner is None: keys = {k: k for k in value.keys()} else: keys = {} for key in value.keys(): try: - keys[key] = self.key_container.deserialize(key) + keys[key] = self.key_inner.deserialize(key) except ValidationError as error: errors[key]['key'] = error.messages #  Deserialize values result = self.mapping_type() - if self.value_container is None: + if self.value_inner is None: for k, v in value.items(): if k in keys: result[keys[k]] = v else: for key, val in value.items(): try: - deser_val = self.value_container.deserialize(val) + deser_val = self.value_inner.deserialize(val) except ValidationError as error: errors[key]['value'] = error.messages if error.valid_data is not None and key in keys: diff --git a/tests/test_fields.py b/tests/test_fields.py index b422a357d..092d6a656 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -122,32 +122,32 @@ def test_unbound_field_root_returns_none(self): assert inner_field.root is None def test_list_field_inner_parent_and_name(self, schema): - assert schema.fields['bar'].container.parent == schema.fields['bar'] - assert schema.fields['bar'].container.name == 'bar' + assert schema.fields['bar'].inner.parent == schema.fields['bar'] + assert schema.fields['bar'].inner.name == 'bar' def test_tuple_field_inner_parent_and_name(self, schema): - for container in schema.fields['baz'].tuple_fields: - assert container.parent == schema.fields['baz'] - assert container.name == 'baz' + for inner in schema.fields['baz'].tuple_fields: + assert inner.parent == schema.fields['baz'] + assert inner.name == 'baz' def test_simple_field_root(self, schema): assert schema.fields['foo'].root == schema assert schema.fields['bar'].root == schema def test_list_field_inner_root(self, schema): - assert schema.fields['bar'].container.root == schema + assert schema.fields['bar'].inner.root == schema def test_tuple_field_inner_root(self, schema): - for container in schema.fields['baz'].tuple_fields: - assert container.root == schema + for inner in schema.fields['baz'].tuple_fields: + assert inner.root == schema def test_list_root_inheritance(self, schema): class OtherSchema(TestParentAndName.MySchema): pass schema2 = OtherSchema() - assert schema.fields['bar'].container.root == schema - assert schema2.fields['bar'].container.root == schema2 + assert schema.fields['bar'].inner.root == schema + assert schema2.fields['bar'].inner.root == schema2 def test_dict_root_inheritance(self): class MySchema(Schema): @@ -158,10 +158,10 @@ class OtherSchema(MySchema): schema = MySchema() schema2 = OtherSchema() - assert schema.fields['foo'].key_container.root == schema - assert schema.fields['foo'].value_container.root == schema - assert schema2.fields['foo'].key_container.root == schema2 - assert schema2.fields['foo'].value_container.root == schema2 + assert schema.fields['foo'].key_inner.root == schema + assert schema.fields['foo'].value_inner.root == schema + assert schema2.fields['foo'].key_inner.root == schema2 + assert schema2.fields['foo'].value_inner.root == schema2 class TestMetadata: @@ -257,7 +257,7 @@ class Family(Schema): children = fields.List(fields.Nested(Child)) schema = Family(**{param: ['children.name']}) - assert getattr(schema.fields['children'].container, param) == {'name'} + assert getattr(schema.fields['children'].inner, param) == {'name'} @pytest.mark.parametrize('param', ('only', 'exclude')) def test_list_nested_only_and_exclude_merged_with_nested(self, param): @@ -275,7 +275,7 @@ class Family(Schema): 'only': {'name'}, 'exclude': {'name', 'surname', 'age'}, }[param] - assert getattr(schema.fields['children'].container, param) == expected + assert getattr(schema.fields['children'].inner, param) == expected class TestTupleNested: @@ -306,7 +306,7 @@ class Family(Schema): ( fields.Nested(Child, **{param: ('name', 'surname')}), fields.Nested(Child, **{param: ('name', 'surname')}), - ) + ), ) schema = Family(**{param: ['children.name', 'children.age']}) @@ -330,7 +330,7 @@ class Family(Schema): children = fields.Dict(values=fields.Nested(Child)) schema = Family(**{param: ['children.name']}) - assert getattr(schema.fields['children'].value_container, param) == {'name'} + assert getattr(schema.fields['children'].value_inner, param) == {'name'} @pytest.mark.parametrize('param', ('only', 'exclude')) def test_dict_nested_only_and_exclude_merged_with_nested(self, param): @@ -348,4 +348,4 @@ class Family(Schema): 'only': {'name'}, 'exclude': {'name', 'surname', 'age'}, }[param] - assert getattr(schema.fields['children'].value_container, param) == expected + assert getattr(schema.fields['children'].value_inner, param) == expected