def memoized_classproperty(func: Optional[Callable[..., T]] = None, key_factory=per_instance, cache_factory=dict) -> T: return classproperty( memoized_classmethod(func, key_factory=key_factory, cache_factory=cache_factory))
def memoized_classproperty(*args, **kwargs): return classproperty(memoized_classmethod(*args, **kwargs))
def enum(all_values): """A datatype which can take on a finite set of values. This method is experimental and unstable. Any enum subclass can be constructed with its create() classmethod. This method will use the first element of `all_values` as the default value, but enum classes can override this behavior by setting `default_value` in the class body. If `all_values` contains only strings, then each variant is made into an attribute on the generated enum class object. This allows code such as the following: class MyResult(enum(['success', 'not-success'])): pass MyResult.success # The same as: MyResult('success') MyResult.not_success # The same as: MyResult('not-success') Note that like with option names, hyphenated ('-') enum values are converted into attribute names with underscores ('_'). :param Iterable all_values: A nonempty iterable of objects representing all possible values for the enum. This argument must be a finite, non-empty iterable with unique values. :raises: :class:`ValueError` """ # namedtuple() raises a ValueError if you try to use a field with a leading underscore. field_name = 'value' # This call to list() will eagerly evaluate any `all_values` which would otherwise be lazy, such # as a generator. all_values_realized = list(all_values) unique_values = OrderedSet(all_values_realized) if len(unique_values) == 0: raise ValueError("all_values must be a non-empty iterable!") elif len(unique_values) < len(all_values_realized): raise ValueError("When converting all_values ({}) to a set, at least one duplicate " "was detected. The unique elements of all_values were: {}." .format(all_values_realized, list(unique_values))) class ChoiceDatatype(datatype([field_name]), ChoicesMixin): # Overriden from datatype() so providing an invalid variant is catchable as a TypeCheckError, # but more specific. type_check_error_type = EnumVariantSelectionError @memoized_classproperty def _singletons(cls): """Generate memoized instances of this enum wrapping each of this enum's allowed values. NB: The implementation of enum() should use this property as the source of truth for allowed values and enum instances from those values. """ return OrderedDict((value, cls._make_singleton(value)) for value in all_values_realized) @classmethod def _make_singleton(cls, value): """ We convert uses of the constructor to call create(), so we then need to go around __new__ to bootstrap singleton creation from datatype()'s __new__. """ return super(ChoiceDatatype, cls).__new__(cls, value) @classproperty def _allowed_values(cls): """The values provided to the enum() type constructor, for use in error messages.""" return list(cls._singletons.keys()) def __new__(cls, value): """Create an instance of this enum. :param value: Use this as the enum value. If `value` is an instance of this class, return it, otherwise it is checked against the enum's allowed values. """ if isinstance(value, cls): return value if value not in cls._singletons: raise cls.make_type_error( "Value {!r} must be one of: {!r}." .format(value, cls._allowed_values)) return cls._singletons[value] # TODO: figure out if this will always trigger on primitives like strings, and what situations # won't call this __eq__ (and therefore won't raise like we want). Also look into whether there # is a way to return something more conventional like `NotImplemented` here that maintains the # extra caution we're looking for. def __eq__(self, other): """Redefine equality to avoid accidentally comparing against a non-enum.""" if other is None: return False if type(self) != type(other): raise self.make_type_error( "when comparing {!r} against {!r} with type '{}': " "enum equality is only defined for instances of the same enum class!" .format(self, other, type(other).__name__)) return super(ChoiceDatatype, self).__eq__(other) # Redefine the canary so datatype __new__ doesn't raise. __eq__._eq_override_canary = None # NB: as noted in datatype(), __hash__ must be explicitly implemented whenever __eq__ is # overridden. See https://docs.python.org/3/reference/datamodel.html#object.__hash__. def __hash__(self): return super(ChoiceDatatype, self).__hash__() def resolve_for_enum_variant(self, mapping): """Return the object in `mapping` with the key corresponding to the enum value. `mapping` is a dict mapping enum variant value -> arbitrary object. All variant values must be provided. NB: The objects in `mapping` should be made into lambdas if lazy execution is desired, as this will "evaluate" all of the values in `mapping`. """ keys = frozenset(mapping.keys()) if keys != frozenset(self._allowed_values): raise self.make_type_error( "pattern matching must have exactly the keys {} (was: {})" .format(self._allowed_values, list(keys))) match_for_variant = mapping[self.value] return match_for_variant @classproperty def all_variants(cls): """Iterate over all instances of this enum, in the declared order. NB: resolve_for_enum_variant() should be used instead of this method for performing conditional logic based on an enum instance's value. """ return cls._singletons.values() # Python requires creating an explicit closure to save the value on each loop iteration. accessor_generator = lambda case: lambda cls: cls(case) for case in all_values_realized: if _string_type_constraint.satisfied_by(case): accessor = classproperty(accessor_generator(case)) attr_name = re.sub(r'-', '_', case) setattr(ChoiceDatatype, attr_name, accessor) return ChoiceDatatype
def memoized_classproperty(*args, **kwargs): return classproperty(memoized_classmethod(*args, **kwargs))