Filename: //lib/python3/dist-packages///zope//interface/////interface.py

############################################################################## # # Copyright (c) 2001, 2002 Zope Foundation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## """Interface object implementation """ # pylint:disable=protected-access import sys from types import MethodType from types import FunctionType import weakref from zope.interface._compat import _use_c_impl from zope.interface._compat import PYTHON2 as PY2 from zope.interface.exceptions import Invalid from zope.interface.ro import ro as calculate_ro from zope.interface import ro __all__ = [ # Most of the public API from this module is directly exported # from zope.interface. The only remaining public API intended to # be imported from here should be those few things documented as # such. 'InterfaceClass', 'Specification', 'adapter_hooks', ] CO_VARARGS = 4 CO_VARKEYWORDS = 8 # Put in the attrs dict of an interface by ``taggedValue`` and ``invariants`` TAGGED_DATA = '__interface_tagged_values__' # Put in the attrs dict of an interface by ``interfacemethod`` INTERFACE_METHODS = '__interface_methods__' _decorator_non_return = object() _marker = object() def invariant(call): f_locals = sys._getframe(1).f_locals tags = f_locals.setdefault(TAGGED_DATA, {}) invariants = tags.setdefault('invariants', []) invariants.append(call) return _decorator_non_return def taggedValue(key, value): """Attaches a tagged value to an interface at definition time.""" f_locals = sys._getframe(1).f_locals tagged_values = f_locals.setdefault(TAGGED_DATA, {}) tagged_values[key] = value return _decorator_non_return class Element(object): """ Default implementation of `zope.interface.interfaces.IElement`. """ # We can't say this yet because we don't have enough # infrastructure in place. # #implements(IElement) def __init__(self, __name__, __doc__=''): # pylint:disable=redefined-builtin if not __doc__ and __name__.find(' ') >= 0: __doc__ = __name__ __name__ = None self.__name__ = __name__ self.__doc__ = __doc__ # Tagged values are rare, especially on methods or attributes. # Deferring the allocation can save substantial memory. self.__tagged_values = None def getName(self): """ Returns the name of the object. """ return self.__name__ def getDoc(self): """ Returns the documentation for the object. """ return self.__doc__ ### # Tagged values. # # Direct tagged values are set only in this instance. Others # may be inherited (for those subclasses that have that concept). ### def getTaggedValue(self, tag): """ Returns the value associated with 'tag'. """ if not self.__tagged_values: raise KeyError(tag) return self.__tagged_values[tag] def queryTaggedValue(self, tag, default=None): """ Returns the value associated with 'tag'. """ return self.__tagged_values.get(tag, default) if self.__tagged_values else default def getTaggedValueTags(self): """ Returns a collection of all tags. """ return self.__tagged_values.keys() if self.__tagged_values else () def setTaggedValue(self, tag, value): """ Associates 'value' with 'key'. """ if self.__tagged_values is None: self.__tagged_values = {} self.__tagged_values[tag] = value queryDirectTaggedValue = queryTaggedValue getDirectTaggedValue = getTaggedValue getDirectTaggedValueTags = getTaggedValueTags SpecificationBasePy = object # filled by _use_c_impl. @_use_c_impl class SpecificationBase(object): # This object is the base of the inheritance hierarchy for ClassProvides: # # ClassProvides < ClassProvidesBase, Declaration # Declaration < Specification < SpecificationBase # ClassProvidesBase < SpecificationBase # # In order to have compatible instance layouts, we need to declare # the storage used by Specification and Declaration here (and # those classes must have ``__slots__ = ()``); fortunately this is # not a waste of space because those are the only two inheritance # trees. These all translate into tp_members in C. __slots__ = ( # Things used here. '_implied', # Things used in Specification. '_dependents', '_bases', '_v_attrs', '__iro__', '__sro__', '__weakref__', ) def providedBy(self, ob): """Is the interface implemented by an object """ spec = providedBy(ob) return self in spec._implied def implementedBy(self, cls): """Test whether the specification is implemented by a class or factory. Raise TypeError if argument is neither a class nor a callable. """ spec = implementedBy(cls) return self in spec._implied def isOrExtends(self, interface): """Is the interface the same as or extend the given interface """ return interface in self._implied # pylint:disable=no-member __call__ = isOrExtends class NameAndModuleComparisonMixin(object): # Internal use. Implement the basic sorting operators (but not (in)equality # or hashing). Subclasses must provide ``__name__`` and ``__module__`` # attributes. Subclasses will be mutually comparable; but because equality # and hashing semantics are missing from this class, take care in how # you define those two attributes: If you stick with the default equality # and hashing (identity based) you should make sure that all possible ``__name__`` # and ``__module__`` pairs are unique ACROSS ALL SUBCLASSES. (Actually, pretty # much the same thing goes if you define equality and hashing to be based on # those two attributes: they must still be consistent ACROSS ALL SUBCLASSES.) # pylint:disable=assigning-non-slot __slots__ = () def _compare(self, other): """ Compare *self* to *other* based on ``__name__`` and ``__module__``. Return 0 if they are equal, return 1 if *self* is greater than *other*, and return -1 if *self* is less than *other*. If *other* does not have ``__name__`` or ``__module__``, then return ``NotImplemented``. .. caution:: This allows comparison to things well outside the type hierarchy, perhaps not symmetrically. For example, ``class Foo(object)`` and ``class Foo(Interface)`` in the same file would compare equal, depending on the order of operands. Writing code like this by hand would be unusual, but it could happen with dynamic creation of types and interfaces. None is treated as a pseudo interface that implies the loosest contact possible, no contract. For that reason, all interfaces sort before None. """ if other is self: return 0 if other is None: return -1 n1 = (self.__name__, self.__module__) try: n2 = (other.__name__, other.__module__) except AttributeError: return NotImplemented # This spelling works under Python3, which doesn't have cmp(). return (n1 > n2) - (n1 < n2) def __lt__(self, other): c = self._compare(other) if c is NotImplemented: return c return c < 0 def __le__(self, other): c = self._compare(other) if c is NotImplemented: return c return c <= 0 def __gt__(self, other): c = self._compare(other) if c is NotImplemented: return c return c > 0 def __ge__(self, other): c = self._compare(other) if c is NotImplemented: return c return c >= 0 @_use_c_impl class InterfaceBase(NameAndModuleComparisonMixin, SpecificationBasePy): """Base class that wants to be replaced with a C base :) """ __slots__ = ( '__name__', '__ibmodule__', '_v_cached_hash', ) def __init__(self, name=None, module=None): self.__name__ = name self.__ibmodule__ = module def _call_conform(self, conform): raise NotImplementedError @property def __module_property__(self): # This is for _InterfaceMetaClass return self.__ibmodule__ def __call__(self, obj, alternate=_marker): """Adapt an object to the interface """ try: conform = obj.__conform__ except AttributeError: conform = None if conform is not None: adapter = self._call_conform(conform) if adapter is not None: return adapter adapter = self.__adapt__(obj) if adapter is not None: return adapter if alternate is not _marker: return alternate raise TypeError("Could not adapt", obj, self) def __adapt__(self, obj): """Adapt an object to the receiver """ if self.providedBy(obj): return obj for hook in adapter_hooks: adapter = hook(self, obj) if adapter is not None: return adapter return None def __hash__(self): # pylint:disable=assigning-non-slot,attribute-defined-outside-init try: return self._v_cached_hash except AttributeError: self._v_cached_hash = hash((self.__name__, self.__module__)) return self._v_cached_hash def __eq__(self, other): c = self._compare(other) if c is NotImplemented: return c return c == 0 def __ne__(self, other): if other is self: return False c = self._compare(other) if c is NotImplemented: return c return c != 0 adapter_hooks = _use_c_impl([], 'adapter_hooks') class Specification(SpecificationBase): """Specifications An interface specification is used to track interface declarations and component registrations. This class is a base class for both interfaces themselves and for interface specifications (declarations). Specifications are mutable. If you reassign their bases, their relations with other specifications are adjusted accordingly. """ __slots__ = () # The root of all Specifications. This will be assigned `Interface`, # once it is defined. _ROOT = None # Copy some base class methods for speed isOrExtends = SpecificationBase.isOrExtends providedBy = SpecificationBase.providedBy def __init__(self, bases=()): # There are many leaf interfaces with no dependents, # and a few with very many. It's a heavily left-skewed # distribution. In a survey of Plone and Zope related packages # that loaded 2245 InterfaceClass objects and 2235 ClassProvides # instances, there were a total of 7000 Specification objects created. # 4700 had 0 dependents, 1400 had 1, 382 had 2 and so on. Only one # for <type> had 1664. So there's savings to be had deferring # the creation of dependents. self._dependents = None # type: weakref.WeakKeyDictionary self._bases = () self._implied = {} self._v_attrs = None self.__iro__ = () self.__sro__ = () self.__bases__ = tuple(bases) @property def dependents(self): if self._dependents is None: self._dependents = weakref.WeakKeyDictionary() return self._dependents def subscribe(self, dependent): self._dependents[dependent] = self.dependents.get(dependent, 0) + 1 def unsubscribe(self, dependent): try: n = self._dependents[dependent] except TypeError: raise KeyError(dependent) n -= 1 if not n: del self.dependents[dependent] else: assert n > 0 self.dependents[dependent] = n def __setBases(self, bases): # Remove ourselves as a dependent of our old bases for b in self.__bases__: b.unsubscribe(self) # Register ourselves as a dependent of our new bases self._bases = bases for b in bases: b.subscribe(self) self.changed(self) __bases__ = property( lambda self: self._bases, __setBases, ) def _calculate_sro(self): """ Calculate and return the resolution order for this object, using its ``__bases__``. Ensures that ``Interface`` is always the last (lowest priority) element. """ # We'd like to make Interface the lowest priority as a # property of the resolution order algorithm. That almost # works out naturally, but it fails when class inheritance has # some bases that DO implement an interface, and some that DO # NOT. In such a mixed scenario, you wind up with a set of # bases to consider that look like this: [[..., Interface], # [..., object], ...]. Depending on the order if inheritance, # Interface can wind up before or after object, and that can # happen at any point in the tree, meaning Interface can wind # up somewhere in the middle of the order. Since Interface is # treated as something that everything winds up implementing # anyway (a catch-all for things like adapters), having it high up # the order is bad. It's also bad to have it at the end, just before # some concrete class: concrete classes should be HIGHER priority than # interfaces (because there's only one class, but many implementations). # # One technically nice way to fix this would be to have # ``implementedBy(object).__bases__ = (Interface,)`` # # But: (1) That fails for old-style classes and (2) that causes # everything to appear to *explicitly* implement Interface, when up # to this point it's been an implicit virtual sort of relationship. # # So we force the issue by mutating the resolution order. # Note that we let C3 use pre-computed __sro__ for our bases. # This requires that by the time this method is invoked, our bases # have settled their SROs. Thus, ``changed()`` must first # update itself before telling its descendents of changes. sro = calculate_ro(self, base_mros={ b: b.__sro__ for b in self.__bases__ }) root = self._ROOT if root is not None and sro and sro[-1] is not root: # In one dataset of 1823 Interface objects, 1117 ClassProvides objects, # sro[-1] was root 4496 times, and only not root 118 times. So it's # probably worth checking. # Once we don't have to deal with old-style classes, # we can add a check and only do this if base_count > 1, # if we tweak the bootstrapping for ``<implementedBy object>`` sro = [ x for x in sro if x is not root ] sro.append(root) return sro def changed(self, originally_changed): """ We, or something we depend on, have changed. By the time this is called, the things we depend on, such as our bases, should themselves be stable. """ self._v_attrs = None implied = self._implied implied.clear() ancestors = self._calculate_sro() self.__sro__ = tuple(ancestors) self.__iro__ = tuple([ancestor for ancestor in ancestors if isinstance(ancestor, InterfaceClass) ]) for ancestor in ancestors: # We directly imply our ancestors: implied[ancestor] = () # Now, advise our dependents of change # (being careful not to create the WeakKeyDictionary if not needed): for dependent in tuple(self._dependents.keys() if self._dependents else ()): dependent.changed(originally_changed) # Just in case something called get() at some point # during that process and we have a cycle of some sort # make sure we didn't cache incomplete results. self._v_attrs = None def interfaces(self): """Return an iterator for the interfaces in the specification. """ seen = {} for base in self.__bases__: for interface in base.interfaces(): if interface not in seen: seen[interface] = 1 yield interface def extends(self, interface, strict=True): """Does the specification extend the given interface? Test whether an interface in the specification extends the given interface """ return ((interface in self._implied) and ((not strict) or (self != interface)) ) def weakref(self, callback=None): return weakref.ref(self, callback) def get(self, name, default=None): """Query for an attribute description """ attrs = self._v_attrs if attrs is None: attrs = self._v_attrs = {} attr = attrs.get(name) if attr is None: for iface in self.__iro__: attr = iface.direct(name) if attr is not None: attrs[name] = attr break return default if attr is None else attr class _InterfaceMetaClass(type): # Handling ``__module__`` on ``InterfaceClass`` is tricky. We need # to be able to read it on a type and get the expected string. We # also need to be able to set it on an instance and get the value # we set. So far so good. But what gets tricky is that we'd like # to store the value in the C structure (``InterfaceBase.__ibmodule__``) for # direct access during equality, sorting, and hashing. "No # problem, you think, I'll just use a property" (well, the C # equivalents, ``PyMemberDef`` or ``PyGetSetDef``). # # Except there is a problem. When a subclass is created, the # metaclass (``type``) always automatically puts the expected # string in the class's dictionary under ``__module__``, thus # overriding the property inherited from the superclass. Writing # ``Subclass.__module__`` still works, but # ``Subclass().__module__`` fails. # # There are multiple ways to work around this: # # (1) Define ``InterfaceBase.__getattribute__`` to watch for # ``__module__`` and return the C storage. # # This works, but slows down *all* attribute access (except, # ironically, to ``__module__``) by about 25% (40ns becomes 50ns) # (when implemented in C). Since that includes methods like # ``providedBy``, that's probably not acceptable. # # All the other methods involve modifying subclasses. This can be # done either on the fly in some cases, as instances are # constructed, or by using a metaclass. These next few can be done on the fly. # # (2) Make ``__module__`` a descriptor in each subclass dictionary. # It can't be a straight up ``@property`` descriptor, though, because accessing # it on the class returns a ``property`` object, not the desired string. # # (3) Implement a data descriptor (``__get__`` and ``__set__``) # that is both a subclass of string, and also does the redirect of # ``__module__`` to ``__ibmodule__`` and does the correct thing # with the ``instance`` argument to ``__get__`` is None (returns # the class's value.) (Why must it be a subclass of string? Because # when it' s in the class's dict, it's defined on an *instance* of the # metaclass; descriptors in an instance's dict aren't honored --- their # ``__get__`` is never invoked --- so it must also *be* the value we want # returned.) # # This works, preserves the ability to read and write # ``__module__``, and eliminates any penalty accessing other # attributes. But it slows down accessing ``__module__`` of # instances by 200% (40ns to 124ns), requires editing class dicts on the fly # (in InterfaceClass.__init__), thus slightly slowing down all interface creation, # and is ugly. # # (4) As in the last step, but make it a non-data descriptor (no ``__set__``). # # If you then *also* store a copy of ``__ibmodule__`` in # ``__module__`` in the instance's dict, reading works for both # class and instance and is full speed for instances. But the cost # is storage space, and you can't write to it anymore, not without # things getting out of sync. # # (Actually, ``__module__`` was never meant to be writable. Doing # so would break BTrees and normal dictionaries, as well as the # repr, maybe more.) # # That leaves us with a metaclass. (Recall that a class is an # instance of its metaclass, so properties/descriptors defined in # the metaclass are used when accessing attributes on the # instance/class. We'll use that to define ``__module__``.) Here # we can have our cake and eat it too: no extra storage, and # C-speed access to the underlying storage. The only substantial # cost is that metaclasses tend to make people's heads hurt. (But # still less than the descriptor-is-string, hopefully.) __slots__ = () def __new__(cls, name, bases, attrs): # Figure out what module defined the interface. # This is copied from ``InterfaceClass.__init__``; # reviewers aren't sure how AttributeError or KeyError # could be raised. __module__ = sys._getframe(1).f_globals['__name__'] # Get the C optimized __module__ accessor and give it # to the new class. moduledescr = InterfaceBase.__dict__['__module__'] if isinstance(moduledescr, str): # We're working with the Python implementation, # not the C version moduledescr = InterfaceBase.__dict__['__module_property__'] attrs['__module__'] = moduledescr kind = type.__new__(cls, name, bases, attrs) kind.__module = __module__ return kind @property def __module__(cls): return cls.__module def __repr__(cls): return "<class '%s.%s'>" % ( cls.__module, cls.__name__, ) _InterfaceClassBase = _InterfaceMetaClass( 'InterfaceClass', # From least specific to most specific. (InterfaceBase, Specification, Element), {'__slots__': ()} ) def interfacemethod(func): """ Convert a method specification to an actual method of the interface. This is a decorator that functions like `staticmethod` et al. The primary use of this decorator is to allow interface definitions to define the ``__adapt__`` method, but other interface methods can be overridden this way too. .. seealso:: `zope.interface.interfaces.IInterfaceDeclaration.interfacemethod` """ f_locals = sys._getframe(1).f_locals methods = f_locals.setdefault(INTERFACE_METHODS, {}) methods[func.__name__] = func return _decorator_non_return class InterfaceClass(_InterfaceClassBase): """ Prototype (scarecrow) Interfaces Implementation. Note that it is not possible to change the ``__name__`` or ``__module__`` after an instance of this object has been constructed. """ # We can't say this yet because we don't have enough # infrastructure in place. # #implements(IInterface) def __new__(cls, name=None, bases=(), attrs=None, __doc__=None, # pylint:disable=redefined-builtin __module__=None): assert isinstance(bases, tuple) attrs = attrs or {} needs_custom_class = attrs.pop(INTERFACE_METHODS, None) if needs_custom_class: needs_custom_class.update( {'__classcell__': attrs.pop('__classcell__')} if '__classcell__' in attrs else {} ) if '__adapt__' in needs_custom_class: # We need to tell the C code to call this. needs_custom_class['_CALL_CUSTOM_ADAPT'] = 1 if issubclass(cls, _InterfaceClassWithCustomMethods): cls_bases = (cls,) elif cls is InterfaceClass: cls_bases = (_InterfaceClassWithCustomMethods,) else: cls_bases = (cls, _InterfaceClassWithCustomMethods) cls = type(cls)( # pylint:disable=self-cls-assignment name + "<WithCustomMethods>", cls_bases, needs_custom_class ) elif PY2 and bases and len(bases) > 1: bases_with_custom_methods = tuple( type(b) for b in bases if issubclass(type(b), _InterfaceClassWithCustomMethods) ) # If we have a subclass of InterfaceClass in *bases*, # Python 3 is smart enough to pass that as *cls*, but Python # 2 just passes whatever the first base in *bases* is. This means that if # we have multiple inheritance, and one of our bases has already defined # a custom method like ``__adapt__``, we do the right thing automatically # and extend it on Python 3, but not necessarily on Python 2. To fix this, we need # to run the MRO algorithm and get the most derived base manually. # Note that this only works for consistent resolution orders if bases_with_custom_methods: cls = type( # pylint:disable=self-cls-assignment name + "<WithCustomMethods>", bases_with_custom_methods, {} ).__mro__[1] # Not the class we created, the most derived. return _InterfaceClassBase.__new__(cls) def __init__(self, name, bases=(), attrs=None, __doc__=None, # pylint:disable=redefined-builtin __module__=None): # We don't call our metaclass parent directly # pylint:disable=non-parent-init-called # pylint:disable=super-init-not-called if not all(isinstance(base, InterfaceClass) for base in bases): raise TypeError('Expected base interfaces') if attrs is None: attrs = {} if __module__ is None: __module__ = attrs.get('__module__') if isinstance(__module__, str): del attrs['__module__'] else: try: # Figure out what module defined the interface. # This is how cPython figures out the module of # a class, but of course it does it in C. :-/ __module__ = sys._getframe(1).f_globals['__name__'] except (AttributeError, KeyError): # pragma: no cover pass InterfaceBase.__init__(self, name, __module__) # These asserts assisted debugging the metaclass # assert '__module__' not in self.__dict__ # assert self.__ibmodule__ is self.__module__ is __module__ d = attrs.get('__doc__') if d is not None: if not isinstance(d, Attribute): if __doc__ is None: __doc__ = d del attrs['__doc__'] if __doc__ is None: __doc__ = '' Element.__init__(self, name, __doc__) tagged_data = attrs.pop(TAGGED_DATA, None) if tagged_data is not None: for key, val in tagged_data.items(): self.setTaggedValue(key, val) Specification.__init__(self, bases) self.__attrs = self.__compute_attrs(attrs) self.__identifier__ = "%s.%s" % (__module__, name) def __compute_attrs(self, attrs): # Make sure that all recorded attributes (and methods) are of type # `Attribute` and `Method` def update_value(aname, aval): if isinstance(aval, Attribute): aval.interface = self if not aval.__name__: aval.__name__ = aname elif isinstance(aval, FunctionType): aval = fromFunction(aval, self, name=aname) else: raise InvalidInterface("Concrete attribute, " + aname) return aval return { aname: update_value(aname, aval) for aname, aval in attrs.items() if aname not in ( # __locals__: Python 3 sometimes adds this. '__locals__', # __qualname__: PEP 3155 (Python 3.3+) '__qualname__', # __annotations__: PEP 3107 (Python 3.0+) '__annotations__', ) and aval is not _decorator_non_return } def interfaces(self): """Return an iterator for the interfaces in the specification. """ yield self def getBases(self): return self.__bases__ def isEqualOrExtendedBy(self, other): """Same interface or extends?""" return self == other or other.extends(self) def names(self, all=False): # pylint:disable=redefined-builtin """Return the attribute names defined by the interface.""" if not all: return self.__attrs.keys() r = self.__attrs.copy() for base in self.__bases__: r.update(dict.fromkeys(base.names(all))) return r.keys() def __iter__(self): return iter(self.names(all=True)) def namesAndDescriptions(self, all=False): # pylint:disable=redefined-builtin """Return attribute names and descriptions defined by interface.""" if not all: return self.__attrs.items() r = {} for base in self.__bases__[::-1]: r.update(dict(base.namesAndDescriptions(all))) r.update(self.__attrs) return r.items() def getDescriptionFor(self, name): """Return the attribute description for the given name.""" r = self.get(name) if r is not None: return r raise KeyError(name) __getitem__ = getDescriptionFor def __contains__(self, name): return self.get(name) is not None def direct(self, name): return self.__attrs.get(name) def queryDescriptionFor(self, name, default=None): return self.get(name, default) def validateInvariants(self, obj, errors=None): """validate object to defined invariants.""" for iface in self.__iro__: for invariant in iface.queryDirectTaggedValue('invariants', ()): try: invariant(obj) except Invalid as error: if errors is not None: errors.append(error) else: raise if errors: raise Invalid(errors) def queryTaggedValue(self, tag, default=None): """ Queries for the value associated with *tag*, returning it from the nearest interface in the ``__iro__``. If not found, returns *default*. """ for iface in self.__iro__: value = iface.queryDirectTaggedValue(tag, _marker) if value is not _marker: return value return default def getTaggedValue(self, tag): """ Returns the value associated with 'tag'. """ value = self.queryTaggedValue(tag, default=_marker) if value is _marker: raise KeyError(tag) return value def getTaggedValueTags(self): """ Returns a list of all tags. """ keys = set() for base in self.__iro__: keys.update(base.getDirectTaggedValueTags()) return keys def __repr__(self): # pragma: no cover try: return self._v_repr except AttributeError: name = self.__name__ m = self.__ibmodule__ if m: name = '%s.%s' % (m, name) r = "<%s %s>" % (self.__class__.__name__, name) self._v_repr = r # pylint:disable=attribute-defined-outside-init return r def _call_conform(self, conform): try: return conform(self) except TypeError: # pragma: no cover # We got a TypeError. It might be an error raised by # the __conform__ implementation, or *we* may have # made the TypeError by calling an unbound method # (object is a class). In the later case, we behave # as though there is no __conform__ method. We can # detect this case by checking whether there is more # than one traceback object in the traceback chain: if sys.exc_info()[2].tb_next is not None: # There is more than one entry in the chain, so # reraise the error: raise # This clever trick is from Phillip Eby return None # pragma: no cover def __reduce__(self): return self.__name__ Interface = InterfaceClass("Interface", __module__='zope.interface') # Interface is the only member of its own SRO. Interface._calculate_sro = lambda: (Interface,) Interface.changed(Interface) assert Interface.__sro__ == (Interface,) Specification._ROOT = Interface ro._ROOT = Interface class _InterfaceClassWithCustomMethods(InterfaceClass): """ Marker class for interfaces with custom methods that override InterfaceClass methods. """ class Attribute(Element): """Attribute descriptions """ # We can't say this yet because we don't have enough # infrastructure in place. # # implements(IAttribute) interface = None def _get_str_info(self): """Return extra data to put at the end of __str__.""" return "" def __str__(self): of = '' if self.interface is not None: of = self.interface.__module__ + '.' + self.interface.__name__ + '.' # self.__name__ may be None during construction (e.g., debugging) return of + (self.__name__ or '<unknown>') + self._get_str_info() def __repr__(self): return "<%s.%s object at 0x%x %s>" % ( type(self).__module__, type(self).__name__, id(self), self ) class Method(Attribute): """Method interfaces The idea here is that you have objects that describe methods. This provides an opportunity for rich meta-data. """ # We can't say this yet because we don't have enough # infrastructure in place. # # implements(IMethod) positional = required = () _optional = varargs = kwargs = None def _get_optional(self): if self._optional is None: return {} return self._optional def _set_optional(self, opt): self._optional = opt def _del_optional(self): self._optional = None optional = property(_get_optional, _set_optional, _del_optional) def __call__(self, *args, **kw): raise BrokenImplementation(self.interface, self.__name__) def getSignatureInfo(self): return {'positional': self.positional, 'required': self.required, 'optional': self.optional, 'varargs': self.varargs, 'kwargs': self.kwargs, } def getSignatureString(self): sig = [] for v in self.positional: sig.append(v) if v in self.optional.keys(): sig[-1] += "=" + repr(self.optional[v]) if self.varargs: sig.append("*" + self.varargs) if self.kwargs: sig.append("**" + self.kwargs) return "(%s)" % ", ".join(sig) _get_str_info = getSignatureString def fromFunction(func, interface=None, imlevel=0, name=None): name = name or func.__name__ method = Method(name, func.__doc__) defaults = getattr(func, '__defaults__', None) or () code = func.__code__ # Number of positional arguments na = code.co_argcount - imlevel names = code.co_varnames[imlevel:] opt = {} # Number of required arguments defaults_count = len(defaults) if not defaults_count: # PyPy3 uses ``__defaults_count__`` for builtin methods # like ``dict.pop``. Surprisingly, these don't have recorded # ``__defaults__`` defaults_count = getattr(func, '__defaults_count__', 0) nr = na - defaults_count if nr < 0: defaults = defaults[-nr:] nr = 0 # Determine the optional arguments. opt.update(dict(zip(names[nr:], defaults))) method.positional = names[:na] method.required = names[:nr] method.optional = opt argno = na # Determine the function's variable argument's name (i.e. *args) if code.co_flags & CO_VARARGS: method.varargs = names[argno] argno = argno + 1 else: method.varargs = None # Determine the function's keyword argument's name (i.e. **kw) if code.co_flags & CO_VARKEYWORDS: method.kwargs = names[argno] else: method.kwargs = None method.interface = interface for key, value in func.__dict__.items(): method.setTaggedValue(key, value) return method def fromMethod(meth, interface=None, name=None): if isinstance(meth, MethodType): func = meth.__func__ else: func = meth return fromFunction(func, interface, imlevel=1, name=name) # Now we can create the interesting interfaces and wire them up: def _wire(): from zope.interface.declarations import classImplements # From lest specific to most specific. from zope.interface.interfaces import IElement classImplements(Element, IElement) from zope.interface.interfaces import IAttribute classImplements(Attribute, IAttribute) from zope.interface.interfaces import IMethod classImplements(Method, IMethod) from zope.interface.interfaces import ISpecification classImplements(Specification, ISpecification) from zope.interface.interfaces import IInterface classImplements(InterfaceClass, IInterface) # We import this here to deal with module dependencies. # pylint:disable=wrong-import-position from zope.interface.declarations import implementedBy from zope.interface.declarations import providedBy from zope.interface.exceptions import InvalidInterface from zope.interface.exceptions import BrokenImplementation # This ensures that ``Interface`` winds up in the flattened() # list of the immutable declaration. It correctly overrides changed() # as a no-op, so we bypass that. from zope.interface.declarations import _empty Specification.changed(_empty, _empty)

./Ninja\.