Support collectons abc (#685)

* Support Sequence and MutableSequence

* Support Mapping and MutableMapping

* Support Set, MutableSet

* Update documents for collections.abc suppport

Author: yukinarit

README.md

@@ -65,7 +65,9 @@ Happy coding with pyserde! 🚀
 - Supported types
     - Primitives (`int`, `float`, `str`, `bool`)
     - Containers
-        - `list`, `set`, `tuple`, `dict`
+        - `list`, `collections.abc.Sequence`, `collections.abc.MutableSequence`, `tuple`
+        - `set`, `collections.abc.Set`, `collections.abc.MutableSet`
+        - `dict`, `collections.abc.Mapping`, `collections.abc.MutableMapping`
         - [`frozenset`](https://docs.python.org/3/library/stdtypes.html#frozenset), [`defaultdict`](https://docs.python.org/3/library/collections.html#collections.defaultdict)
     - [`typing.Optional`](https://docs.python.org/3/library/typing.html#typing.Optional)
     - [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union)

docs/en/types.md

@@ -4,7 +4,9 @@ Here is the list of the supported types. See the simple example for each type in
 
 * Primitives (int, float, str, bool) [^1]
 * Containers
-    * `list`, `set`, `tuple`, `dict` [^2]
+    * `list`, `collections.abc.Sequence`, `collections.abc.MutableSequence`, `tuple` [^2]
+    * `set`, `collections.abc.Set`, `collections.abc.MutableSet` [^2]
+    * `dict`, `collections.abc.Mapping`, `collections.abc.MutableMapping` [^2]
     * [`frozenset`](https://docs.python.org/3/library/stdtypes.html#frozenset), [^3]
     * [`defaultdict`](https://docs.python.org/3/library/collections.html#collections.defaultdict) [^4]
 * [`typing.Optional`](https://docs.python.org/3/library/typing.html#typing.Optional) [^5]

docs/ja/types.md

@@ -4,7 +4,9 @@
 
 * プリミティブ（`int`, `float`, `str`, `bool`）[^1]
 * コンテナ
-    * `list`, `set`, `tuple`, `dict` [^2]
+    * `list`, `collections.abc.Sequence`, `collections.abc.MutableSequence`, `tuple` [^2]
+    * `set`, `collections.abc.Set`, `collections.abc.MutableSet` [^2]
+    * `dict`, `collections.abc.Mapping`, `collections.abc.MutableMapping` [^2]
     * [`frozenset`](https://docs.python.org/3/library/stdtypes.html#frozenset) [^3]
     * [`defaultdict`](https://docs.python.org/3/library/collections.html#collections.defaultdict) [^4]
 * [`typing.Optional`](https://docs.python.org/3/library/typing.html#typing.Optional)[^5]

examples/mapping.py

@@ -0,0 +1,27 @@
+from collections import UserDict
+from collections.abc import Mapping, MutableMapping
+from types import MappingProxyType
+
+from serde import serde
+from serde.json import from_json, to_json
+
+
+@serde
+class Foo:
+    m: Mapping[str, int]
+    mm: MutableMapping[str, int]
+
+
+def main() -> None:
+    proxy: Mapping[str, int] = MappingProxyType({"a": 1, "b": 2})
+    userdict: MutableMapping[str, int] = UserDict({"c": 3, "d": 4})
+
+    foo = Foo(m=proxy, mm=userdict)
+    print(f"Into Json: {to_json(foo)}")  # -> {"m":{"a":1,"b":2},"mm":{"c":3,"d":4}}
+
+    s = '{"m":{"a":1,"b":2},"mm":{"c":3,"d":4}}'
+    print(f"From Json: {from_json(Foo, s)}")  # -> Foo(m={'a': 1, 'b': 2}, mm={'c': 3, 'd': 4})
+
+
+if __name__ == "__main__":
+    main()

examples/runner.py

@@ -13,6 +13,9 @@ def run_all() -> None:
     import class_var
     import primitive_subclass
     import collection
+    import mapping
+    import sequence
+    import set_abc
     import custom_class_serializer
     import custom_legacy_class_serializer
     import custom_field_serializer
@@ -70,6 +73,9 @@ def run_all() -> None:
     run(frozen_set)
     run(newtype)
     run(collection)
+    run(mapping)
+    run(sequence)
+    run(set_abc)
     run(default)
     run(default_dict)
     run(env)

examples/sequence.py

@@ -0,0 +1,22 @@
+from collections.abc import Sequence
+
+from serde import serde
+from serde.json import from_json, to_json
+
+
+@serde
+class Foo:
+    xs: Sequence[int]
+
+
+def main() -> None:
+    # Any non-string Sequence works (e.g. tuple, list).
+    foo = Foo(xs=(1, 2, 3))
+    print(f"Into Json: {to_json(foo)}")  # -> {"xs":[1,2,3]}
+
+    s = '{"xs":[1,2,3]}'
+    print(f"From Json: {from_json(Foo, s)}")  # -> Foo(xs=[1, 2, 3])
+
+
+if __name__ == "__main__":
+    main()

examples/set_abc.py

@@ -0,0 +1,22 @@
+from collections.abc import MutableSet, Set
+
+from serde import serde
+from serde.json import from_json, to_json
+
+
+@serde
+class Foo:
+    s: Set[int]
+    ms: MutableSet[int]
+
+
+def main() -> None:
+    f = Foo(s=frozenset({1, 2}), ms=set({3, 4}))
+    print(f"Into Json: {to_json(f)}")
+
+    s = '{"s":[1,2],"ms":[3,4]}'
+    print(f"From Json: {from_json(Foo, s)}")
+
+
+if __name__ == "__main__":
+    main()

serde/compat.py

@@ -15,7 +15,8 @@
 import typing
 import typing_extensions
 from collections import defaultdict
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence, MutableSequence
+from collections.abc import Mapping, MutableMapping, Set, MutableSet
 from dataclasses import is_dataclass
 from typing import TypeVar, Generic, Any, ClassVar, Optional, NewType, Union, Hashable, Callable
 
@@ -563,30 +564,50 @@ def is_opt_dataclass(typ: Any) -> bool:
 @cache
 def is_list(typ: type[Any]) -> bool:
     """
-    Test if the type is `list`.
+    Test if the type is `list`, `collections.abc.Sequence`, or `collections.abc.MutableSequence`.
 
     >>> is_list(list[int])
     True
     >>> is_list(list)
     True
+    >>> is_list(Sequence[int])
+    True
+    >>> is_list(Sequence)
+    True
+    >>> is_list(MutableSequence[int])
+    True
+    >>> is_list(MutableSequence)
+    True
     """
-    try:
-        return issubclass(get_origin(typ), list)  # type: ignore
-    except TypeError:
-        return typ is list
+    origin = get_origin(typ)
+    if origin is None:
+        return typ in (list, Sequence, MutableSequence)
+    return origin in (list, Sequence, MutableSequence)
 
 
 @cache
 def is_bare_list(typ: type[Any]) -> bool:
     """
-    Test if the type is `list` without type args.
+    Test if the type is `list`/`collections.abc.Sequence`/`collections.abc.MutableSequence`
+    without type args.
 
     >>> is_bare_list(list[int])
     False
     >>> is_bare_list(list)
     True
+    >>> is_bare_list(Sequence[int])
+    False
+    >>> is_bare_list(Sequence)
+    True
+    >>> is_bare_list(MutableSequence[int])
+    False
+    >>> is_bare_list(MutableSequence)
+    True
     """
-    return typ is list
+    origin = get_origin(typ)
+    if origin in (list, Sequence, MutableSequence):
+        return not type_args(typ)
+    return typ in (list, Sequence, MutableSequence)
 
 
 @cache
@@ -633,32 +654,49 @@ def is_variable_tuple(typ: type[Any]) -> bool:
 @cache
 def is_set(typ: type[Any]) -> bool:
     """
-    Test if the type is `set` or `frozenset`.
+    Test if the type is set-like.
 
     >>> is_set(set[int])
     True
     >>> is_set(set)
     True
     >>> is_set(frozenset[int])
     True
+    >>> from collections.abc import Set, MutableSet
+    >>> is_set(Set[int])
+    True
+    >>> is_set(Set)
+    True
+    >>> is_set(MutableSet[int])
+    True
+    >>> is_set(MutableSet)
+    True
     """
     try:
-        return issubclass(get_origin(typ), (set, frozenset))  # type: ignore
+        return issubclass(get_origin(typ), (set, frozenset, Set, MutableSet))  # type: ignore[arg-type]
     except TypeError:
-        return typ in (set, frozenset)
+        return typ in (set, frozenset, Set, MutableSet)
 
 
 @cache
 def is_bare_set(typ: type[Any]) -> bool:
     """
-    Test if the type is `set` without type args.
+    Test if the type is `set`/`frozenset`/`Set`/`MutableSet` without type args.
 
     >>> is_bare_set(set[int])
     False
     >>> is_bare_set(set)
     True
+    >>> from collections.abc import Set, MutableSet
+    >>> is_bare_set(Set)
+    True
+    >>> is_bare_set(MutableSet)
+    True
     """
-    return typ in (set, frozenset)
+    origin = get_origin(typ)
+    if origin in (set, frozenset, Set, MutableSet):
+        return not type_args(typ)
+    return typ in (set, frozenset, Set, MutableSet)
 
 
 @cache
@@ -680,32 +718,52 @@ def is_frozen_set(typ: type[Any]) -> bool:
 @cache
 def is_dict(typ: type[Any]) -> bool:
     """
-    Test if the type is dict.
+    Test if the type is dict-like.
 
     >>> is_dict(dict[int, int])
     True
     >>> is_dict(dict)
     True
     >>> is_dict(defaultdict[int, int])
     True
+    >>> from collections.abc import Mapping, MutableMapping
+    >>> is_dict(Mapping[str, int])
+    True
+    >>> is_dict(Mapping)
+    True
+    >>> is_dict(MutableMapping[str, int])
+    True
+    >>> is_dict(MutableMapping)
+    True
     """
     try:
-        return issubclass(get_origin(typ), (dict, defaultdict))  # type: ignore
+        return issubclass(
+            get_origin(typ), (dict, defaultdict, Mapping, MutableMapping)  # type: ignore[arg-type]
+        )
     except TypeError:
-        return typ in (dict, defaultdict)
+        return typ in (dict, defaultdict, Mapping, MutableMapping)
 
 
+@cache
 @cache
 def is_bare_dict(typ: type[Any]) -> bool:
     """
-    Test if the type is `dict` without type args.
+    Test if the type is `dict`/`Mapping`/`MutableMapping` without type args.
 
     >>> is_bare_dict(dict[int, str])
     False
     >>> is_bare_dict(dict)
     True
+    >>> from collections.abc import Mapping, MutableMapping
+    >>> is_bare_dict(Mapping)
+    True
+    >>> is_bare_dict(MutableMapping)
+    True
     """
-    return typ is dict
+    origin = get_origin(typ)
+    if origin in (dict, Mapping, MutableMapping):
+        return not type_args(typ)
+    return typ in (dict, Mapping, MutableMapping)
 
 
 @cache

serde/core.py

@@ -12,7 +12,7 @@
 from dataclasses import dataclass
 
 from beartype.door import is_bearable
-from collections.abc import Mapping, Sequence, Callable, Hashable
+from collections.abc import Mapping, Sequence, MutableSequence, Set, Callable, Hashable
 from typing import (
     overload,
     TypeVar,
@@ -403,8 +403,20 @@ def is_union_instance(obj: Any, typ: type[Any]) -> bool:
 
 
 def is_list_instance(obj: Any, typ: type[Any]) -> bool:
-    if not isinstance(obj, list):
-        return False
+    origin = get_origin(typ) or typ
+    if origin is list:
+        if not isinstance(obj, list):
+            return False
+    elif origin is MutableSequence:
+        if isinstance(obj, (str, bytes, bytearray)):
+            return False
+        if not isinstance(obj, MutableSequence):
+            return False
+    else:
+        if isinstance(obj, (str, bytes, bytearray)):
+            return False
+        if not isinstance(obj, Sequence):
+            return False
     if len(obj) == 0 or is_bare_list(typ):
         return True
     list_arg = type_args(typ)[0]
@@ -413,7 +425,7 @@ def is_list_instance(obj: Any, typ: type[Any]) -> bool:
 
 
 def is_set_instance(obj: Any, typ: type[Any]) -> bool:
-    if not isinstance(obj, (set, frozenset)):
+    if not isinstance(obj, Set):
         return False
     if len(obj) == 0 or is_bare_set(typ):
         return True
@@ -458,7 +470,7 @@ def is_tuple_instance(obj: Any, typ: type[Any]) -> bool:
 
 
 def is_dict_instance(obj: Any, typ: type[Any]) -> bool:
-    if not isinstance(obj, dict):
+    if not isinstance(obj, Mapping):
         return False
     if len(obj) == 0 or is_bare_dict(typ):
         return True

serde/de.py

@@ -690,7 +690,7 @@ def __getitem__(self, n: int) -> DeField[Any] | InnerField[Any]:
             "flatten": self.flatten,
             "parent": self.parent,
         }
-        if is_list(self.type) or is_dict(self.type) or is_set(self.type):
+        if is_list(self.type) or is_set(self.type) or is_dict(self.type):
             return InnerField(typ, "v", datavar="v", **opts)
         elif is_tuple(self.type):
             return InnerField(typ, f"{self.data}[{n}]", datavar=f"{self.data}[{n}]", **opts)