adorn.unit.dataclass module

Representation of dataclasses.dataclass

class adorn.unit.dataclass.DataClass

Bases: adorn.unit.unit.Unit

A wrapper around dataclass()

from dataclasses import dataclass

from adorn.orchestrator.base import Base
from adorn.params import Params
from adorn.unit.dataclass import DataClass

class Example(DataClass):
    _registry = dict()

@Example.register()
@dataclass
class A:
    a: int
    b: bool

base = Base([Example()])
assert base.from_obj(A, Params({"a": 1, "b": False})) == A(1, False)

contains(obj, orchestrator)

Check if obj is registered to DataClass

Parameters

obj (Any) – the Type that may be a subclass of Anum
orchestrator (Orchestrator) – container of all types, not used

Returns

if True then obj is represented by Anum,: otherwise False

Return type

bool

from_obj(target_cls, orchestrator, obj)

Convert obj to an instance of the type target_cls

Parameters

target_cls (Type) – the target Type, the given obj will be converted into
orchestrator (Orchestrator) – container of all types, used to instantiate the arguments for the constructor of the given dataclass
obj (Any) – an instance, that will be converted to an instance of target_cls

Returns

an instantiated dataclass()

Return type

_D

get(key, orchestrator)

Return the relevant Anum for the key

Parameters

key (Any) – the Type that may be a subclass of the Unit
orchestrator (Orchestrator) – container of all types, not used

Returns

if key is an Anum then return it,: otherwise None

Return type

Optional[type]

classmethod register()

Add dataclass() to the _registry

Returns

funcion that adds the decorated: dataclass() to the _registry

Return type

Callable[[Type[_D]], Type[_D]]

type_check(target_cls, orchestrator, obj)

Ensure obj can be converted to the type target_cls

Exceptions:

UnRepresentedTypeError:
obj did not map to any of the types contained in the _registry
ParamError:
obj was not of type Params

Parameters

target_cls (Type) – the target Type, the given obj will be checked against
orchestrator (Orchestrator) – container of all types, used to check the arguments of the constructor for the given dataclass
obj (Any) – a Params, that will be checked to see if it can be converted to an instance of target_cls

Returns

if TypeCheckError then there was: an issue which would prevent converting obj to an instance of target_cls, otherwise None

Return type

Optional[TypeCheckError]