implement local support for more types, both pack & unpack

add more types to test

mashumaro/core/meta/code/builder.py

@@ -45,7 +45,7 @@
     is_hashable,
     is_init_var,
     is_literal,
-    is_local_type,
+    is_local_type_name,
     is_named_tuple,
     is_optional,
     is_type_var_any,
@@ -1264,9 +1264,9 @@ def build(
             ),
         )
 
-        if is_local_type(ftype):
+        if is_local_type_name(field_type):
             field_type = clean_id(field_type)
-            self.ensure_object_imported(ftype, field_type)
+            self.parent.ensure_object_imported(ftype, field_type)
 
         could_be_none = (
             ftype in (typing.Any, type(None), None)

mashumaro/core/meta/helpers.py

@@ -389,8 +389,8 @@ def is_literal(typ: Type) -> bool:
     return False
 
 
-def is_local_type(typ: Type) -> bool:
-    return "<locals>" in getattr(typ, "__qualname__", "")
+def is_local_type_name(type_name: str) -> bool:
+    return "<locals>" in type_name
 
 
 def not_none_type_arg(

mashumaro/core/meta/types/pack.py

@@ -32,6 +32,7 @@
     is_final,
     is_generic,
     is_literal,
+    is_local_type_name,
     is_named_tuple,
     is_new_type,
     is_not_required,
@@ -306,6 +307,11 @@ def pack_union(
                 spec.field_ctx.name
             ),
         )
+
+        if is_local_type_name(field_type):
+            field_type = clean_id(field_type)
+            spec.builder.ensure_object_imported(spec.type, field_type)
+
         if spec.builder.is_nailed:
             lines.append(
                 "raise InvalidFieldValue("
@@ -359,6 +365,13 @@ def pack_literal(spec: ValueSpec) -> Expression:
                     typ=value_type,
                     resolved_type_params=resolved_type_params,
                 )
+
+                if is_local_type_name(enum_type_name):
+                    enum_type_name = clean_id(enum_type_name)
+                    spec.builder.ensure_object_imported(
+                        value_type, enum_type_name
+                    )
+
                 with lines.indent(
                     f"if value == {enum_type_name}.{literal_value.name}:"
                 ):
@@ -373,6 +386,11 @@ def pack_literal(spec: ValueSpec) -> Expression:
             typ=spec.type,
             resolved_type_params=resolved_type_params,
         )
+
+        if is_local_type_name(field_type):
+            field_type = clean_id(field_type)
+            spec.builder.ensure_object_imported(spec.type, field_type)
+
         if spec.builder.is_nailed:
             lines.append(
                 f"raise InvalidFieldValue('{spec.field_ctx.name}',"

mashumaro/core/meta/types/unpack.py

@@ -39,6 +39,7 @@
     is_final,
     is_generic,
     is_literal,
+    is_local_type_name,
     is_named_tuple,
     is_new_type,
     is_not_required,
@@ -180,6 +181,10 @@ def _add_body(self, spec: ValueSpec, lines: CodeLines) -> None:
             ),
         )
         if spec.builder.is_nailed:
+            if is_local_type_name(field_type):
+                field_type = clean_id(field_type)
+                spec.builder.ensure_object_imported(spec.type, field_type)
+
             lines.append(
                 "raise InvalidFieldValue("
                 f"'{spec.field_ctx.name}',{field_type},value,cls)"
@@ -203,7 +208,15 @@ def get_method_prefix(self) -> str:
     def _add_body(self, spec: ValueSpec, lines: CodeLines) -> None:
         for literal_value in get_literal_values(spec.type):
             if isinstance(literal_value, enum.Enum):
-                enum_type_name = type_name(type(literal_value))
+                lit_type = type(literal_value)
+                enum_type_name = type_name(lit_type)
+
+                if is_local_type_name(enum_type_name):
+                    enum_type_name = clean_id(enum_type_name)
+                    spec.builder.ensure_object_imported(
+                        lit_type, enum_type_name
+                    )
+
                 with lines.indent(
                     f"if value == {enum_type_name}.{literal_value.name}.value:"
                 ):
@@ -300,6 +313,10 @@ def _add_body(self, spec: ValueSpec, lines: CodeLines) -> None:
         variants = self._get_variant_names_iterable(spec)
         variants_type_expr = type_name(spec.type)
 
+        if is_local_type_name(variants_type_expr):
+            variants_type_expr = clean_id(variants_type_expr)
+            spec.builder.ensure_object_imported(spec.type, variants_type_expr)
+
         if variants_attr not in variants_attr_holder.__dict__:
             setattr(variants_attr_holder, variants_attr, {})
         variant_method_name = spec.builder.get_unpack_method_name(
@@ -565,7 +582,14 @@ def _unpack_annotated_serializable_type(
         ],
     )
     unpacker = UnpackerRegistry.get(spec.copy(type=value_type))
-    return f"{type_name(spec.type)}._deserialize({unpacker})"
+
+    field_type = type_name(spec.type)
+
+    if is_local_type_name(field_type):
+        field_type = clean_id(field_type)
+        spec.builder.ensure_object_imported(spec.type, field_type)
+
+    return f"{field_type}._deserialize({unpacker})"
 
 
 @register
@@ -578,7 +602,12 @@ def unpack_serializable_type(spec: ValueSpec) -> Optional[Expression]:
     if spec.origin_type.__use_annotations__:
         return _unpack_annotated_serializable_type(spec)
     else:
-        return f"{type_name(spec.type)}._deserialize({spec.expression})"
+        field_type = type_name(spec.type)
+        if is_local_type_name(field_type):
+            field_type = clean_id(field_type)
+            spec.builder.ensure_object_imported(spec.type, field_type)
+
+        return f"{field_type}._deserialize({spec.expression})"
 
 
 @register
@@ -588,8 +617,14 @@ def unpack_generic_serializable_type(spec: ValueSpec) -> Optional[Expression]:
             type_arg_names = ", ".join(
                 list(map(type_name, get_args(spec.type)))
             )
+            field_type = type_name(spec.origin_type)
+
+            if is_local_type_name(field_type):
+                field_type = clean_id(field_type)
+                spec.builder.ensure_object_imported(spec.type, field_type)
+
             return (
-                f"{type_name(spec.type)}._deserialize({spec.expression}, "
+                f"{field_type}._deserialize({spec.expression}, "
                 f"[{type_arg_names}])"
             )
 
@@ -990,7 +1025,12 @@ def unpack_named_tuple(spec: ValueSpec) -> Expression:
         unpackers.append(unpacker)
 
     if not defaults:
-        return f"{type_name(spec.type)}({', '.join(unpackers)})"
+        field_type = type_name(spec.type)
+        if is_local_type_name(field_type):
+            field_type = clean_id(field_type)
+            spec.builder.ensure_object_imported(spec.type, field_type)
+
+        return f"{field_type}({', '.join(unpackers)})"
 
     lines = CodeLines()
     method_name = (
@@ -1015,7 +1055,13 @@ def unpack_named_tuple(spec: ValueSpec) -> Expression:
                 lines.append(f"fields.append({unpacker})")
         with lines.indent("except IndexError:"):
             lines.append("pass")
-        lines.append(f"return {type_name(spec.type)}(*fields)")
+
+        field_type = type_name(spec.type)
+        if is_local_type_name(field_type):
+            field_type = clean_id(field_type)
+            spec.builder.ensure_object_imported(spec.type, field_type)
+
+        lines.append(f"return {field_type}(*fields)")
     lines.append(
         f"setattr({spec.cls_attrs_name}, '{method_name}', {method_name})"
     )
@@ -1194,10 +1240,22 @@ def unpack_pathlike(spec: ValueSpec) -> Optional[Expression]:
         spec.builder.ensure_module_imported(pathlib)
         return f"{type_name(pathlib.PurePath)}({spec.expression})"
     elif issubclass(spec.origin_type, os.PathLike):
-        return f"{type_name(spec.origin_type)}({spec.expression})"
+        field_type = type_name(spec.origin_type)
+
+        if is_local_type_name(field_type):
+            field_type = clean_id(field_type)
+            spec.builder.ensure_object_imported(spec.type, field_type)
+
+        return f"{field_type}({spec.expression})"
 
 
 @register
 def unpack_enum(spec: ValueSpec) -> Optional[Expression]:
     if issubclass(spec.origin_type, enum.Enum):
-        return f"{type_name(spec.origin_type)}({spec.expression})"
+        field_type = type_name(spec.origin_type)
+
+        if is_local_type_name(field_type):
+            field_type = clean_id(field_type)
+            spec.builder.ensure_object_imported(spec.type, field_type)
+
+        return f"{field_type}({spec.expression})"

tests/test_common.py

@@ -1,5 +1,8 @@
 import dataclasses
 from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import PurePosixPath
+from typing import Any, Literal, NamedTuple
 
 import msgpack
 import pytest
@@ -264,15 +267,81 @@ def test_kw_args_when_pos_arg_is_overridden_with_field():
     assert loaded.kw1 == 4
 
 
-def test_local_type():
+def test_local_types():
     @dataclass
-    class LocalType:
+    class LocalDataclassType:
+        foo: int
+
+    class LocalNamedTupleType(NamedTuple):
+        foo: int
+
+    class LocalPathLike(PurePosixPath):
         pass
 
+    class LocalEnumType(Enum):
+        FOO = "foo"
+
+    class LocalSerializableType(SerializableType):
+        @classmethod
+        def _deserialize(self, value):
+            return LocalSerializableType()
+
+        def _serialize(self) -> Any:
+            return {}
+
+        def __eq__(self, __value: object) -> bool:
+            return isinstance(__value, LocalSerializableType)
+
+    class LocalGenericSerializableType(GenericSerializableType):
+        @classmethod
+        def _deserialize(self, value, types):
+            return LocalGenericSerializableType()
+
+        def _serialize(self, types) -> Any:
+            return {}
+
+        def __eq__(self, __value: object) -> bool:
+            return isinstance(__value, LocalGenericSerializableType)
+
     @dataclass
     class DataClassWithLocalType(DataClassDictMixin):
-        x: LocalType
-
-    obj = DataClassWithLocalType(LocalType())
-    assert obj.to_dict() == {"x": {}}
-    assert DataClassWithLocalType.from_dict({"x": {}}) == obj
+        x1: LocalDataclassType
+        x2: LocalNamedTupleType
+        x3: LocalPathLike
+        x4: LocalEnumType
+        x4_1: Literal[LocalEnumType.FOO]
+        x5: LocalSerializableType
+        x6: LocalGenericSerializableType
+
+    obj = DataClassWithLocalType(
+        x1=LocalDataclassType(foo=0),
+        x2=LocalNamedTupleType(foo=0),
+        x3=LocalPathLike("path/to/file"),
+        x4=LocalEnumType.FOO,
+        x4_1=LocalEnumType.FOO,
+        x5=LocalSerializableType(),
+        x6=LocalGenericSerializableType(),
+    )
+    assert obj.to_dict() == {
+        "x1": {"foo": 0},
+        "x2": [0],
+        "x3": "path/to/file",
+        "x4": "foo",
+        "x4_1": "foo",
+        "x5": {},
+        "x6": {},
+    }
+    assert (
+        DataClassWithLocalType.from_dict(
+            {
+                "x1": {"foo": 0},
+                "x2": [0],
+                "x3": "path/to/file",
+                "x4": "foo",
+                "x4_1": "foo",
+                "x5": {},
+                "x6": {},
+            }
+        )
+        == obj
+    )