feat: Implement alias

* `alias` works only during deserialization
* `rename` + `alias` works as expected
* If alias conflicts, the first one wins

```
@serde
@DataClass
class Foo:
    a: int = field(alias=["b", "c", "d"])
```

README.md

@@ -73,6 +73,7 @@ Foo(i=10, s='foo', f=100.0, b=True)
 - [Forward reference](docs/features/forward-reference.md)
 - [Case Conversion](docs/features/case-conversion.md)
 - [Rename](docs/features/rename.md)
+- [Alias](docs/features/alias.md)
 - [Skip](docs/features/skip.md)
 - [Conditional Skip](docs/features/conditional-skip.md)
 - [Custom field (de)serializer](docs/features/custom-field-serializer.md)

docs/SUMMARY.md

@@ -15,6 +15,7 @@
     - [Forward reference](features/forward-reference.md)
     - [Case Conversion](features/case-conversion.md)
     - [Rename](features/rename.md)
+    - [Alias](features/alias.md)
     - [Skip](features/skip.md)
     - [Conditional Skip](features/conditional-skip.md)
     - [Custom field (de)serializer](features/custom-field-serializer.md)

docs/features/alias.md

@@ -0,0 +1,14 @@
+# Alias
+
+You can set aliases for field names. Alias only works for deserialization.
+
+```python
+@serde
+@dataclass
+class Foo:
+    a: str = field(alias=["b", "c"])
+```
+
+`Foo` can be deserialized from either `{"a": "..."}`, `{"b": "..."}` or `{"c": "..."}`.
+
+For complete example, please see [examples/alias.py](https://github.com/yukinarit/pyserde/blob/master/examples/alias.py)

docs/features/rename.md

@@ -1,12 +1,12 @@
 # Rename
 
-In case you want to use a keyword as field such as `class`, you can use `serde_rename` field attribute.
+In case you want to use a keyword as field such as `class`, you can use `rename` field attribute. If you want to have multiple aliases, you can use [alias](alias.md).
 
 ```python
 @serde
 @dataclass
 class Foo:
-    class_name: str = field(metadata={'serde_rename': 'class'})
+    class_name: str = field(rename='class')
 
 print(to_json(Foo(class_name='Foo')))
 ```

docs/introduction.md

@@ -57,6 +57,7 @@ Foo(i=10, s='foo', f=100.0, b=True)
 - [Forward reference](features/forward-reference.md)
 - [Case Conversion](features/case-conversion.md)
 - [Rename](features/rename.md)
+- [Alias](features/alias.md)
 - [Skip](features/skip.md)
 - [Conditional Skip](features/conditional-skip.md)
 - [Custom field (de)serializer](features/custom-field-serializer.md)

examples/alias.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+
+from serde import field, serde
+from serde.json import from_json
+
+
+@serde
+@dataclass
+class Foo:
+    a: int = field(alias=["b", "c", "d"])
+
+
+def main():
+    s = '{"a": 10}'
+    print(f"From Json: {from_json(Foo, s)}")
+
+    s = '{"b": 20}'
+    print(f"From Json: {from_json(Foo, s)}")
+
+    s = '{"c": 30}'
+    print(f"From Json: {from_json(Foo, s)}")
+
+    s = '{"d": 40}'
+    print(f"From Json: {from_json(Foo, s)}")
+
+    try:
+        s = '{"e": 50}'
+        print(f"From Json: {from_json(Foo, s)}")
+    except Exception:
+        pass
+
+
+if __name__ == '__main__':
+    main()

examples/runner.py

@@ -1,5 +1,6 @@
 import sys
 
+import alias
 import any
 import class_var
 import collection
@@ -67,6 +68,7 @@ def run_all():
     run(ellipsis)
     run(init_var)
     run(class_var)
+    run(alias)
     if PY310:
         import union_operator
 

serde/core.py

@@ -321,6 +321,7 @@ class FlattenOpts:
 def field(
     *args,
     rename: Optional[str] = None,
+    alias: Optional[List[str]] = None,
     skip: Optional[bool] = None,
     skip_if: Optional[Callable] = None,
     skip_if_false: Optional[bool] = None,
@@ -339,6 +340,8 @@ def field(
 
     if rename is not None:
         metadata["serde_rename"] = rename
+    if alias is not None:
+        metadata["serde_alias"] = alias
     if skip is not None:
         metadata["serde_skip"] = skip
     if skip_if is not None:
@@ -432,6 +435,7 @@ class Foo:
     compare: Any = field(default_factory=dataclasses._MISSING_TYPE)
     metadata: Mapping[str, Any] = field(default_factory=dict)
     case: Optional[str] = None
+    alias: List[str] = field(default_factory=list)
     rename: Optional[str] = None
     skip: Optional[bool] = None
     skip_if: Optional[Func] = None
@@ -486,6 +490,7 @@ def from_dataclass(cls, f: dataclasses.Field) -> 'Field':
             compare=f.compare,
             metadata=f.metadata,
             rename=f.metadata.get('serde_rename'),
+            alias=f.metadata.get('serde_alias', []),
             skip=f.metadata.get('serde_skip'),
             skip_if=skip_if or skip_if_false_func or skip_if_default_func,
             serializer=serializer,

serde/de.py

@@ -79,7 +79,7 @@
     is_numpy_scalar,
 )
 
-__all__: List = ['deserialize', 'is_deserializable', 'from_dict', 'from_tuple']
+__all__ = ['deserialize', 'is_deserializable', 'from_dict', 'from_tuple']
 
 # Interface of Custom deserialize function.
 DeserializeFunc = Callable[[Type, Any], Any]
@@ -108,6 +108,15 @@ def default_deserializer(_cls: Type, obj):
     """
 
 
+def _get_by_aliases(d: Dict[str, str], aliases: List[str]):
+    if not aliases:
+        raise KeyError("Tried all aliases, but key not found")
+    if aliases[0] in d:
+        return d[aliases[0]]
+    else:
+        return _get_by_aliases(d, aliases[1:])
+
+
 def _make_deserialize(
     cls_name: str,
     fields,
@@ -233,6 +242,7 @@ def wrap(cls: Type):
         g['TypeCheck'] = TypeCheck
         g['NoCheck'] = NoCheck
         g['coerce'] = coerce
+        g['_get_by_aliases'] = _get_by_aliases
         if deserialize:
             g['serde_custom_class_deserializer'] = functools.partial(
                 serde_custom_class_deserializer, custom=deserializer
@@ -755,6 +765,9 @@ def primitive(self, arg: DeField, suppress_coerce: bool = False) -> str:
         """
         typ = typename(arg.type)
         dat = arg.data
+        if arg.alias:
+            aliases = map(lambda s: f'"{s}"', [arg.name, *arg.alias])
+            dat = f"_get_by_aliases(data, [{','.join(aliases)}])"
         if self.suppress_coerce:
             return dat
         else:

tests/test_basics.py

@@ -454,6 +454,50 @@ class Foo:
     assert f == de(Foo, se(f))
 
 
+@pytest.mark.parametrize('se,de', (format_dict + format_json + format_yaml + format_toml))
+def test_alias(se, de):
+    @serde.serde
+    class Foo:
+        a: str = serde.field(alias=["b", "c", "d"])
+
+    f = Foo(a='foo')
+    assert f == de(Foo, se(f))
+
+
+def test_conflicting_alias():
+    @serde.serde
+    class Foo:
+        a: int = serde.field(alias=["b", "c", "d"])
+        b: int
+        c: int
+        d: int
+
+    f = Foo(a=1, b=2, c=3, d=4)
+    assert '{"a":1,"b":2,"c":3,"d":4}' == serde.json.to_json(f)
+    ff = serde.json.from_json(Foo, '{"a":1,"b":2,"c":3,"d":4}')
+    assert ff.a == 1
+    assert ff.b == 2
+    assert ff.c == 3
+    assert ff.d == 4
+
+    ff = serde.json.from_json(Foo, '{"b":2,"c":3,"d":4}')
+    assert ff.a == 2
+    assert ff.b == 2
+    assert ff.c == 3
+    assert ff.d == 4
+
+
+def test_rename_and_alias():
+    @serde.serde
+    class Foo:
+        a: int = serde.field(rename="z", alias=["b", "c", "d"])
+
+    f = Foo(a=1)
+    assert '{"z":1}' == serde.json.to_json(f)
+    ff = serde.json.from_json(Foo, '{"b":10}')
+    assert ff.a == 10
+
+
 @pytest.mark.parametrize('se,de', (format_dict + format_json + format_msgpack + format_yaml + format_toml))
 def test_skip_if(se, de):
     @serde.serde