bshishov / ctor Goto Github PK

from typing import Optional, List
from dataclasses import dataclass

import ctor


@dataclass
class Foo:
    foo: str


@dataclass
class Bar:
    bar: str


@dataclass
class ListsAggregate:
    first: Optional[List[Foo]] = None
    second: Optional[List[Bar]] = None


list_aggregate = ListsAggregate(
    first=[Foo("value")],
    second=[Bar("value")]
)

ctor.dump(list_aggregate)

from typing import Optional, Dict, Any

import ctor


class Foo:

    def __init__(self, foo: Optional[Dict[str, Any]]):
        self.foo = foo


ctor.load(Foo, {"foo": None})

from typing import Dict, Type

import ctor

class Base:
    pass

class A(Base):
    pass


class B(Base):
    pass


my_type_map: Dict[str, Type[Base]] = {
    "a": A,
    "b": B
}


ctor.DiscriminatedConverterFactory(
    my_type_map, ctor.ObjectConverterFactory()
)

import ctor
from dataclasses import dataclass

@dataclass
class A:
    a: str


@dataclass
class B:
    b: int


@dataclass
class Foo:
    item: Union[A, B]


foo = Foo(item=B(1))


print(ctor.dump(foo))

# expected: {'item': {'b': 1}}
# actual: {'item': {}}