Adds a configuration option to allow mixed alias/unaliased field name use when deserializing

README.md

@@ -67,6 +67,7 @@ Table of contents
         * [`discriminator` config option](#discriminator-config-option)
         * [`lazy_compilation` config option](#lazy_compilation-config-option)
         * [`sort_keys` config option](#sort_keys-config-option)
+        * [`allow_deserialization_not_by_alias` config option](#allow_deserialization_not_by_alias-config-option)
     * [Passing field values as is](#passing-field-values-as-is)
     * [Extending existing types](#extending-existing-types)
     * [Dialects](#dialects)
@@ -1391,6 +1392,38 @@ t = SortedDataClass(1, 2)
 assert t.to_dict() == {"bar": 2, "foo": 1}
 ```
 
+#### `allow_deserialization_not_by_alias` config option
+
+When using aliases, the deserializer defaults to requiring the keys to match
+what is defined as the alias in the metadata.
+If the flexibility to deserialize aliased and unaliased keys is required then
+the config option `allow_deserialization_not_by_alias = True` can be set to
+enable the feature.
+
+```python
+from dataclasses import dataclass, field
+from mashumaro import DataClassDictMixin
+from mashumaro.config import BaseConfig, TO_DICT_ADD_BY_ALIAS_FLAG
+
+
+@dataclass
+class AliasedDataClass(DataClassDictMixin):
+    foo: int = field(metadata={"alias": "alias_foo"})
+    bar: int = field(metadata={"alias": "alias_bar"})
+
+    class Config(BaseConfig):
+        serialize_by_alias = True
+        allow_deserialization_not_by_alias = True
+        code_generation_options = [TO_DICT_ADD_BY_ALIAS_FLAG]
+
+
+no_alias_dict = {"bar": 2, "foo": 1}
+# Will raise `mashumaro.exceptions.MissingField` if allow_deserialization_not_by_alias is
+# False
+t = AliasedDataClass.from_dict(no_alias_dict)
+assert t.to_dict(by_alias=False) == {"bar": 2, "foo": 1}
+```
+
 ### Passing field values as is
 
 In some cases it's needed to pass a field value as is without any changes

mashumaro/config.py

@@ -49,3 +49,4 @@ class BaseConfig:
     discriminator: Optional[Discriminator] = None
     lazy_compilation: bool = False
     sort_keys: bool = False
+    allow_deserialization_not_by_alias: bool = False

mashumaro/core/meta/code/builder.py

@@ -555,16 +555,36 @@ def _unpack_method_set_value(
                 could_be_none=False if could_be_none else True,
             )
         )
-        if unpacked_value != "value":
-            self.add_line(f"value = d.get('{alias or fname}', MISSING)")
-            packed_value = "value"
-        elif has_default:
-            self.add_line(f"value = d.get('{alias or fname}', MISSING)")
-            packed_value = "value"
+        if self.get_config().allow_deserialization_not_by_alias:
+            if unpacked_value != "value":
+                self.add_line(f"value = d.get('{alias}', MISSING)")
+                with self.indent("if value is MISSING:"):
+                    self.add_line(f"value = d.get('{fname}', MISSING)")
+                packed_value = "value"
+            elif has_default:
+                self.add_line(f"value = d.get('{alias}', MISSING)")
+                with self.indent("if value is MISSING:"):
+                    self.add_line(f"value = d.get('{fname}', MISSING)")
+                packed_value = "value"
+            else:
+                self.add_line(f"__{fname} = d.get('{alias}', MISSING)")
+                with self.indent(f"if __{fname} is MISSING:"):
+                    self.add_line(f"__{fname} = d.get('{fname}', MISSING)")
+                packed_value = f"__{fname}"
+                unpacked_value = packed_value
         else:
-            self.add_line(f"__{fname} = d.get('{alias or fname}', MISSING)")
-            packed_value = f"__{fname}"
-            unpacked_value = packed_value
+            if unpacked_value != "value":
+                self.add_line(f"value = d.get('{alias or fname}', MISSING)")
+                packed_value = "value"
+            elif has_default:
+                self.add_line(f"value = d.get('{alias or fname}', MISSING)")
+                packed_value = "value"
+            else:
+                self.add_line(
+                    f"__{fname} = d.get('{alias or fname}', MISSING)"
+                )
+                packed_value = f"__{fname}"
+                unpacked_value = packed_value
         if not has_default:
             with self.indent(f"if {packed_value} is MISSING:"):
                 self.add_line(

tests/test_aliases.py

@@ -176,3 +176,25 @@ class Config(BaseConfig):
 
     assert DataClass(x=123).to_dict() == {"alias": 123}
     assert DataClass(x=None).to_dict() == {"alias": None}
+
+
+def test_by_field_with_loose_deserialize():
+    @dataclass
+    class DataClass(DataClassDictMixin):
+        a: int = field(metadata={"alias": "alias_a"})
+        b: Optional[int] = field(metadata={"alias": "alias_b"})
+        c: Optional[str] = field(metadata={"alias": "alias_c"}, default="789")
+
+        class Config(BaseConfig):
+            serialize_by_alias = True
+            code_generation_options = [TO_DICT_ADD_BY_ALIAS_FLAG]
+            allow_deserialization_not_by_alias = True
+
+    instance = DataClass(a=123, b=456)
+    assert DataClass.from_dict({"a": 123, "alias_b": 456}) == instance
+    assert instance.to_dict() == {
+        "alias_a": 123,
+        "alias_b": 456,
+        "alias_c": "789",
+    }
+    assert instance.to_dict(by_alias=False) == {"a": 123, "b": 456, "c": "789"}

tests/test_data_types.py

@@ -43,7 +43,7 @@
 from typing_extensions import Final, LiteralString
 
 from mashumaro import DataClassDictMixin
-from mashumaro.config import BaseConfig
+from mashumaro.config import BaseConfig, TO_DICT_ADD_BY_ALIAS_FLAG
 from mashumaro.core.const import PEP_585_COMPATIBLE, PY_39_MIN
 from mashumaro.exceptions import (
     InvalidFieldValue,
@@ -517,6 +517,29 @@ class DataClass(DataClassDictMixin):
     assert same_types(instance_loaded.x, x_value)
 
 
+@pytest.mark.parametrize("value_info", inner_values)
+@pytest.mark.parametrize("use_alias", [False, True])
+def test_level_one_with_aliased_unaliased_fields(value_info, use_alias):
+    x_type, x_value, x_value_dumped = value_info
+
+    @dataclass
+    class DataClass(DataClassDictMixin):
+        x: x_type = field(metadata={"alias": "alias_x"})
+
+        class Config(BaseConfig):
+            allow_deserialization_not_by_alias = True
+            code_generation_options = [TO_DICT_ADD_BY_ALIAS_FLAG]
+
+    instance = DataClass(x_value)
+    dumped = {"alias_x" if use_alias else "x": x_value_dumped}
+    instance_dumped = instance.to_dict(by_alias=use_alias)
+    instance_loaded = DataClass.from_dict(dumped)
+    assert instance_dumped == dumped
+    assert instance_loaded == instance
+    assert same_types(instance_dumped, dumped)
+    assert same_types(instance_loaded.x, x_value)
+
+
 @pytest.mark.parametrize("value_info", inner_values)
 def test_with_generic_list(value_info):
     check_collection_generic(List, value_info)