Lines Matching defs:value
18 # Dummy value for Enum and Flag as there are explicit checks for them
27 def __init__(self, value):
28 self.value = value
34 def __init__(self, value):
35 self.value = value
120 num = num.value
128 def show_flag_values(value):
129 return list(_iter_bits_lsb(value))
175 Instances are replaced with an appropriate value in Enum class suites.
177 def __init__(self, value=_auto_null):
178 self.value = value
181 return "auto(%r)" % self.value
212 def __set__(self, instance, value):
218 return self.fset(instance, value)
238 def __init__(self, value):
239 self.value = value
248 value = self.value
249 if not isinstance(value, tuple):
250 args = (value, )
252 args = value
261 enum_member._value_ = value
271 value = enum_member._value_
278 enum_class._flag_mask_ |= value
279 if _is_single_bit(value):
280 enum_class._singles_mask_ |= value
283 # If another member with the same value was already defined, the
288 enum_member = enum_class._value2member_map_[value]
291 if canonical_member._value_ == value:
297 # this could still be an alias if the value is multi-bit and the
308 and _is_single_bit(value)
341 # This may fail if value is not hashable. We can't add the value
342 # to the map, and by-value lookups for this value will be
344 enum_class._value2member_map_.setdefault(value, enum_member)
346 # keep track of the value in a list so containment checks are quick
347 enum_class._unhashable_values_.append(value)
364 def __setitem__(self, key, value):
373 if _is_internal_class(self._cls_name, value):
398 _gnv = value.__func__ if isinstance(value, staticmethod) else value
401 if isinstance(value, str):
402 value = value.replace(',',' ').split()
404 value = list(value)
405 self._ignore = value
406 already = set(value) & set(self._member_names)
420 elif isinstance(value, nonmember):
421 # unwrap value here; it won't be processed by the below `else`
422 value = value.value
423 elif _is_descriptor(value):
426 # elif _is_internal_class(self._cls_name, value):
433 elif isinstance(value, member):
434 # unwrap value here -- it will become a member
435 value = value.value
438 if isinstance(value, auto):
440 value = (value, )
441 if type(value) is tuple and any(isinstance(v, auto) for v in value):
445 for v in value:
448 if v.value == _auto_null:
449 v.value = self._generate_next_value(
453 v = v.value
457 value = auto_valued[0]
459 value = tuple(auto_valued)
462 self._last_values.append(value)
463 super().__setitem__(key, value)
470 for name, value in members:
471 self[name] = value
472 for name, value in more_members.items():
473 self[name] = value
536 value = classdict[name]
537 classdict[name] = _proto_member(value)
545 # now set the __repr__ for the value
685 def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None):
689 This method is used both when an enum class is given a value to match
695 `value` will be the name of the new class.
698 (values will start at `start`), or an iterator/mapping of name, value pairs.
710 if names is None: # simple value lookup
711 return cls.__new__(cls, value)
714 value,
729 returned if member is the value of a member in this enum
735 "False depending on whether the value is a member or the value of a member",
774 class' __dict__ in order to support `name` and `value` being both
806 Returns a mapping of member name->value.
825 def __setattr__(cls, name, value):
836 super().__setattr__(name, value)
847 * An iterable of (member name, value) pairs.
848 * A mapping of member name -> value pairs.
862 value = first_enum._generate_next_value_(name, start, count, last_values[:])
863 last_values.append(value)
864 names.append((name, value))
866 # Here, names is either an iterable of (name, value) or a mapping.
908 (name, value)
909 for name, value in source.items()
912 # sort by value
1040 # if a non-object.__new__ is used then whatever value/tuple was
1053 Create a collection of name/value pairs.
1069 - value lookup:
1091 def __new__(cls, value):
1095 if type(value) is cls:
1097 return value
1098 # by-value search for a matching enum member
1101 return cls._value2member_map_[value]
1108 if member._value_ == value:
1113 result = cls._missing_(value)
1126 ve_exc = ValueError("%r is not a valid %s" % (value, cls.__qualname__))
1147 Generate the next value when not given.
1150 start: the initial start value or None
1169 "and the value returned will be the largest value in the enum incremented by 1",
1181 def _missing_(cls, value):
1196 interesting = set(['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'value'])
1231 # `value` attributes of enum members while keeping some measure of
1233 # to have members named `name` and `value`. This works because enumeration
1244 def value(self):
1245 """The value of the Enum member."""
1282 value = str(*values)
1283 member = str.__new__(cls, value)
1284 member._value_ = value
1338 Generate the next value when not given.
1341 start: the initial start value or None
1343 last_values: the last value assigned or None
1351 raise TypeError('invalid flag value %r' % last_value) from None
1355 def _iter_member_by_value_(cls, value):
1357 Extract all members from the value in definition (i.e. increasing value) order.
1359 for val in _iter_bits_lsb(value & cls._flag_mask_):
1365 def _iter_member_by_def_(cls, value):
1367 Extract all members from the value in definition order.
1370 cls._iter_member_by_value_(value),
1375 def _missing_(cls, value):
1377 Create a composite member containing all canonical members present in `value`.
1381 if not isinstance(value, int):
1383 "%r is not a valid %s" % (value, cls.__qualname__)
1386 # - value must be in range (e.g. -16 <-> +15, i.e. ~15 <-> 15)
1387 # - value must not include any skipped flags (e.g. if bit 2 is not
1394 not ~all_bits <= value <= all_bits
1395 or value & (all_bits ^ flag_mask)
1398 max_bits = max(value.bit_length(), flag_mask.bit_length())
1400 "%r invalid value %r\n given %s\n allowed %s" % (
1401 cls, value, bin(value, max_bits), bin(flag_mask, max_bits),
1404 value = value & flag_mask
1406 return value
1408 if value < 0:
1409 value = (
1410 max(all_bits+1, 2**(value.bit_length()))
1411 + value
1417 if value < 0:
1418 neg_value = value
1419 value = all_bits + 1 + value
1421 unknown = value & ~flag_mask
1422 aliases = value & ~singles_mask
1423 member_value = value & singles_mask
1427 % (cls.__name__, value, unknown, bin(unknown))
1434 pseudo_member = cls._member_type_.__new__(cls, value)
1436 pseudo_member._value_ = value
1444 value = member_value | aliases
1446 if pm not in members and pm._value_ and pm._value_ & value == pm._value_:
1449 unknown = value ^ combined_value
1454 raise ValueError('%r: no members with value %r' % (cls, unknown))
1460 # with this value, but only if all members are known
1463 pseudo_member = cls._value2member_map_.setdefault(value, pseudo_member)
1512 value = self._value_
1513 return self.__class__(value | other)
1522 value = self._value_
1523 return self.__class__(value & other)
1532 value = self._value_
1533 return self.__class__(value ^ other)
1558 def _high_bit(value):
1560 returns index of highest bit, or -1 if value is zero or negative
1562 return value.bit_length() - 1
1579 def _power_of_two(value):
1580 if value < 1:
1582 return value == 2 ** _high_bit(value)
1721 for name, value in attrs.items():
1722 if isinstance(value, auto) and auto.value is _auto_null:
1723 value = gnv(name, 1, len(member_names), gnv_last_values)
1724 if value in value2member_map:
1729 member_map[name] = value2member_map[value]
1733 if not isinstance(value, tuple):
1734 value = (value, )
1735 member = new_member(enum_class, *value)
1736 value = value[0]
1740 member._value_ = value
1743 member.__init__(value)
1749 value2member_map[value] = member
1750 if _is_single_bit(value):
1753 single_bits |= value
1755 multi_bits |= value
1756 gnv_last_values.append(value)
1766 for name, value in attrs.items():
1767 if isinstance(value, auto):
1768 if value.value is _auto_null:
1769 value.value = gnv(name, 1, len(member_names), gnv_last_values)
1770 value = value.value
1771 if value in value2member_map:
1776 member_map[name] = value2member_map[value]
1780 if not isinstance(value, tuple):
1781 value = (value, )
1782 member = new_member(enum_class, *value)
1783 value = value[0]
1787 member._value_ = value
1790 member.__init__(value)
1796 value2member_map[value] = member
1798 gnv_last_values.append(value)
1812 UNIQUE = "one name per value"
1844 values = set(e.value for e in enumeration)
1869 member_values = [m.value for m in enumeration]
1876 if alias.value < 0:
1879 values = list(_iter_bits_lsb(alias.value))
1892 value = 'value 0x%x' % missing_value
1894 value = 'combined values of 0x%x' % missing_value
1896 'invalid Flag %r: %s %s [use enum.show_flag_values(value) for details]'
1897 % (cls_name, alias, value)
2040 (name, value)
2041 for name, value in source.items()
2044 # sort by value