Fields of type Optional[Union[A, B]] not working with cast

Example to reproduce faulty behavior:

from dataclasses import dataclass
from typing import Optional, Union
import dacite

class A(int):
    pass

class B(str):
    pass

@dataclass
class C:
    a_or_b: Optional[Union[A, B]]

obj_from_dict = dacite.from_dict(
    data_class=C,
    data={"a_or_b": "Hello world!"},
    config=dacite.Config(cast=[A, B]),
)
assert obj_from_dict == C(a_or_b=B("Hello world!"))

Issue

I would expect this to work flawlessly, since I included both A and B in cast to turn int to A and str to B so that the types match. Unfortunately this is not the case, instead I get

Traceback (most recent call last):
  File "problem.py", line 15, in <module>
    obj_from_dict = dacite.from_dict(
  File "[...]/lib/python3.8/site-packages/dacite/core.py", line 60, in from_dict
    transformed_value = transform_value(
  File "[...]/lib/python3.8/site-packages/dacite/types.py", line 24, in transform_value
    return transform_value(type_hooks, cast, target_type, value)
  File "[...]/lib/python3.8/site-packages/dacite/types.py", line 18, in transform_value
    value = target_type(value)
ValueError: invalid literal for int() with base 10: 'Hello world!'

If we inspect this more closely, we first enter from_dict and then transform_value where the target type is Union[A, B, None]. Since the target type is correctly identified as optional by is_optional and since the value is not None (but "Hello world!"), transform_value is again called. This time the target type is extract_optional(Union[A, B, None]). It should be Union[A, B], but in the current implementation it is A. This causes the program to incorrectly cast "Hello World!" to A and the program crashes.

Solution

def extract_optional(optional: Type[Optional[T]]) -> T:
    for type_ in extract_generic(optional):
        if type_ is not type(None):
            return type_
    raise ValueError("can not find not-none value")

should be changed to something like

def extract_optional(optional: Type[Optional[T]]) -> T:
    other_members = [member for member in extract_generic(optional) if member is not type(None)]
    if not other_members:
        raise ValueError("can not find not-none value")
    else:
        return Union[tuple(other_members)]

This way extract_optional(Union[A, B, None]) == Union[A, B] and no incorrect casting happens. The Union is then properly handled by _build_value_for_union. Note that, if other_members contains only a single type, say A, then Union[A] == A.

Basically, this is the same problem reported in #26 for is_optional, but this time for extract_optional. It is also probably related to #161. This issues does not appear without including the types inside the union in type_hooks or cast, because then the incorrect call to transform_values does not actually do anything.

konradhalas / dacite