Skip to content

genericconfig

Generic data model for configuration attributes.

AttrDict

Bases: BaseModel, Mapping

An object whose attributes can also be accessed through subscription, like with a dictionary.

Source code in oteapi/models/genericconfig.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
class AttrDict(BaseModel, Mapping):
    """An object whose attributes can also be accessed through
    subscription, like with a dictionary."""

    class Config:
        """Class for configuration of pydantic models."""

        extra = "allow"

    def __contains__(self, name: "Any") -> bool:
        """Enable using the 'in' operator on this object."""
        return self.__dict__.__contains__(name)

    def __delitem__(self, key: str) -> None:
        """Enable deletion access through subscription."""
        if key in dir(self):
            self.__delattr__(key)
            if key in self.__fields__:
                del self.__fields__[key]
                self.__fields_set__.remove(key)  # pylint: disable=no-member
        else:
            raise KeyError(key)

    def __getitem__(self, key: str) -> "Any":
        """Enable read access through subscription."""
        if key in dir(self):
            return getattr(self, key)
        raise KeyError(key)

    def __setattr__(self, name: str, value: "Any") -> None:
        """Extend BaseModel.__setattr__ with type-checking."""
        if name in self.__dict__ and self.__dict__[name]:
            target_type = type(self.__dict__[name])
            if not isinstance(value, target_type):
                raise TypeError(
                    "Mapped value must be subclass of " + target_type.__name__
                )
        super().__setattr__(name, value)

    def __setitem__(self, key: str, value: "Any") -> None:
        """Enable write access through subscription."""
        self.__setattr__(key, value)

    def __len__(self):
        """Return number of items."""
        return self.__dict__.__len__()

    def __iter__(self):
        """Enable **unpacking."""
        return self.__dict__.__iter__()

    def items(self):
        """Return a view of all (key, value) pairs."""
        return self.__dict__.items()

    def keys(self):
        """Return a view of all keys."""
        return self.__dict__.keys()

    def values(self):
        """Return a view of all values."""
        return self.__dict__.values()

    def get(self, key: str, default: "Optional[Any]" = None) -> "Any":
        """Mapping `get`-method."""
        return self.__dict__.get(key, default)

    def __ne__(self, other: "Any") -> bool:
        if isinstance(other, BaseModel):
            return self.dict() != other.dict()
        return self.dict() != other

    def update(
        self, other: "Optional[Union[dict, AttrDict, Iterable[Any]]]" = None, **kwargs
    ) -> None:
        """MutableMapping `update`-method."""
        if other and isinstance(other, (dict, self.__class__)):
            for key, value in other.items():
                setattr(self, key, value)
        elif other and isinstance(other, Iterable):
            for entry in other:
                if not len(entry) == 2:
                    raise ValueError(
                        "`other` must be an iterable of objects of length two."
                    )
            for key, value in other:
                setattr(self, key, value)
        if kwargs:
            for key, value in kwargs.items():
                setattr(self, key, value)

Config

Class for configuration of pydantic models.

Source code in oteapi/models/genericconfig.py 
14
15
16
17
class Config:
    """Class for configuration of pydantic models."""

    extra = "allow"

extra = 'allow' class-attribute

__contains__(self, name)

Enable using the 'in' operator on this object.

Source code in oteapi/models/genericconfig.py 
19
20
21
def __contains__(self, name: "Any") -> bool:
    """Enable using the 'in' operator on this object."""
    return self.__dict__.__contains__(name)

__delitem__(self, key)

Enable deletion access through subscription.

Source code in oteapi/models/genericconfig.py 
23
24
25
26
27
28
29
30
31
def __delitem__(self, key: str) -> None:
    """Enable deletion access through subscription."""
    if key in dir(self):
        self.__delattr__(key)
        if key in self.__fields__:
            del self.__fields__[key]
            self.__fields_set__.remove(key)  # pylint: disable=no-member
    else:
        raise KeyError(key)

__getitem__(self, key)

Enable read access through subscription.

Source code in oteapi/models/genericconfig.py 
33
34
35
36
37
def __getitem__(self, key: str) -> "Any":
    """Enable read access through subscription."""
    if key in dir(self):
        return getattr(self, key)
    raise KeyError(key)

__iter__(self)

Enable **unpacking.

Source code in oteapi/models/genericconfig.py 
57
58
59
def __iter__(self):
    """Enable **unpacking."""
    return self.__dict__.__iter__()

__len__(self)

Return number of items.

Source code in oteapi/models/genericconfig.py 
53
54
55
def __len__(self):
    """Return number of items."""
    return self.__dict__.__len__()

__ne__(self, other)

Source code in oteapi/models/genericconfig.py 
77
78
79
80
def __ne__(self, other: "Any") -> bool:
    if isinstance(other, BaseModel):
        return self.dict() != other.dict()
    return self.dict() != other

__setattr__(self, name, value)

Extend BaseModel.setattr with type-checking.

Source code in oteapi/models/genericconfig.py 
39
40
41
42
43
44
45
46
47
def __setattr__(self, name: str, value: "Any") -> None:
    """Extend BaseModel.__setattr__ with type-checking."""
    if name in self.__dict__ and self.__dict__[name]:
        target_type = type(self.__dict__[name])
        if not isinstance(value, target_type):
            raise TypeError(
                "Mapped value must be subclass of " + target_type.__name__
            )
    super().__setattr__(name, value)

__setitem__(self, key, value)

Enable write access through subscription.

Source code in oteapi/models/genericconfig.py 
49
50
51
def __setitem__(self, key: str, value: "Any") -> None:
    """Enable write access through subscription."""
    self.__setattr__(key, value)

get(self, key, default=None)

Mapping get-method.

Source code in oteapi/models/genericconfig.py 
73
74
75
def get(self, key: str, default: "Optional[Any]" = None) -> "Any":
    """Mapping `get`-method."""
    return self.__dict__.get(key, default)

items(self)

Return a view of all (key, value) pairs.

Source code in oteapi/models/genericconfig.py 
61
62
63
def items(self):
    """Return a view of all (key, value) pairs."""
    return self.__dict__.items()

keys(self)

Return a view of all keys.

Source code in oteapi/models/genericconfig.py 
65
66
67
def keys(self):
    """Return a view of all keys."""
    return self.__dict__.keys()

update(self, other=None, **kwargs)

MutableMapping update-method.

Source code in oteapi/models/genericconfig.py 
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def update(
    self, other: "Optional[Union[dict, AttrDict, Iterable[Any]]]" = None, **kwargs
) -> None:
    """MutableMapping `update`-method."""
    if other and isinstance(other, (dict, self.__class__)):
        for key, value in other.items():
            setattr(self, key, value)
    elif other and isinstance(other, Iterable):
        for entry in other:
            if not len(entry) == 2:
                raise ValueError(
                    "`other` must be an iterable of objects of length two."
                )
        for key, value in other:
            setattr(self, key, value)
    if kwargs:
        for key, value in kwargs.items():
            setattr(self, key, value)

values(self)

Return a view of all values.

Source code in oteapi/models/genericconfig.py 
69
70
71
def values(self):
    """Return a view of all values."""
    return self.__dict__.values()

GenericConfig

Bases: BaseModel

Generic class for configuration objects.

Source code in oteapi/models/genericconfig.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
class GenericConfig(BaseModel):
    """Generic class for configuration objects."""

    configuration: AttrDict = Field(
        AttrDict(),
        description="Model-specific configuration options which can either "
        "be given as key/value-pairs or set as attributes.",
    )

    description: str = Field(
        __doc__,
        description="A description of the configuration model.",
    )

    @classmethod
    def __init_subclass__(cls) -> None:
        """Initialize subclass descriptions with their docstrings."""
        cls.__fields__["description"].default = cls.__doc__

configuration: AttrDict = Field(AttrDict(), description='Model-specific configuration options which can either be given as key/value-pairs or set as attributes.') class-attribute

description: str = Field(__doc__, description='A description of the configuration model.') class-attribute

__init_subclass__(cls)

Initialize subclass descriptions with their docstrings.

Source code in oteapi/models/genericconfig.py 
116
117
118
119
@classmethod
def __init_subclass__(cls) -> None:
    """Initialize subclass descriptions with their docstrings."""
    cls.__fields__["description"].default = cls.__doc__
Back to top