cengal.code_flow_control.smart_values.versions.v_2.smart_values 

  1#!/usr/bin/env python
  2# coding=utf-8
  3
  4# Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>
  5# 
  6# Licensed under the Apache License, Version 2.0 (the "License");
  7# you may not use this file except in compliance with the License.
  8# You may obtain a copy of the License at
  9# 
 10#     http://www.apache.org/licenses/LICENSE-2.0
 11# 
 12# Unless required by applicable law or agreed to in writing, software
 13# distributed under the License is distributed on an "AS IS" BASIS,
 14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15# See the License for the specific language governing permissions and
 16# limitations under the License.
 17
 18__all__ = [
 19        'ValueExistenceNamedTuple',
 20        'ValueExistence',
 21        'ValueHolder',
 22        'ResultExistence',
 23        'ResultHolder',
 24        'ErrorExistence',
 25        'ErrorHolder',
 26        'ValueCache',
 27        'ValueTypeNamedTuple',
 28        'ValueType',
 29        'ValueWithTypeNamedTuple',
 30        'ValueWithType',
 31    ]
 32
 33
 34from cengal.introspection.inspect import entity_module_importable_str_and_owning_names_path, entity_by_name_module_importable_str_and_owning_names_path
 35from collections import namedtuple
 36from collections.abc import Sequence
 37from typing import Any, TypeVar, Generic, Tuple, NamedTuple, Union, Optional
 38
 39"""
 40Module Docstring
 41Docstrings: http://www.python.org/dev/peps/pep-0257/
 42"""
 43
 44__author__ = "ButenkoMS <gtalk@butenkoms.space>"
 45__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>"
 46__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ]
 47__license__ = "Apache License, Version 2.0"
 48__version__ = "4.4.1"
 49__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>"
 50__email__ = "gtalk@butenkoms.space"
 51# __status__ = "Prototype"
 52__status__ = "Development"
 53# __status__ = "Production"
 54
 55
 56# TODO: implement Cython version (smart_values are used by our Cython code)
 57
 58
 59VT = TypeVar('VT')
 60
 61
 62ValueExistenceNamedTuple = namedtuple('ValueExistenceNamedTuple', ['existence', 'value'])
 63
 64
 65class ValueExistence(Generic[VT], Sequence):
 66    __slots__ = ('existence', '_value')
 67
 68    def __init__(self, existence: bool = False, value: VT = None):
 69        self.existence: bool = existence
 70        self._value: VT = value
 71
 72    def __len__(self):
 73        return 2
 74
 75    def __getitem__(self, index):
 76        if 0 == index:
 77            return self.existence
 78        elif 1 == index:
 79            return self._value
 80        else:
 81            raise IndexError
 82    
 83    @property
 84    def value(self):
 85        return self._value
 86    
 87    @value.setter
 88    def value(self, value):
 89        self.existence = True
 90        self._value = value
 91
 92    def __bool__(self):
 93        return self.existence
 94
 95    def __nonzero__(self):
 96        return self.__bool__()
 97
 98    def __str__(self):
 99        return f'{type(self).__name__}({repr(self.existence)}, {repr(self.value)})'
100
101    def __repr__(self):
102        return self.__str__()
103
104    def __getstate__(self):
105        return self.existence, self.value
106
107    def __setstate__(self, state):
108        existence, value = state
109        self.value = value
110        self.existence = existence
111    
112    def __eq__(self, __value: object) -> bool:
113        if isinstance(__value, ValueExistence):
114            return (self.existence == __value.existence) and (self.value == __value.value)
115        else:
116            if self.existence:
117                return self.value == __value
118            else:
119                return False
120    
121    def __ne__(self, __value: object) -> bool:
122        return not self.__eq__(__value)
123    
124    def to_namedtuple(self) -> ValueExistenceNamedTuple:
125        return ValueExistenceNamedTuple(self.existence, self.value)
126    
127    def to_tuple(self) -> Tuple:
128        return self.existence, self.value
129    
130    def to_dict(self) -> dict:
131        return {
132            'existence': self.existence,
133            'value': self.value,
134        }
135    
136    def serialize_to_dict(self) -> Tuple[dict, dict]:
137        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
138        return {
139            'existence': self.existence,
140            'value': self.value,
141        }, {
142            'class_name': self.__class__,
143            'module_importable_str': module_importable_str,
144            'owning_names_path': owning_names_path,
145        }
146    
147    @classmethod
148    def from_namedtuple(cls, named_tuple: ValueExistenceNamedTuple) -> 'ValueExistence':
149        return cls(named_tuple.existence, named_tuple.value)
150    
151    @classmethod
152    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
153        return cls(*tuple_)
154    
155    @classmethod
156    def from_dict(cls, dict_: dict) -> 'ValueExistence':
157        return cls(dict_['existence'], dict_['value'])
158    
159    @classmethod
160    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
161        if owning_info is None:
162            return cls(dict_['existence'], dict_['value'])
163        else:
164            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
165            return class_type(dict_['existence'], dict_['value'])
166    
167    @classmethod
168    def from_other(cls, value: Union['ValueExistence', ValueExistenceNamedTuple, Tuple, VT]) -> 'ValueExistence':
169        if isinstance(value, ValueExistence):
170            return cls(value.existence, value.value)
171        elif isinstance(value, ValueExistenceNamedTuple):
172            return cls.from_namedtuple(value)
173        elif isinstance(value, tuple):
174            return cls.from_tuple(value)
175        elif isinstance(value, dict):
176            return cls.from_dict(value)
177        else:
178            try:
179                return cls(value.existence, value.value)
180            except AttributeError:
181                return cls(True, value)
182
183
184class ValueHolder(ValueExistence[VT]):
185    def __init__(self, existence: bool = False, value: VT = None):
186        super().__init__(existence, value)
187
188
189class ResultExistence(ValueExistence[VT]):
190    def __init__(self, existence: bool = False, value: VT = None):
191        super().__init__(existence, value)
192
193
194class ResultHolder(ValueExistence[VT]):
195    def __init__(self, existence: bool = False, value: VT = None):
196        super().__init__(existence, value)
197
198
199class ErrorExistence(ValueExistence[VT]):
200    def __init__(self, existence: bool = False, value: VT = None):
201        super().__init__(existence, value)
202
203
204class ErrorHolder(ValueExistence[VT]):
205    def __init__(self, existence: bool = False, value: VT = None):
206        super().__init__(existence, value)
207
208
209class ValueCache(ValueExistence[VT]):
210    __slots__ = tuple()
211
212    def __init__(self, existence: bool = False, value: VT = None):
213        super(ValueCache, self).__init__(existence, value)
214
215    def __call__(self, *args, **kwargs):
216        self.existence = False
217
218    def get(self) -> VT:
219        return self.value
220
221    def set(self, new_value: VT):
222        self.existence = True
223        self.value = new_value
224
225    def reset(self):
226        self.existence = False
227
228    def __getstate__(self):
229        return self.existence, self.value
230
231    def __setstate__(self, state):
232        existence, value = state
233        self.value = value
234        self.existence = existence
235    
236    def __eq__(self, __value: object) -> bool:
237        if isinstance(__value, ValueExistence):
238            return (self.existence == __value.existence) and (self.value == __value.value)
239        else:
240            if self.existence:
241                return self.value == __value
242            else:
243                return False
244    
245    def __ne__(self, __value: object) -> bool:
246        return not self.__eq__(__value)
247
248
249TT = TypeVar('TT')
250
251
252ValueTypeNamedTuple = namedtuple('ValueTypeNamedTuple', ['type_id', 'value'])
253
254
255class ValueType(Generic[TT, VT], Sequence):
256    __slots__ = ('type_id', 'value')
257
258    def __init__(self, type_id: TT, value: VT):
259        self.type_id: TT = type_id
260        self.value: VT = value
261
262    def __len__(self):
263        return 2
264
265    def __getitem__(self, index):
266        if 0 == index:
267            return self.type_id
268        elif 1 == index:
269            return self.value
270        else:
271            raise IndexError
272
273    def __eq__(self, other):
274        # "__ne__() delegates to __eq__() and inverts the value"
275        if isinstance(other, (ValueType, ValueWithType)):
276            return self.type_id == other.type_id
277        else:
278            return self.type_id == other
279
280    def __getstate__(self):
281        return self.type_id, self.value
282
283    def __setstate__(self, state):
284        self.type_id, self.value = state
285
286    def __str__(self):
287        return f'{type(self).__name__}({repr(self.type_id)}, {repr(self.value)})'
288
289    def __repr__(self):
290        return self.__str__()
291    
292    def to_namedtuple(self) -> ValueTypeNamedTuple:
293        return ValueTypeNamedTuple(self.type_id, self.value)
294    
295    def to_tuple(self) -> Tuple:
296        return self.type_id, self.value
297    
298    def to_dict(self) -> dict:
299        return {
300            'type_id': self.type_id,
301            'value': self.value,
302        }
303    
304    def serialize_to_dict(self) -> Tuple[dict, dict]:
305        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
306        return {
307            'type_id': self.type_id,
308            'value': self.value,
309        }, {
310            'class_name': self.__class__,
311            'module_importable_str': module_importable_str,
312            'owning_names_path': owning_names_path,
313        }
314    
315    @classmethod
316    def from_namedtuple(cls, named_tuple: ValueTypeNamedTuple) -> 'ValueExistence':
317        return cls(named_tuple.type_id, named_tuple.value)
318    
319    @classmethod
320    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
321        return cls(*tuple_)
322    
323    @classmethod
324    def from_dict(cls, dict_: dict) -> 'ValueExistence':
325        return cls(dict_['type_id'], dict_['value'])
326    
327    @classmethod
328    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
329        if owning_info is None:
330            return cls(dict_['type_id'], dict_['value'])
331        else:
332            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
333            return class_type(dict_['type_id'], dict_['value'])
334    
335    @classmethod
336    def from_other(cls, value: Union['ValueExistence', ValueTypeNamedTuple, Tuple, VT]) -> 'ValueExistence':
337        if isinstance(value, ValueExistence):
338            return cls(value.type_id, value.value)
339        elif isinstance(value, ValueTypeNamedTuple):
340            return cls.from_namedtuple(value)
341        elif isinstance(value, tuple):
342            return cls.from_tuple(value)
343        elif isinstance(value, dict):
344            return cls.from_dict(value)
345        else:
346            try:
347                return cls(value.type_id, value.value)
348            except AttributeError:
349                return cls(None, value)
350
351
352ValueWithTypeNamedTuple = namedtuple('ValueWithTypeNamedTuple', ['type_id', 'value'])
353
354
355class ValueWithType(Generic[TT, VT], Sequence):
356    __slots__ = ('type_id', 'value')
357
358    def __init__(self, type_id: TT, value: VT):
359        self.type_id: TT = type_id
360        self.value: VT = value
361
362    def __len__(self):
363        return 2
364
365    def __getitem__(self, index):
366        if 0 == index:
367            return self.type_id
368        elif 1 == index:
369            return self.value
370        else:
371            raise IndexError
372
373    def __eq__(self, other):
374        # "__ne__() delegates to __eq__() and inverts the value"
375        if isinstance(other, ValueType):
376            return self.type_id == other.type_id
377        elif isinstance(other, ValueWithType):
378            return (self.type_id == other.type_id) and (self.value == other.value)
379        else:
380            return self.value == other
381
382    def __getstate__(self):
383        return self.type_id, self.value
384
385    def __setstate__(self, state):
386        self.type_id, self.value = state
387
388    def __str__(self):
389        return f'{type(self).__name__}({repr(self.type_id)}, {repr(self.value)})'
390
391    def __repr__(self):
392        return self.__str__()
393    
394    def to_namedtuple(self) -> ValueWithTypeNamedTuple:
395        return ValueWithTypeNamedTuple(self.type_id, self.value)
396    
397    def to_tuple(self) -> Tuple:
398        return self.type_id, self.value
399    
400    def to_dict(self) -> dict:
401        return {
402            'type_id': self.type_id,
403            'value': self.value,
404        }
405    
406    def serialize_to_dict(self) -> Tuple[dict, dict]:
407        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
408        return {
409            'type_id': self.type_id,
410            'value': self.value,
411        }, {
412            'class_name': self.__class__,
413            'module_importable_str': module_importable_str,
414            'owning_names_path': owning_names_path,
415        }
416    
417    @classmethod
418    def from_namedtuple(cls, named_tuple: ValueWithTypeNamedTuple) -> 'ValueExistence':
419        return cls(named_tuple.type_id, named_tuple.value)
420    
421    @classmethod
422    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
423        return cls(*tuple_)
424    
425    @classmethod
426    def from_dict(cls, dict_: dict) -> 'ValueExistence':
427        return cls(dict_['type_id'], dict_['value'])
428    
429    @classmethod
430    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
431        if owning_info is None:
432            return cls(dict_['type_id'], dict_['value'])
433        else:
434            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
435            return class_type(dict_['type_id'], dict_['value'])
436    
437    @classmethod
438    def from_other(cls, value: Union['ValueExistence', ValueWithTypeNamedTuple, Tuple, VT]) -> 'ValueExistence':
439        if isinstance(value, ValueExistence):
440            return cls(value.type_id, value.value)
441        elif isinstance(value, ValueWithTypeNamedTuple):
442            return cls.from_namedtuple(value)
443        elif isinstance(value, tuple):
444            return cls.from_tuple(value)
445        elif isinstance(value, dict):
446            return cls.from_dict(value)
447        else:
448            try:
449                return cls(value.type_id, value.value)
450            except AttributeError:
451                return cls(None, value)
class ValueExistenceNamedTuple(builtins.tuple):

ValueExistenceNamedTuple(existence, value)

ValueExistenceNamedTuple(existence, value)

Create new instance of ValueExistenceNamedTuple(existence, value)

existence

Alias for field number 0

value

Alias for field number 1

Inherited Members
builtins.tuple
index
count
class ValueExistence(typing.Generic[~VT], collections.abc.Sequence): 
 66class ValueExistence(Generic[VT], Sequence):
 67    __slots__ = ('existence', '_value')
 68
 69    def __init__(self, existence: bool = False, value: VT = None):
 70        self.existence: bool = existence
 71        self._value: VT = value
 72
 73    def __len__(self):
 74        return 2
 75
 76    def __getitem__(self, index):
 77        if 0 == index:
 78            return self.existence
 79        elif 1 == index:
 80            return self._value
 81        else:
 82            raise IndexError
 83    
 84    @property
 85    def value(self):
 86        return self._value
 87    
 88    @value.setter
 89    def value(self, value):
 90        self.existence = True
 91        self._value = value
 92
 93    def __bool__(self):
 94        return self.existence
 95
 96    def __nonzero__(self):
 97        return self.__bool__()
 98
 99    def __str__(self):
100        return f'{type(self).__name__}({repr(self.existence)}, {repr(self.value)})'
101
102    def __repr__(self):
103        return self.__str__()
104
105    def __getstate__(self):
106        return self.existence, self.value
107
108    def __setstate__(self, state):
109        existence, value = state
110        self.value = value
111        self.existence = existence
112    
113    def __eq__(self, __value: object) -> bool:
114        if isinstance(__value, ValueExistence):
115            return (self.existence == __value.existence) and (self.value == __value.value)
116        else:
117            if self.existence:
118                return self.value == __value
119            else:
120                return False
121    
122    def __ne__(self, __value: object) -> bool:
123        return not self.__eq__(__value)
124    
125    def to_namedtuple(self) -> ValueExistenceNamedTuple:
126        return ValueExistenceNamedTuple(self.existence, self.value)
127    
128    def to_tuple(self) -> Tuple:
129        return self.existence, self.value
130    
131    def to_dict(self) -> dict:
132        return {
133            'existence': self.existence,
134            'value': self.value,
135        }
136    
137    def serialize_to_dict(self) -> Tuple[dict, dict]:
138        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
139        return {
140            'existence': self.existence,
141            'value': self.value,
142        }, {
143            'class_name': self.__class__,
144            'module_importable_str': module_importable_str,
145            'owning_names_path': owning_names_path,
146        }
147    
148    @classmethod
149    def from_namedtuple(cls, named_tuple: ValueExistenceNamedTuple) -> 'ValueExistence':
150        return cls(named_tuple.existence, named_tuple.value)
151    
152    @classmethod
153    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
154        return cls(*tuple_)
155    
156    @classmethod
157    def from_dict(cls, dict_: dict) -> 'ValueExistence':
158        return cls(dict_['existence'], dict_['value'])
159    
160    @classmethod
161    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
162        if owning_info is None:
163            return cls(dict_['existence'], dict_['value'])
164        else:
165            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
166            return class_type(dict_['existence'], dict_['value'])
167    
168    @classmethod
169    def from_other(cls, value: Union['ValueExistence', ValueExistenceNamedTuple, Tuple, VT]) -> 'ValueExistence':
170        if isinstance(value, ValueExistence):
171            return cls(value.existence, value.value)
172        elif isinstance(value, ValueExistenceNamedTuple):
173            return cls.from_namedtuple(value)
174        elif isinstance(value, tuple):
175            return cls.from_tuple(value)
176        elif isinstance(value, dict):
177            return cls.from_dict(value)
178        else:
179            try:
180                return cls(value.existence, value.value)
181            except AttributeError:
182                return cls(True, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ValueExistence(existence: bool = False, value: ~VT = None) 
69    def __init__(self, existence: bool = False, value: VT = None):
70        self.existence: bool = existence
71        self._value: VT = value
existence: bool
value 
84    @property
85    def value(self):
86        return self._value
def to_namedtuple( self) -> ValueExistenceNamedTuple: 
125    def to_namedtuple(self) -> ValueExistenceNamedTuple:
126        return ValueExistenceNamedTuple(self.existence, self.value)
def to_tuple(self) -> Tuple: 
128    def to_tuple(self) -> Tuple:
129        return self.existence, self.value
def to_dict(self) -> dict: 
131    def to_dict(self) -> dict:
132        return {
133            'existence': self.existence,
134            'value': self.value,
135        }
def serialize_to_dict(self) -> Tuple[dict, dict]: 
137    def serialize_to_dict(self) -> Tuple[dict, dict]:
138        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
139        return {
140            'existence': self.existence,
141            'value': self.value,
142        }, {
143            'class_name': self.__class__,
144            'module_importable_str': module_importable_str,
145            'owning_names_path': owning_names_path,
146        }
@classmethod
def from_namedtuple( cls, named_tuple: ValueExistenceNamedTuple) -> ValueExistence: 
148    @classmethod
149    def from_namedtuple(cls, named_tuple: ValueExistenceNamedTuple) -> 'ValueExistence':
150        return cls(named_tuple.existence, named_tuple.value)
@classmethod
def from_tuple( cls, tuple_: Tuple) -> ValueExistence: 
152    @classmethod
153    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
154        return cls(*tuple_)
@classmethod
def from_dict( cls, dict_: dict) -> ValueExistence: 
156    @classmethod
157    def from_dict(cls, dict_: dict) -> 'ValueExistence':
158        return cls(dict_['existence'], dict_['value'])
@classmethod
def deserialize_from_dict( cls, dict_: dict, owning_info: Union[str, NoneType] = None) -> ValueExistence: 
160    @classmethod
161    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
162        if owning_info is None:
163            return cls(dict_['existence'], dict_['value'])
164        else:
165            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
166            return class_type(dict_['existence'], dict_['value'])
@classmethod
def from_other( cls, value: Union[ValueExistence, ValueExistenceNamedTuple, Tuple, ~VT]) -> ValueExistence: 
168    @classmethod
169    def from_other(cls, value: Union['ValueExistence', ValueExistenceNamedTuple, Tuple, VT]) -> 'ValueExistence':
170        if isinstance(value, ValueExistence):
171            return cls(value.existence, value.value)
172        elif isinstance(value, ValueExistenceNamedTuple):
173            return cls.from_namedtuple(value)
174        elif isinstance(value, tuple):
175            return cls.from_tuple(value)
176        elif isinstance(value, dict):
177            return cls.from_dict(value)
178        else:
179            try:
180                return cls(value.existence, value.value)
181            except AttributeError:
182                return cls(True, value)
Inherited Members
collections.abc.Sequence
index
count
class ValueHolder(cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence[~VT]): 
185class ValueHolder(ValueExistence[VT]):
186    def __init__(self, existence: bool = False, value: VT = None):
187        super().__init__(existence, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ValueHolder(existence: bool = False, value: ~VT = None) 
186    def __init__(self, existence: bool = False, value: VT = None):
187        super().__init__(existence, value)
Inherited Members
collections.abc.Sequence
index
count
class ResultExistence(cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence[~VT]): 
190class ResultExistence(ValueExistence[VT]):
191    def __init__(self, existence: bool = False, value: VT = None):
192        super().__init__(existence, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ResultExistence(existence: bool = False, value: ~VT = None) 
191    def __init__(self, existence: bool = False, value: VT = None):
192        super().__init__(existence, value)
Inherited Members
collections.abc.Sequence
index
count
class ResultHolder(cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence[~VT]): 
195class ResultHolder(ValueExistence[VT]):
196    def __init__(self, existence: bool = False, value: VT = None):
197        super().__init__(existence, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ResultHolder(existence: bool = False, value: ~VT = None) 
196    def __init__(self, existence: bool = False, value: VT = None):
197        super().__init__(existence, value)
Inherited Members
collections.abc.Sequence
index
count
class ErrorExistence(cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence[~VT]): 
200class ErrorExistence(ValueExistence[VT]):
201    def __init__(self, existence: bool = False, value: VT = None):
202        super().__init__(existence, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ErrorExistence(existence: bool = False, value: ~VT = None) 
201    def __init__(self, existence: bool = False, value: VT = None):
202        super().__init__(existence, value)
Inherited Members
collections.abc.Sequence
index
count
class ErrorHolder(cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence[~VT]): 
205class ErrorHolder(ValueExistence[VT]):
206    def __init__(self, existence: bool = False, value: VT = None):
207        super().__init__(existence, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ErrorHolder(existence: bool = False, value: ~VT = None) 
206    def __init__(self, existence: bool = False, value: VT = None):
207        super().__init__(existence, value)
Inherited Members
collections.abc.Sequence
index
count
class ValueCache(cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence[~VT]): 
210class ValueCache(ValueExistence[VT]):
211    __slots__ = tuple()
212
213    def __init__(self, existence: bool = False, value: VT = None):
214        super(ValueCache, self).__init__(existence, value)
215
216    def __call__(self, *args, **kwargs):
217        self.existence = False
218
219    def get(self) -> VT:
220        return self.value
221
222    def set(self, new_value: VT):
223        self.existence = True
224        self.value = new_value
225
226    def reset(self):
227        self.existence = False
228
229    def __getstate__(self):
230        return self.existence, self.value
231
232    def __setstate__(self, state):
233        existence, value = state
234        self.value = value
235        self.existence = existence
236    
237    def __eq__(self, __value: object) -> bool:
238        if isinstance(__value, ValueExistence):
239            return (self.existence == __value.existence) and (self.value == __value.value)
240        else:
241            if self.existence:
242                return self.value == __value
243            else:
244                return False
245    
246    def __ne__(self, __value: object) -> bool:
247        return not self.__eq__(__value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ValueCache(existence: bool = False, value: ~VT = None) 
213    def __init__(self, existence: bool = False, value: VT = None):
214        super(ValueCache, self).__init__(existence, value)
def get(self) -> ~VT: 
219    def get(self) -> VT:
220        return self.value
def set(self, new_value: ~VT): 
222    def set(self, new_value: VT):
223        self.existence = True
224        self.value = new_value
def reset(self): 
226    def reset(self):
227        self.existence = False
Inherited Members
collections.abc.Sequence
index
count
class ValueTypeNamedTuple(builtins.tuple):

ValueTypeNamedTuple(type_id, value)

ValueTypeNamedTuple(type_id, value)

Create new instance of ValueTypeNamedTuple(type_id, value)

type_id

Alias for field number 0

value

Alias for field number 1

Inherited Members
builtins.tuple
index
count
class ValueType(typing.Generic[~TT, ~VT], collections.abc.Sequence): 
256class ValueType(Generic[TT, VT], Sequence):
257    __slots__ = ('type_id', 'value')
258
259    def __init__(self, type_id: TT, value: VT):
260        self.type_id: TT = type_id
261        self.value: VT = value
262
263    def __len__(self):
264        return 2
265
266    def __getitem__(self, index):
267        if 0 == index:
268            return self.type_id
269        elif 1 == index:
270            return self.value
271        else:
272            raise IndexError
273
274    def __eq__(self, other):
275        # "__ne__() delegates to __eq__() and inverts the value"
276        if isinstance(other, (ValueType, ValueWithType)):
277            return self.type_id == other.type_id
278        else:
279            return self.type_id == other
280
281    def __getstate__(self):
282        return self.type_id, self.value
283
284    def __setstate__(self, state):
285        self.type_id, self.value = state
286
287    def __str__(self):
288        return f'{type(self).__name__}({repr(self.type_id)}, {repr(self.value)})'
289
290    def __repr__(self):
291        return self.__str__()
292    
293    def to_namedtuple(self) -> ValueTypeNamedTuple:
294        return ValueTypeNamedTuple(self.type_id, self.value)
295    
296    def to_tuple(self) -> Tuple:
297        return self.type_id, self.value
298    
299    def to_dict(self) -> dict:
300        return {
301            'type_id': self.type_id,
302            'value': self.value,
303        }
304    
305    def serialize_to_dict(self) -> Tuple[dict, dict]:
306        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
307        return {
308            'type_id': self.type_id,
309            'value': self.value,
310        }, {
311            'class_name': self.__class__,
312            'module_importable_str': module_importable_str,
313            'owning_names_path': owning_names_path,
314        }
315    
316    @classmethod
317    def from_namedtuple(cls, named_tuple: ValueTypeNamedTuple) -> 'ValueExistence':
318        return cls(named_tuple.type_id, named_tuple.value)
319    
320    @classmethod
321    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
322        return cls(*tuple_)
323    
324    @classmethod
325    def from_dict(cls, dict_: dict) -> 'ValueExistence':
326        return cls(dict_['type_id'], dict_['value'])
327    
328    @classmethod
329    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
330        if owning_info is None:
331            return cls(dict_['type_id'], dict_['value'])
332        else:
333            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
334            return class_type(dict_['type_id'], dict_['value'])
335    
336    @classmethod
337    def from_other(cls, value: Union['ValueExistence', ValueTypeNamedTuple, Tuple, VT]) -> 'ValueExistence':
338        if isinstance(value, ValueExistence):
339            return cls(value.type_id, value.value)
340        elif isinstance(value, ValueTypeNamedTuple):
341            return cls.from_namedtuple(value)
342        elif isinstance(value, tuple):
343            return cls.from_tuple(value)
344        elif isinstance(value, dict):
345            return cls.from_dict(value)
346        else:
347            try:
348                return cls(value.type_id, value.value)
349            except AttributeError:
350                return cls(None, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ValueType(type_id: ~TT, value: ~VT) 
259    def __init__(self, type_id: TT, value: VT):
260        self.type_id: TT = type_id
261        self.value: VT = value
type_id: ~TT
value: ~VT
def to_namedtuple( self) -> ValueTypeNamedTuple: 
293    def to_namedtuple(self) -> ValueTypeNamedTuple:
294        return ValueTypeNamedTuple(self.type_id, self.value)
def to_tuple(self) -> Tuple: 
296    def to_tuple(self) -> Tuple:
297        return self.type_id, self.value
def to_dict(self) -> dict: 
299    def to_dict(self) -> dict:
300        return {
301            'type_id': self.type_id,
302            'value': self.value,
303        }
def serialize_to_dict(self) -> Tuple[dict, dict]: 
305    def serialize_to_dict(self) -> Tuple[dict, dict]:
306        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
307        return {
308            'type_id': self.type_id,
309            'value': self.value,
310        }, {
311            'class_name': self.__class__,
312            'module_importable_str': module_importable_str,
313            'owning_names_path': owning_names_path,
314        }
@classmethod
def from_namedtuple( cls, named_tuple: ValueTypeNamedTuple) -> ValueExistence: 
316    @classmethod
317    def from_namedtuple(cls, named_tuple: ValueTypeNamedTuple) -> 'ValueExistence':
318        return cls(named_tuple.type_id, named_tuple.value)
@classmethod
def from_tuple( cls, tuple_: Tuple) -> ValueExistence: 
320    @classmethod
321    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
322        return cls(*tuple_)
@classmethod
def from_dict( cls, dict_: dict) -> ValueExistence: 
324    @classmethod
325    def from_dict(cls, dict_: dict) -> 'ValueExistence':
326        return cls(dict_['type_id'], dict_['value'])
@classmethod
def deserialize_from_dict( cls, dict_: dict, owning_info: Union[str, NoneType] = None) -> ValueExistence: 
328    @classmethod
329    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
330        if owning_info is None:
331            return cls(dict_['type_id'], dict_['value'])
332        else:
333            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
334            return class_type(dict_['type_id'], dict_['value'])
@classmethod
def from_other( cls, value: Union[ValueExistence, ValueTypeNamedTuple, Tuple, ~VT]) -> ValueExistence: 
336    @classmethod
337    def from_other(cls, value: Union['ValueExistence', ValueTypeNamedTuple, Tuple, VT]) -> 'ValueExistence':
338        if isinstance(value, ValueExistence):
339            return cls(value.type_id, value.value)
340        elif isinstance(value, ValueTypeNamedTuple):
341            return cls.from_namedtuple(value)
342        elif isinstance(value, tuple):
343            return cls.from_tuple(value)
344        elif isinstance(value, dict):
345            return cls.from_dict(value)
346        else:
347            try:
348                return cls(value.type_id, value.value)
349            except AttributeError:
350                return cls(None, value)
Inherited Members
collections.abc.Sequence
index
count
class ValueWithTypeNamedTuple(builtins.tuple):

ValueWithTypeNamedTuple(type_id, value)

ValueWithTypeNamedTuple(type_id, value)

Create new instance of ValueWithTypeNamedTuple(type_id, value)

type_id

Alias for field number 0

value

Alias for field number 1

Inherited Members
builtins.tuple
index
count
class ValueWithType(typing.Generic[~TT, ~VT], collections.abc.Sequence): 
356class ValueWithType(Generic[TT, VT], Sequence):
357    __slots__ = ('type_id', 'value')
358
359    def __init__(self, type_id: TT, value: VT):
360        self.type_id: TT = type_id
361        self.value: VT = value
362
363    def __len__(self):
364        return 2
365
366    def __getitem__(self, index):
367        if 0 == index:
368            return self.type_id
369        elif 1 == index:
370            return self.value
371        else:
372            raise IndexError
373
374    def __eq__(self, other):
375        # "__ne__() delegates to __eq__() and inverts the value"
376        if isinstance(other, ValueType):
377            return self.type_id == other.type_id
378        elif isinstance(other, ValueWithType):
379            return (self.type_id == other.type_id) and (self.value == other.value)
380        else:
381            return self.value == other
382
383    def __getstate__(self):
384        return self.type_id, self.value
385
386    def __setstate__(self, state):
387        self.type_id, self.value = state
388
389    def __str__(self):
390        return f'{type(self).__name__}({repr(self.type_id)}, {repr(self.value)})'
391
392    def __repr__(self):
393        return self.__str__()
394    
395    def to_namedtuple(self) -> ValueWithTypeNamedTuple:
396        return ValueWithTypeNamedTuple(self.type_id, self.value)
397    
398    def to_tuple(self) -> Tuple:
399        return self.type_id, self.value
400    
401    def to_dict(self) -> dict:
402        return {
403            'type_id': self.type_id,
404            'value': self.value,
405        }
406    
407    def serialize_to_dict(self) -> Tuple[dict, dict]:
408        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
409        return {
410            'type_id': self.type_id,
411            'value': self.value,
412        }, {
413            'class_name': self.__class__,
414            'module_importable_str': module_importable_str,
415            'owning_names_path': owning_names_path,
416        }
417    
418    @classmethod
419    def from_namedtuple(cls, named_tuple: ValueWithTypeNamedTuple) -> 'ValueExistence':
420        return cls(named_tuple.type_id, named_tuple.value)
421    
422    @classmethod
423    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
424        return cls(*tuple_)
425    
426    @classmethod
427    def from_dict(cls, dict_: dict) -> 'ValueExistence':
428        return cls(dict_['type_id'], dict_['value'])
429    
430    @classmethod
431    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
432        if owning_info is None:
433            return cls(dict_['type_id'], dict_['value'])
434        else:
435            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
436            return class_type(dict_['type_id'], dict_['value'])
437    
438    @classmethod
439    def from_other(cls, value: Union['ValueExistence', ValueWithTypeNamedTuple, Tuple, VT]) -> 'ValueExistence':
440        if isinstance(value, ValueExistence):
441            return cls(value.type_id, value.value)
442        elif isinstance(value, ValueWithTypeNamedTuple):
443            return cls.from_namedtuple(value)
444        elif isinstance(value, tuple):
445            return cls.from_tuple(value)
446        elif isinstance(value, dict):
447            return cls.from_dict(value)
448        else:
449            try:
450                return cls(value.type_id, value.value)
451            except AttributeError:
452                return cls(None, value)

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as::

class Mapping(Generic[KT, VT]): def __getitem__(self, key: KT) -> VT: ... # Etc.

This class can then be used as follows::

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: try: return mapping[key] except KeyError: return default

ValueWithType(type_id: ~TT, value: ~VT) 
359    def __init__(self, type_id: TT, value: VT):
360        self.type_id: TT = type_id
361        self.value: VT = value
type_id: ~TT
value: ~VT
def to_namedtuple( self) -> ValueWithTypeNamedTuple: 
395    def to_namedtuple(self) -> ValueWithTypeNamedTuple:
396        return ValueWithTypeNamedTuple(self.type_id, self.value)
def to_tuple(self) -> Tuple: 
398    def to_tuple(self) -> Tuple:
399        return self.type_id, self.value
def to_dict(self) -> dict: 
401    def to_dict(self) -> dict:
402        return {
403            'type_id': self.type_id,
404            'value': self.value,
405        }
def serialize_to_dict(self) -> Tuple[dict, dict]: 
407    def serialize_to_dict(self) -> Tuple[dict, dict]:
408        module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(self.__class__)
409        return {
410            'type_id': self.type_id,
411            'value': self.value,
412        }, {
413            'class_name': self.__class__,
414            'module_importable_str': module_importable_str,
415            'owning_names_path': owning_names_path,
416        }
@classmethod
def from_namedtuple( cls, named_tuple: ValueWithTypeNamedTuple) -> ValueExistence: 
418    @classmethod
419    def from_namedtuple(cls, named_tuple: ValueWithTypeNamedTuple) -> 'ValueExistence':
420        return cls(named_tuple.type_id, named_tuple.value)
@classmethod
def from_tuple( cls, tuple_: Tuple) -> ValueExistence: 
422    @classmethod
423    def from_tuple(cls, tuple_: Tuple) -> 'ValueExistence':
424        return cls(*tuple_)
@classmethod
def from_dict( cls, dict_: dict) -> ValueExistence: 
426    @classmethod
427    def from_dict(cls, dict_: dict) -> 'ValueExistence':
428        return cls(dict_['type_id'], dict_['value'])
@classmethod
def deserialize_from_dict( cls, dict_: dict, owning_info: Union[str, NoneType] = None) -> ValueExistence: 
430    @classmethod
431    def deserialize_from_dict(cls, dict_: dict, owning_info: Optional[str] = None) -> 'ValueExistence':
432        if owning_info is None:
433            return cls(dict_['type_id'], dict_['value'])
434        else:
435            class_type = entity_by_name_module_importable_str_and_owning_names_path(owning_info['class_name'], owning_info['module_importable_str'], owning_info['owning_names_path'])
436            return class_type(dict_['type_id'], dict_['value'])
@classmethod
def from_other( cls, value: Union[ValueExistence, ValueWithTypeNamedTuple, Tuple, ~VT]) -> ValueExistence: 
438    @classmethod
439    def from_other(cls, value: Union['ValueExistence', ValueWithTypeNamedTuple, Tuple, VT]) -> 'ValueExistence':
440        if isinstance(value, ValueExistence):
441            return cls(value.type_id, value.value)
442        elif isinstance(value, ValueWithTypeNamedTuple):
443            return cls.from_namedtuple(value)
444        elif isinstance(value, tuple):
445            return cls.from_tuple(value)
446        elif isinstance(value, dict):
447            return cls.from_dict(value)
448        else:
449            try:
450                return cls(value.type_id, value.value)
451            except AttributeError:
452                return cls(None, value)
Inherited Members
collections.abc.Sequence
index
count