Union type is not supported

[tsuga]

I'm seeing an error when using Union type.

from typing import Union
from datafiles import datafile, Missing

@datafile("inventory/items/{self.name}.yml")
class InventoryItem:
    """Class for keeping track of an item in inventory."""

    name: str
    unit_price: float
    quantity_on_hand: Union[int, float] = 0

item = InventoryItem("widget", 3)

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
[<ipython-input-4-9790d08ed9c3>](https://localhost:8080/#) in <module>()
     10     quantity_on_hand: Union[int, float] = 0.0
     11 
---> 12 item = InventoryItem("widget", 3)

3 frames
[/usr/local/lib/python3.7/dist-packages/datafiles/converters/__init__.py](https://localhost:8080/#) in map_type(cls, name, item_cls)
    134             converter = map_type(cls.__args__[0])
    135             assert len(cls.__args__) == 2
--> 136             assert cls.__args__[1] == type(None)
    137             converter = converter.as_optional()
    138 

AssertionError:

[tsuga]

#239 might be related.

[jacebrowning]

For classes under your control, Number should work instead of Union[int, float].

How would you expect serialization to work for disparate types such as Union[str, bool, float]?

[jacebrowning]

While it's not full support for Union types, #272 will handle Union[str, ...] (treated as the broader str type) and Union[int, float] (treated as the broader float type).

[traverseda]

How would you expect serialization to work for disparate types such as Union[str, bool, float]?

Yaml supports type-hints, which would be nice.

I'm using a hack something like this, where the rule_type is just available as a field.

from datafiles import datafile, converters
from dataclasses import dataclass, field
from typing import List, Union, Optional

def all_subclasses(cls):
    """ Recursively finds all subclasses of a given class. """
    return cls.__subclasses__() + [g for s in cls.__subclasses__() for g in all_subclasses(s)]

@dataclass
class RuleBase:
    """ Base class for all rules """
    rule_type: Optional[str] = None
    value: str = "default_orig"

    def __post_init__(self):
        self.rule_type = self.__class__.__name__

class RuleBaseConverter(converters.Converter):
    """ Custom converter for RuleBase """

    @classmethod
    def to_python_value(cls, deserialized_data, **kwargs):
        """ Convert a dictionary back into an instance of the correct subclass """
        print(f"Deserializing: {deserialized_data}")

        # Force using RuleBase to get subclasses
        subclasses = {sub.__name__: sub for sub in all_subclasses(RuleBase)}
        rule_type = deserialized_data.pop("rule_type", None)

        if rule_type in subclasses:
            return subclasses[rule_type](**deserialized_data)

        raise ValueError(f"Unknown rule type: {rule_type}")

# Register the converter
converters.register(RuleBase, RuleBaseConverter)

@dataclass
class Rule1(RuleBase):
    value: str = "default1"

@dataclass
class Rule2(RuleBase):
    value: str = "default2"
    extra: str = "extra"

@datafile("test.yaml", defaults=True)
class RuleSet:
    rules: List[RuleBase]

# Test serialization and deserialization
ruleset = RuleSet(rules=[Rule1(), Rule2()])
print("Serialized RuleSet:", ruleset)

# Save and reload to test deserialization
print("\nDeserialized RuleSet:", *RuleSet.objects.all())

Which produces yaml that looks like this

rules:                                                                                                                    
  - rule_type: Rule1                                                                                                      
    value: default1                                                                                                       
  - rule_type: Rule2                                                                                                      
    value: default2                                                                                                       
    extra: extra 

[traverseda]

Turns out this isn't applying hooks properly. @jacebrowning any help? The hooks subsystem is pretty deep.

[jacebrowning]

Can you narrow down your example at all? I'm not sure what you mean by "applying hooks". How would you like union types to work? Thanks!

[traverseda]

On hooks not being applied

The example code I uploaded does work, and is a minimal example of how I'm doing something like union types in a real code base. The problem with this is that when I edit "extra" on a rule2 instance, it doesn't save the datafile. It doesn't appear to be applying the hooks to extra. The datafile doesn't know when extra is updated, and it doesn't know when to save it.

It does know when rule1 or rule2 value is changed though, since that's part of base class.

---

On union types

How I'd like union types to work is that an objects type gets stored in the serializable data.

- __object_type__: str
  value: bizbazbar
- __object_type__: int
  value: 42

And so on. The datafile would then inspect the list of possible types for that Union to figure out what an str or int was.

[jacebrowning]

I'm not sure but I wonder if the __post_init__ is breaking the hooks. Can you implement your example without that method?

Regardless, your code is not actually using the Union type annotation so, while an interesting idea, is not quite relevant to the original issue.