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 
 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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
class AttrDict(BaseModel, Mapping):
    """An object whose attributes can also be accessed through
    subscription, like with a dictionary."""

    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 the item is a pydantic field, reset it and remove it from the set of set
        fields. Otherwise, delete the attribute.

        """
        if key in self.__dict__:
            if key in self.__fields__:
                # Reset field to default and remove from set of set fields
                setattr(self, key, self.__fields__[key].default)
                self.__fields_set__.remove(key)  # pylint: disable=no-member
            else:
                self.__delattr__(key)
        else:
            raise KeyError(key)

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

    def __setitem__(self, key: str, value: "Any") -> None:
        """Enable write access through subscription."""
        setattr(self, 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:
        """Implement the != operator."""
        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, Mapping)):
            for key, value in other.items():
                setattr(self, key, value)
        elif other and isinstance(other, BaseModel):
            for key, value in other.dict().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)

    def pop(self, key: str, default: "Optional[Any]" = Undefined) -> "Any":
        """MutableMapping `pop`-method."""
        value = self.get(key, default)
        if value == Undefined:
            raise KeyError(key)
        if key in self:
            del self[key]
        return value

    def popitem(self) -> "Tuple[str, Any]":
        """MutableMapping `popitem`-method.

        Important:
            Unlike the regular `dict.popitem()` method, this one does _not_ respect
            LIFO (last-in, first-out).
            This is due to the fact that attributes are stored in a random order when
            initializing the model.

            However, it will respect LIFO with respect to the internal `__dict__`.

        """
        if not self:
            raise KeyError(f"popitem(): {self.__class__.__name__} is empty")

        key = list(self.__dict__)[-1]
        value = self.pop(key)
        return key, value

    class Config:
        """Pydantic configuration for `AttrDict`.

        * **`extra`**
          Allow any attributes/fields to be defined - this is what makes this pydantic
          model an attribute dictionary.
        * **`validate_assignment`**
          Validate and cast set values.
          This is mainly relevant for sub-classes of `AttrDict`, where specific
          attributes have been defined.
        * **`arbitrary_types_allowed`**
          If a custom type is used for an attribute that doesn't have a `validate()`
          method, don't fail setting the attribute.

        """

        extra = "allow"
        validate_assignment = True
        arbitrary_types_allowed = True

Config

Pydantic configuration for AttrDict.

  • extra Allow any attributes/fields to be defined - this is what makes this pydantic model an attribute dictionary.
  • validate_assignment Validate and cast set values. This is mainly relevant for sub-classes of AttrDict, where specific attributes have been defined.
  • arbitrary_types_allowed If a custom type is used for an attribute that doesn't have a validate() method, don't fail setting the attribute.
Source code in oteapi/models/genericconfig.py 
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
class Config:
    """Pydantic configuration for `AttrDict`.

    * **`extra`**
      Allow any attributes/fields to be defined - this is what makes this pydantic
      model an attribute dictionary.
    * **`validate_assignment`**
      Validate and cast set values.
      This is mainly relevant for sub-classes of `AttrDict`, where specific
      attributes have been defined.
    * **`arbitrary_types_allowed`**
      If a custom type is used for an attribute that doesn't have a `validate()`
      method, don't fail setting the attribute.

    """

    extra = "allow"
    validate_assignment = True
    arbitrary_types_allowed = True

arbitrary_types_allowed = True class-attribute

extra = 'allow' class-attribute

validate_assignment = True class-attribute

get(key, default=None)

Mapping get-method.

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

items()

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

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

keys()

Return a view of all keys.

Source code in oteapi/models/genericconfig.py 
58
59
60
def keys(self):
    """Return a view of all keys."""
    return self.__dict__.keys()

pop(key, default=Undefined)

MutableMapping pop-method.

Source code in oteapi/models/genericconfig.py 
 98
 99
100
101
102
103
104
105
def pop(self, key: str, default: "Optional[Any]" = Undefined) -> "Any":
    """MutableMapping `pop`-method."""
    value = self.get(key, default)
    if value == Undefined:
        raise KeyError(key)
    if key in self:
        del self[key]
    return value

popitem()

MutableMapping popitem-method.

Important

Unlike the regular dict.popitem() method, this one does not respect LIFO (last-in, first-out). This is due to the fact that attributes are stored in a random order when initializing the model.

However, it will respect LIFO with respect to the internal __dict__.

Source code in oteapi/models/genericconfig.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
def popitem(self) -> "Tuple[str, Any]":
    """MutableMapping `popitem`-method.

    Important:
        Unlike the regular `dict.popitem()` method, this one does _not_ respect
        LIFO (last-in, first-out).
        This is due to the fact that attributes are stored in a random order when
        initializing the model.

        However, it will respect LIFO with respect to the internal `__dict__`.

    """
    if not self:
        raise KeyError(f"popitem(): {self.__class__.__name__} is empty")

    key = list(self.__dict__)[-1]
    value = self.pop(key)
    return key, value

update(other=None, **kwargs)

MutableMapping update-method.

Source code in oteapi/models/genericconfig.py 
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
def update(
    self, other: "Optional[Union[dict, AttrDict, Iterable[Any]]]" = None, **kwargs
) -> None:
    """MutableMapping `update`-method."""
    if other and isinstance(other, (dict, Mapping)):
        for key, value in other.items():
            setattr(self, key, value)
    elif other and isinstance(other, BaseModel):
        for key, value in other.dict().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()

Return a view of all values.

Source code in oteapi/models/genericconfig.py 
62
63
64
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 
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
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__

    class Config:
        """Pydantic configuration for `GenericConfig`.

        * **`validate_assignment`**
          Validate and cast set values.
          This is mainly relevant for sub-classes of `AttrDict`, where specific
          attributes have been defined.
        * **`arbitrary_types_allowed`**
          If a custom type is used for an attribute that doesn't have a `validate()`
          method, don't fail setting the attribute.

        """

        validate_assignment = True
        arbitrary_types_allowed = True

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

Config

Pydantic configuration for GenericConfig.

  • validate_assignment Validate and cast set values. This is mainly relevant for sub-classes of AttrDict, where specific attributes have been defined.
  • arbitrary_types_allowed If a custom type is used for an attribute that doesn't have a validate() method, don't fail setting the attribute.
Source code in oteapi/models/genericconfig.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
class Config:
    """Pydantic configuration for `GenericConfig`.

    * **`validate_assignment`**
      Validate and cast set values.
      This is mainly relevant for sub-classes of `AttrDict`, where specific
      attributes have been defined.
    * **`arbitrary_types_allowed`**
      If a custom type is used for an attribute that doesn't have a `validate()`
      method, don't fail setting the attribute.

    """

    validate_assignment = True
    arbitrary_types_allowed = True

arbitrary_types_allowed = True class-attribute

validate_assignment = True class-attribute