PK@6H!!protocols/api.py"""Adapter and Declaration API""" __all__ = [ 'adapt', 'declareAdapterForType', 'declareAdapterForProtocol', 'declareAdapterForObject', 'advise', 'declareImplementation', 'declareAdapter', 'adviseObject', ] _marker = object() from sys import _getframe, exc_info, modules from types import ClassType ClassTypes = ClassType, type from adapters import NO_ADAPTER_NEEDED, DOES_NOT_SUPPORT, AdaptationFailure from adapters import bindAdapter from peak.util.decorators import decorate_class, frameinfo from interfaces import IOpenProtocol, IOpenProvider, IOpenImplementor from interfaces import Protocol, InterfaceClass def adapt(obj, protocol, default=_marker): """PEP 246-alike: Adapt 'obj' to 'protocol', return 'default' If 'default' is not supplied and no implementation is found, the result of 'factory(obj,protocol)' is returned. If 'factory' is also not supplied, 'NotImplementedError' is then raised.""" if isinstance(protocol,ClassTypes) and isinstance(obj,protocol): return obj try: _conform = obj.__conform__ except AttributeError: pass else: try: result = _conform(protocol) if result is not None: return result except TypeError: if exc_info()[2].tb_next is not None: raise try: _adapt = protocol.__adapt__ except AttributeError: pass else: try: result = _adapt(obj) if result is not None: return result except TypeError: if exc_info()[2].tb_next is not None: raise if default is _marker: raise AdaptationFailure("Can't adapt", obj, protocol) return default try: from _speedups import adapt except ImportError: pass # Fundamental, explicit interface/adapter declaration API: # All declarations should end up passing through these three routines. def declareAdapterForType(protocol, adapter, typ, depth=1): """Declare that 'adapter' adapts instances of 'typ' to 'protocol'""" adapter = bindAdapter(adapter,protocol) adapter = adapt(protocol, IOpenProtocol).registerImplementation( typ, adapter, depth ) oi = adapt(typ, IOpenImplementor, None) if oi is not None: oi.declareClassImplements(protocol,adapter,depth) def declareAdapterForProtocol(protocol, adapter, proto, depth=1): """Declare that 'adapter' adapts 'proto' to 'protocol'""" adapt(protocol, IOpenProtocol) # src and dest must support IOpenProtocol adapt(proto, IOpenProtocol).addImpliedProtocol(protocol, bindAdapter(adapter,protocol), depth) def declareAdapterForObject(protocol, adapter, ob, depth=1): """Declare that 'adapter' adapts 'ob' to 'protocol'""" adapt(protocol,IOpenProtocol).registerObject(ob,bindAdapter(adapter,protocol),depth) # Bootstrap APIs to work with Protocol and InterfaceClass, without needing to # give Protocol a '__conform__' method that's hardwired to IOpenProtocol. # Note that InterfaceClass has to be registered first, so that when the # registration propagates to IAdaptingProtocol and IProtocol, InterfaceClass # will already be recognized as an IOpenProtocol, preventing infinite regress. IOpenProtocol.registerImplementation(InterfaceClass) # VERY BAD!! IOpenProtocol.registerImplementation(Protocol) # NEVER DO THIS!! # From this line forward, the declaration APIs can work. Use them instead! # Interface and adapter declarations - convenience forms, explicit targets def declareAdapter(factory, provides, forTypes=(), forProtocols=(), forObjects=() ): """'factory' is an IAdapterFactory providing 'provides' protocols""" for protocol in provides: for typ in forTypes: declareAdapterForType(protocol, factory, typ) for proto in forProtocols: declareAdapterForProtocol(protocol, factory, proto) for ob in forObjects: declareAdapterForObject(protocol, factory, ob) def declareImplementation(typ, instancesProvide=(), instancesDoNotProvide=()): """Declare information about a class, type, or 'IOpenImplementor'""" for proto in instancesProvide: declareAdapterForType(proto, NO_ADAPTER_NEEDED, typ) for proto in instancesDoNotProvide: declareAdapterForType(proto, DOES_NOT_SUPPORT, typ) def adviseObject(ob, provides=(), doesNotProvide=()): """Tell an object what it does or doesn't provide""" for proto in provides: declareAdapterForObject(proto, NO_ADAPTER_NEEDED, ob) for proto in doesNotProvide: declareAdapterForObject(proto, DOES_NOT_SUPPORT, ob) # And now for the magic function... def advise(**kw): kw = kw.copy() frame = _getframe(1) kind, module, caller_locals, caller_globals = frameinfo(frame) if kind=="module": moduleProvides = kw.setdefault('moduleProvides',()) del kw['moduleProvides'] for k in kw: raise TypeError( "Invalid keyword argument for advising modules: %s" % k ) adviseObject(module, provides=moduleProvides ) return elif kind != "class": raise SyntaxError( "protocols.advise() must be called directly in a class or" " module body, not in a function or exec." ) classProvides = kw.setdefault('classProvides',()) classDoesNotProvide = kw.setdefault('classDoesNotProvide',()) instancesProvide = kw.setdefault('instancesProvide',()) instancesDoNotProvide = kw.setdefault('instancesDoNotProvide',()) asAdapterForTypes = kw.setdefault('asAdapterForTypes',()) asAdapterForProtocols = kw.setdefault('asAdapterForProtocols',()) protocolExtends = kw.setdefault('protocolExtends',()) protocolIsSubsetOf = kw.setdefault('protocolIsSubsetOf',()) factoryMethod = kw.setdefault('factoryMethod',None) equivalentProtocols = kw.setdefault('equivalentProtocols',()) map(kw.__delitem__,"classProvides classDoesNotProvide instancesProvide" " instancesDoNotProvide asAdapterForTypes asAdapterForProtocols" " protocolExtends protocolIsSubsetOf factoryMethod equivalentProtocols" .split()) for k in kw: raise TypeError( "Invalid keyword argument for advising classes: %s" % k ) def callback(klass): if classProvides or classDoesNotProvide: adviseObject(klass, provides=classProvides, doesNotProvide=classDoesNotProvide ) if instancesProvide or instancesDoNotProvide: declareImplementation(klass, instancesProvide=instancesProvide, instancesDoNotProvide=instancesDoNotProvide ) if asAdapterForTypes or asAdapterForProtocols: if not instancesProvide: raise TypeError( "When declaring an adapter, you must specify what" " its instances will provide." ) if factoryMethod: factory = getattr(klass,factoryMethod) else: factory = klass declareAdapter(factory, instancesProvide, forTypes=asAdapterForTypes, forProtocols=asAdapterForProtocols ) elif factoryMethod: raise TypeError( "'factoryMethod' is only used when declaring an adapter type" ) if protocolExtends: declareAdapter(NO_ADAPTER_NEEDED, protocolExtends, forProtocols=[klass] ) if protocolIsSubsetOf: declareAdapter(NO_ADAPTER_NEEDED, [klass], forProtocols=protocolIsSubsetOf ) if equivalentProtocols: declareAdapter( NO_ADAPTER_NEEDED, equivalentProtocols, forProtocols=[klass] ) declareAdapter( NO_ADAPTER_NEEDED, [klass], forProtocols=equivalentProtocols ) return klass decorate_class(callback) PK@6/v v protocols/zope_support.py"""Declaration support for Zope Interfaces""" __all__ = [] from types import ClassType from adapters import * from api import declareImplementation, advise, adapt from interfaces import IOpenProtocol, Protocol from advice import metamethod, supermeta # Monkeypatch Zope Interfaces try: import zope.interface as zi except ImportError: ZopeInterfaceTypes = [] zi = None else: def __adapt__(self, obj): return adapt(self,IOpenProtocol).__adapt__(obj) try: from zope.interface import adapter_hooks except ImportError: try: from zope.interface.interface import adapter_hooks except ImportError: zi.Interface.__class__.__adapt__ = __adapt__ adapter_hooks = [] adapter_hooks.append(__adapt__) ZopeInterfaceTypes = [zi.Interface.__class__] del __adapt__, adapter_hooks # Adapter for Zope X3 Interfaces class ZopeInterfaceAsProtocol(StickyAdapter, Protocol): advise( instancesProvide=[IOpenProtocol], asAdapterForTypes=ZopeInterfaceTypes, ) attachForProtocols = IOpenProtocol, def __init__(self, ob): StickyAdapter.__init__(self,ob) Protocol.__init__(self) if ZopeInterfaceTypes and hasattr(ZopeInterfaceTypes[0],'providedBy'): def __adapt__(self, obj): if self.subject.providedBy(obj): return obj return supermeta(ZopeInterfaceAsProtocol,self).__adapt__(obj) else: def __adapt__(self, obj): if self.subject.isImplementedBy(obj): return obj return supermeta(ZopeInterfaceAsProtocol,self).__adapt__(obj) def registerImplementation(self,klass,adapter=NO_ADAPTER_NEEDED,depth=1): if adapter is NO_ADAPTER_NEEDED: zi.classImplements(klass, self.subject) elif adapter is DOES_NOT_SUPPORT: ifaces = zi.Declaration( [i.__iro__ for i in zi.implementedBy(klass)] ) - self.subject zi.classImplementsOnly(klass, ifaces) return supermeta(ZopeInterfaceAsProtocol,self).registerImplementation( klass,adapter,depth ) registerImplementation = metamethod(registerImplementation) def registerObject(self, ob, adapter=NO_ADAPTER_NEEDED, depth=1): if adapter is NO_ADAPTER_NEEDED: zi.directlyProvides(ob,self.subject) elif adapter is DOES_NOT_SUPPORT: zi.directlyProvides(ob, zi.directlyProvidedBy(ob)-self.subject) return supermeta(ZopeInterfaceAsProtocol,self).registerObject( ob, adapter, depth ) registerObject = metamethod(registerObject) def getImpliedProtocols(self): protos = super(ZopeInterfaceAsProtocol,self).getImpliedProtocols() return list(protos) + [ (i,(NO_ADAPTER_NEEDED,1)) for i in self.subject.__bases__ if i is not zi.Interface ] def __getstate__(self): state = self.__dict__.copy() del state['_Protocol__lock'] # locks can't be pickled del state['_Protocol__listeners'] # and neither can weakref dict return state def __hash__(self): return hash(self.subject) def __cmp__(self,other): return cmp(self.subject, other) PK@6v\protocols/generate.py"""Autogenerated protocols from type+method names, URI, sequence, etc.""" from interfaces import Protocol, allocate_lock, Interface from advice import metamethod, supermeta from api import declareAdapterForProtocol, declareAdapterForType from api import declareAdapter, adapt from adapters import NO_ADAPTER_NEEDED __all__ = [ 'protocolForType', 'protocolForURI', 'sequenceOf', 'IBasicSequence', 'URIProtocol', 'TypeSubset', 'WeakSubset', 'ADAPT_SEQUENCE', 'SequenceProtocol' ] class URIProtocol(Protocol): """Protocol representing a URI, UUID, or other unique textual identifier""" def __init__(self,uri): self.URI = uri Protocol.__init__(self) def __repr__(self): return "URIProtocol(%r)" % self.URI def __reduce__(self): return protocolForURI, (self.URI,) class TypeSubset(Protocol): """Protocol representing some set of a type's methods""" def __init__(self,baseType,methods): self.baseType = baseType self.methods = methods Protocol.__init__(self) def __repr__(self): return "TypeSubset(%r,%r)" % (self.baseType,self.methods) def __reduce__(self): return protocolForType, (self.baseType, self.methods, False) class WeakSubset(TypeSubset,object): """TypeSubset that accepts any object with the right attributes""" __metaclass__ = type # new-style so we can use super() def __adapt__(self,ob): result = supermeta(TypeSubset,self).__adapt__(ob) if result is not None: return result for name in self.methods: if not hasattr(ob,name): return None else: return ob __adapt__ = metamethod(__adapt__) def __repr__(self): return "WeakSubset(%r,%r)" % (self.baseType,self.methods) def __reduce__(self): return protocolForType, (self.baseType, self.methods, True) class SequenceProtocol(Protocol): """Protocol representing a "sequence of" some base protocol""" def __init__(self,baseProtocol): self.baseProtocol = baseProtocol Protocol.__init__(self) def __repr__(self): return "sequenceOf(%r)" % self.baseProtocol def __reduce__(self): return sequenceOf, (self.baseProtocol,) class IBasicSequence(Interface): """Non-string, iterable object sequence""" def __iter__(): """Return an iterator over the sequence""" declareAdapter( NO_ADAPTER_NEEDED, provides=[IBasicSequence], forTypes=[list,tuple] ) def ADAPT_SEQUENCE(ob, proto): """Convert iterable 'ob' into list of objects implementing 'proto'""" marker = object() out = [] proto = proto.baseProtocol # get the protocol to adapt to for item in ob: item = adapt(item,proto, marker) if item is marker: return None # can't adapt unless all members adapt out.append(item) return out __registryLock = allocate_lock() registry = {} def protocolForURI(uri): """Return a unique protocol object representing the supplied URI/UUID""" __registryLock.acquire() try: try: return registry[uri] except KeyError: proto = registry[uri] = URIProtocol(uri) return proto finally: __registryLock.release() def protocolForType(baseType, methods=(), implicit=False): """Return a protocol representing a subset of methods of a specific type""" # Normalize 'methods' to a sorted tuple w/no duplicate names methods = dict([(k,k) for k in methods]).keys() methods.sort() methods = tuple(methods) key = baseType, methods, (not not implicit) # ensure implicit is true/false return __protocolForType(key) def sequenceOf(baseProtocol): """Return a protocol representing an sequence of a given base protocol""" key = (sequenceOf, baseProtocol) __registryLock.acquire() try: try: return registry[key] except KeyError: proto = registry[key] = SequenceProtocol(baseProtocol) declareAdapterForProtocol( proto, lambda o: ADAPT_SEQUENCE(o,proto), IBasicSequence ) return proto finally: __registryLock.release() def __protocolForType(key): """Recursive implementation of protocolForType; assumes standardized key""" __registryLock.acquire() try: try: return registry[key] except KeyError: baseType, methods, implicit = key if implicit: proto = WeakSubset(baseType,methods) else: proto = TypeSubset(baseType,methods) registry[key] = proto finally: __registryLock.release() # declare that proto implies all subset-method protocols if len(methods)>1: for method in methods: subset = tuple([m for m in methods if m!=method]) implied = __protocolForType((baseType, subset, implicit)) declareAdapterForProtocol(implied, NO_ADAPTER_NEEDED, proto) # declare that explicit form implies implicit form if implicit: impliedBy = __protocolForType((baseType, methods, False)) declareAdapterForProtocol(proto, NO_ADAPTER_NEEDED, impliedBy) # declare that baseType implements this protocol declareAdapterForType(proto, NO_ADAPTER_NEEDED, baseType) return proto PK@6̕iiprotocols/advice.pyfrom __future__ import generators from new import instancemethod from types import ClassType, FunctionType, InstanceType import sys __all__ = [ 'metamethod', 'supermeta', 'getMRO', 'classicMRO', 'mkRef', 'StrongRef', # XXX these should be deprecated 'addClassAdvisor', 'isClassAdvisor', 'add_assignment_advisor', 'determineMetaclass', 'getFrameInfo', 'minimalBases', ] # No sense duplicating all this functionality any more... from peak.util import decorators def addClassAdvisor(callback, depth=2,frame=None): "protocols.advice.addClassAdvisor is deprecated, please use" " peak.util.decorators.decorate_class instead" from warnings import warn warn(addClassAdvisor.__doc__, DeprecationWarning, 2) return decorators.decorate_class(callback, (depth or 0)+1, frame) def add_assignment_advisor(callback,depth=2,frame=None): "protocols.advice.add_assignment_advisor is deprecated, please use" " peak.util.decorators.decorate_assignment instead" from warnings import warn warn(add_assignment_advisor.__doc__, DeprecationWarning, 2) return decorators.decorate_assignment(callback, (depth or 0)+1, frame) def getFrameInfo(frame): "protocols.advice.getFrameInfo is deprecated, please use" " peak.util.decorators.frameinfo instead" from warnings import warn warn(getFrameInfo.__doc__, DeprecationWarning, 2) return decorators.frameinfo(frame) def determineMetaclass(bases, explicit_mc=None): "protocols.advice.determineMetaclass is deprecated, please use" " peak.util.decorators.metaclass_for_bases instead" from warnings import warn warn(determineMetaclass.__doc__, DeprecationWarning, 2) return decorators.metaclass_for_bases(bases, explicit_mc) def isClassAdvisor(ob): "protocols.advice.isClassAdvisor is deprecated, please use" " peak.util.decorators.metaclass_is_decorator instead" from warnings import warn warn(isClassAdvisor.__doc__, DeprecationWarning, 2) return decorators.metaclass_is_decorator(ob) def metamethod(func): """Wrapper for metaclass method that might be confused w/instance method""" return property(lambda ob: func.__get__(ob,ob.__class__)) try: from ExtensionClass import ExtensionClass except ImportError: ClassicTypes = ClassType else: ClassicTypes = ClassType, ExtensionClass def classicMRO(ob, extendedClassic=False): stack = [] push = stack.insert pop = stack.pop push(0,ob) while stack: cls = pop() yield cls p = len(stack) for b in cls.__bases__: push(p,b) if extendedClassic: yield InstanceType yield object def getMRO(ob, extendedClassic=False): if isinstance(ob,ClassicTypes): return classicMRO(ob,extendedClassic) elif isinstance(ob,type): return ob.__mro__ return ob, try: from _speedups import metamethod, getMRO, classicMRO except ImportError: pass # property-safe 'super()' for Python 2.2; 2.3 can use super() instead def supermeta(typ,ob): starttype = type(ob) mro = starttype.__mro__ if typ not in mro: starttype = ob mro = starttype.__mro__ mro = iter(mro) for cls in mro: if cls is typ: mro = [cls.__dict__ for cls in mro] break else: raise TypeError("Not sub/supertypes:", starttype, typ) typ = type(ob) class theSuper(object): def __getattribute__(self,name): for d in mro: if name in d: descr = d[name] try: descr = descr.__get__ except AttributeError: return descr else: return descr(ob,typ) return object.__getattribute__(self,name) return theSuper() def minimalBases(classes): """DEPRECATED""" from warnings import warn warn("protocols.advice.minimalBases is deprecated; please do not use it", DeprecationWarning, 2) classes = [c for c in classes if c is not ClassType] candidates = [] for m in classes: for n in classes: if issubclass(n,m) and m is not n: break else: # m has no subclasses in 'classes' if m in candidates: candidates.remove(m) # ensure that we're later in the list candidates.append(m) return candidates from weakref import ref class StrongRef(object): """Like a weakref, but for non-weakrefable objects""" __slots__ = 'referent' def __init__(self,referent): self.referent = referent def __call__(self): return self.referent def __hash__(self): return hash(self.referent) def __eq__(self,other): return self.referent==other def __repr__(self): return 'StrongRef(%r)' % self.referent def mkRef(ob,*args): """Return either a weakref or a StrongRef for 'ob' Note that extra args are forwarded to weakref.ref() if applicable.""" try: return ref(ob,*args) except TypeError: return StrongRef(ob) PK@6dxprotocols/__init__.py"""Trivial Interfaces and Adaptation""" from api import * from adapters import NO_ADAPTER_NEEDED,DOES_NOT_SUPPORT,Adapter,StickyAdapter from adapters import AdaptationFailure from interfaces import * from advice import metamethod, supermeta from classic import ProviderMixin from generate import protocolForType, protocolForURI from generate import sequenceOf, IBasicSequence PK@6(((protocols/twisted_support.py"""Declaration support for Twisted Interfaces""" __all__ = [] from adapters import * from api import advise from interfaces import IOpenProtocol from weakref import WeakKeyDictionary # Twisted uses an approach to __adapt__ that is largely incompatible with # PEP 246, so we have to jump through some twisty hoops to convince it to work # for our purposes, without breaking Twisted's test suite. class TwistedAdaptMethod(object): """__adapt__ implementation for Twisted interfaces""" __slots__ = 'iface' def __init__(self,iface): self.iface = iface def __call__(self, obj): # This is the __adapt__ method that you get # for ISomething.__adapt__()... if TwistedImplements(obj, self.iface): return obj # Get Twisted to try and adapt return self.iface(obj, None) def im_func(self, ob, default): # And this is what MetaInterface.__call__ calls when # it goes after __adapt__.im_func! meth = self.iface.__dict__.get('__adapt__') if meth is None: return default return meth(ob,default) # Monkeypatch Twisted Interfaces try: from twisted.python.components import \ implements as TwistedImplements, \ MetaInterface as TwistedInterfaceClass, \ getInterfaces as TwistedGetInterfaces except ImportError: TwistedInterfaceTypes = [] else: # Force all Twisted interfaces to have an __adapt__ method TwistedInterfaceClass.__adapt__ = property(lambda s: TwistedAdaptMethod(s)) TwistedInterfaceTypes = [TwistedInterfaceClass] class TwistedInterfaceAsProtocol(object): __slots__ = 'iface' advise( instancesProvide=[IOpenProtocol], asAdapterForTypes=TwistedInterfaceTypes, ) def __init__(self, iface): self.iface = iface def __adapt__(self, obj): return self.iface.__adapt__(obj) def registerImplementation(self,klass,adapter=NO_ADAPTER_NEEDED,depth=1): oldImplements = TwistedGetInterfaces(klass) if adapter is NO_ADAPTER_NEEDED: klass.__implements__ = self.iface, tuple(oldImplements) elif adapter is DOES_NOT_SUPPORT: if self.iface in oldImplements: oldImplements.remove(self.iface) klass.__implements__ = tuple(oldImplements) else: raise TypeError( "Twisted interfaces can only declare support, not adapters", self.iface, klass, adapter ) def addImpliedProtocol(self, proto, adapter=NO_ADAPTER_NEEDED, depth=1): iface = self.iface # XXX need to ensure 'proto' is usable w/Twisted! self.iface.adaptWith(lambda o: adapter(o, iface), proto) # XXX is the above sufficient? # XXX What are Twisted's adapter override semantics? listeners = iface.__dict__.get('_Protocol__listeners',{}) for listener in listeners.keys(): # Must use keys()! listener.newProtocolImplied(self, proto, adapter, depth) def registerObject(self, ob, adapter=NO_ADAPTER_NEEDED, depth=1): oldImplements = TwistedGetInterfaces(ob) if adapter is NO_ADAPTER_NEEDED: ob.__implements__ = self.iface, tuple(oldImplements) elif adapter is DOES_NOT_SUPPORT: if self.iface in oldImplements: oldImplements.remove(self.iface) ob.__implements__ = tuple(oldImplements) else: raise TypeError( "Twisted interfaces can only declare support, not adapters", self.iface, ob, adapter ) def addImplicationListener(self, listener): listeners = self.iface.__dict__.setdefault( '_Protocol__listeners',WeakKeyDictionary() ) listeners[listener] = True PK@6`G+protocols/classic.py"""Declaration support for Python built-in types""" __all__ = ['ProviderMixin'] from types import FunctionType, ModuleType, InstanceType, ClassType from adapters import * from api import declareImplementation, advise, declareAdapterForObject, adapt from interfaces import * from new import instancemethod from advice import getMRO, metamethod, mkRef class ProviderMixin: """Mixin to support per-instance declarations""" advise( instancesProvide=[IOpenProvider, IImplicationListener] ) def declareProvides(self,protocol,adapter=NO_ADAPTER_NEEDED,depth=1): registry = self.__dict__.get('__protocols_provided__') if registry is None: self.__protocols_provided__ = registry = {} if updateWithSimplestAdapter(registry,protocol,adapter,depth): adapt(protocol,IOpenProtocol).addImplicationListener(self) return True declareProvides = metamethod(declareProvides) def newProtocolImplied(self, srcProto, destProto, adapter, depth): registry = self.__dict__.get('__protocols_provided__',()) if srcProto not in registry: return baseAdapter, d = registry[srcProto] adapter = composeAdapters(baseAdapter,srcProto,adapter) declareAdapterForObject( destProto, adapter, self, depth+d ) newProtocolImplied = metamethod(newProtocolImplied) def __conform__(self,protocol): for cls in getMRO(self): conf = cls.__dict__.get('__protocols_provided__',()) if protocol in conf: return conf[protocol][0](self) __conform__ = metamethod(__conform__) class conformsRegistry(dict): """Helper type for objects and classes that need registration support""" def __call__(self, protocol): # This only gets called for non-class objects if protocol in self: subject = self.subject() if subject is not None: return self[protocol][0](subject) def findImplementation(self, subject, protocol, checkSelf=True): for cls in getMRO(subject): conf = cls.__dict__.get('__conform__') if conf is None: continue if not isinstance(conf,conformsRegistry): raise TypeError( "Incompatible __conform__ in base class", conf, cls ) if protocol in conf: return conf[protocol][0](subject) def newProtocolImplied(self, srcProto, destProto, adapter, depth): subject = self.subject() if subject is None or srcProto not in self: return baseAdapter, d = self[srcProto] adapter = composeAdapters(baseAdapter,srcProto,adapter) declareAdapterForObject( destProto, adapter, subject, depth+d ) def __hash__(self): # Need this because dictionaries aren't hashable, but we need to # be referenceable by a weak-key dictionary return id(self) def __get__(self,ob,typ=None): if ob is not None: raise AttributeError( "__conform__ registry does not pass to instances" ) # Return a bound method that adds the retrieved-from class to the return instancemethod(self.findImplementation, typ, type(typ)) def __getstate__(self): return self.subject(), self.items() def __setstate__(self,(subject,items)): self.clear() self.update(dict(items)) self.subject = mkRef(subject) class MiscObjectsAsOpenProvider(object): """Supply __conform__ registry for funcs, modules, & classic instances""" advise( instancesProvide=[IOpenProvider], asAdapterForTypes=[ FunctionType, ModuleType, InstanceType, ClassType, type, object ] ) def __init__(self,ob): obs = list(getMRO(ob)) for item in obs: try: reg = item.__dict__.get('__conform__') if reg is None and obs==[ob]: # Make sure we don't obscure a method from the class! reg = getattr(item,'__conform__',None) except AttributeError: raise TypeError( "Only objects with dictionaries can use this adapter", ob ) if reg is not None and not isinstance(reg,conformsRegistry): raise TypeError( "Incompatible __conform__ on adapted object", ob, reg ) reg = ob.__dict__.get('__conform__') if reg is None: reg = ob.__conform__ = self.newRegistry(ob) self.ob = ob self.reg = reg def declareProvides(self, protocol, adapter=NO_ADAPTER_NEEDED, depth=1): if updateWithSimplestAdapter(self.reg, protocol, adapter, depth): adapt(protocol,IOpenProtocol).addImplicationListener(self.reg) return True def newRegistry(self,subject): # Create a registry that's also set up for inheriting declarations reg = conformsRegistry() reg.subject = mkRef(subject) return reg PK@6$GEEprotocols/adapters.py"""Basic Adapters and Adapter Operations""" __all__ = [ 'NO_ADAPTER_NEEDED','DOES_NOT_SUPPORT', 'Adapter', 'minimumAdapter', 'composeAdapters', 'updateWithSimplestAdapter', 'StickyAdapter', 'AdaptationFailure', 'bindAdapter', ] from types import FunctionType,ClassType,MethodType try: PendingDeprecationWarning except NameError: class PendingDeprecationWarning(Warning): 'Base class for warnings about features which will be deprecated in the future.' class AdaptationFailure(NotImplementedError,TypeError): """A suitable implementation/adapter could not be found""" # Fundamental Adapters def NO_ADAPTER_NEEDED(obj, protocol=None): """Assume 'obj' implements 'protocol' directly""" return obj def DOES_NOT_SUPPORT(obj, protocol=None): """Prevent 'obj' from supporting 'protocol'""" return None try: from _speedups import NO_ADAPTER_NEEDED, DOES_NOT_SUPPORT except ImportError: pass class Adapter(object): """Convenient base class for adapters""" def __init__(self, ob): self.subject = ob class StickyAdapter(object): """Adapter that attaches itself to its subject for repeated use""" attachForProtocols = () def __init__(self, ob): self.subject = ob # Declare this instance as a per-instance adaptation for the # given protocols provides = list(self.attachForProtocols) from protocols.api import declareAdapter declareAdapter(lambda s: self, provides, forObjects=[ob]) # Adapter "arithmetic" def minimumAdapter(a1,a2,d1=0,d2=0): """Shortest route to implementation, 'a1' @ depth 'd1', or 'a2' @ 'd2'? Assuming both a1 and a2 are interchangeable adapters (i.e. have the same source and destination protocols), return the one which is preferable; that is, the one with the shortest implication depth, or, if the depths are equal, then the adapter that is composed of the fewest chained adapters. If both are the same, then prefer 'NO_ADAPTER_NEEDED', followed by anything but 'DOES_NOT_SUPPORT', with 'DOES_NOT_SUPPORT' being least preferable. If there is no unambiguous choice, and 'not a1 is a2', TypeError is raised. """ if d1=maxargs: newAdapter = lambda ob: adapter(ob,proto) newAdapter.__adapterCount__ = getattr( adapter,'__adapterCount__',1 ) newAdapter.__unbound_adapter__ = adapter from warnings import warn warn("Adapter %r to protocol %r needs multiple arguments" % (adapter,proto), PendingDeprecationWarning, 6) return newAdapter return adapter def updateWithSimplestAdapter(mapping, key, adapter, depth): """Replace 'mapping[key]' w/'adapter' @ 'depth', return true if changed""" new = adapter old = mapping.get(key) if old is not None: old, oldDepth = old new = minimumAdapter(old,adapter,oldDepth,depth) if old is new and depth>=oldDepth: return False mapping[key] = new, depth return True PK@6Ms11protocols/interfaces.py"""Implement Interfaces and define the interfaces used by the package""" from __future__ import generators __all__ = [ 'Protocol', 'InterfaceClass', 'Interface', 'AbstractBase', 'AbstractBaseMeta', 'IAdapterFactory', 'IProtocol', 'IAdaptingProtocol', 'IOpenProtocol', 'IOpenProvider', 'IOpenImplementor', 'IImplicationListener', 'Attribute', 'Variation' ] import api from advice import metamethod, classicMRO, mkRef from adapters import composeAdapters, updateWithSimplestAdapter from adapters import NO_ADAPTER_NEEDED, DOES_NOT_SUPPORT from types import InstanceType # Thread locking support try: from thread import allocate_lock except ImportError: try: from dummy_thread import allocate_lock except ImportError: class allocate_lock(object): __slots__ = () def acquire(*args): pass def release(*args): pass # Trivial interface implementation class Protocol: """Generic protocol w/type-based adapter registry""" def __init__(self): self.__adapters = {} self.__implies = {} self.__listeners = None self.__lock = allocate_lock() def getImpliedProtocols(self): # This is messy so it can clean out weakrefs, but this method is only # called for declaration activities and is thus not at all # speed-critical. It's more important that we support weak refs to # implied protocols, so that dynamically created subset protocols can # be garbage collected. out = [] add = out.append self.__lock.acquire() # we might clean out dead weakrefs try: for k,v in self.__implies.items(): proto = k() if proto is None: del self.__implies[k] else: add((proto,v)) return out finally: self.__lock.release() def addImpliedProtocol(self,proto,adapter=NO_ADAPTER_NEEDED,depth=1): self.__lock.acquire() try: key = mkRef(proto) if not updateWithSimplestAdapter( self.__implies, key, adapter, depth ): return self.__implies[key][0] finally: self.__lock.release() # Always register implied protocol with classes, because they should # know if we break the implication link between two protocols for klass,(baseAdapter,d) in self.__adapters.items(): api.declareAdapterForType( proto,composeAdapters(baseAdapter,self,adapter),klass,depth+d ) if self.__listeners: for listener in self.__listeners.keys(): # Must use keys()! listener.newProtocolImplied(self, proto, adapter, depth) return adapter addImpliedProtocol = metamethod(addImpliedProtocol) def registerImplementation(self,klass,adapter=NO_ADAPTER_NEEDED,depth=1): self.__lock.acquire() try: if not updateWithSimplestAdapter( self.__adapters,klass,adapter,depth ): return self.__adapters[klass][0] finally: self.__lock.release() if adapter is DOES_NOT_SUPPORT: # Don't register non-support with implied protocols, because # "X implies Y" and "not X" doesn't imply "not Y". In effect, # explicitly registering DOES_NOT_SUPPORT for a type is just a # way to "disinherit" a superclass' claim to support something. return adapter for proto, (extender,d) in self.getImpliedProtocols(): api.declareAdapterForType( proto, composeAdapters(adapter,self,extender), klass, depth+d ) return adapter registerImplementation = metamethod(registerImplementation) def registerObject(self, ob, adapter=NO_ADAPTER_NEEDED,depth=1): # Object needs to be able to handle registration if api.adapt(ob,IOpenProvider).declareProvides(self,adapter,depth): if adapter is DOES_NOT_SUPPORT: return # non-support doesn't imply non-support of implied # Handle implied protocols for proto, (extender,d) in self.getImpliedProtocols(): api.declareAdapterForObject( proto, composeAdapters(adapter,self,extender), ob, depth+d ) registerObject = metamethod(registerObject) def __adapt__(self, obj): get = self.__adapters.get try: typ = obj.__class__ except AttributeError: typ = type(obj) try: mro = typ.__mro__ except AttributeError: # Note: this adds 'InstanceType' and 'object' to end of MRO mro = classicMRO(typ,extendedClassic=True) for klass in mro: factory=get(klass) if factory is not None: return factory[0](obj) try: from _speedups import Protocol__adapt__ as __adapt__ except ImportError: pass __adapt__ = metamethod(__adapt__) def addImplicationListener(self, listener): self.__lock.acquire() try: if self.__listeners is None: from weakref import WeakKeyDictionary self.__listeners = WeakKeyDictionary() self.__listeners[listener] = 1 finally: self.__lock.release() addImplicationListener = metamethod(addImplicationListener) def __call__(self, ob, default=api._marker): """Adapt to this protocol""" return api.adapt(ob,self,default) # Use faster __call__ method, if possible # XXX it could be even faster if the __call__ were in the tp_call slot # XXX directly, but Pyrex doesn't have a way to do that AFAIK. try: from _speedups import Protocol__call__ except ImportError: pass else: from new import instancemethod Protocol.__call__ = instancemethod(Protocol__call__, None, Protocol) class AbstractBaseMeta(Protocol, type): """Metaclass for 'AbstractBase' - a protocol that's also a class (Note that this should not be used as an explicit metaclass - always subclass from 'AbstractBase' or 'Interface' instead.) """ def __init__(self, __name__, __bases__, __dict__): type.__init__(self, __name__, __bases__, __dict__) Protocol.__init__(self) for b in __bases__: if isinstance(b,AbstractBaseMeta) and b.__bases__<>(object,): self.addImpliedProtocol(b) def __setattr__(self,attr,val): # We could probably support changing __bases__, as long as we checked # that no bases are *removed*. But it'd be a pain, since we'd # have to do callbacks, remove entries from our __implies registry, # etc. So just punt for now. if attr=='__bases__': raise TypeError( "Can't change interface __bases__", self ) type.__setattr__(self,attr,val) __call__ = type.__call__ class AbstractBase(object): """Base class for a protocol that's a class""" __metaclass__ = AbstractBaseMeta class InterfaceClass(AbstractBaseMeta): """Metaclass for 'Interface' - a non-instantiable protocol (Note that this should not be used as an explicit metaclass - always subclass from 'AbstractBase' or 'Interface' instead.) """ def __call__(self, *__args, **__kw): if self.__init__ is Interface.__init__: return Protocol.__call__(self,*__args, **__kw) else: return type.__call__(self,*__args, **__kw) def getBases(self): return [ b for b in self.__bases__ if isinstance(b,AbstractBaseMeta) and b.__bases__<>(object,) ] class Interface(object): __metaclass__ = InterfaceClass class Variation(Protocol): """A variation of a base protocol - "inherits" the base's adapters See the 'LocalProtocol' example in the reference manual for more info. """ def __init__(self, baseProtocol, context = None): self.baseProtocol = baseProtocol self.context = context # Note: Protocol is a ``classic'' class, so we don't use super() Protocol.__init__(self) api.declareAdapterForProtocol(self,NO_ADAPTER_NEEDED,baseProtocol) def __repr__(self): if self.context is None: return "Variation(%r)" % self.baseProtocol return "Variation(%r,%r)" % (self.baseProtocol, self.context) # Semi-backward compatible 'interface.Attribute' class Attribute(object): """Attribute declaration; should we get rid of this?""" def __init__(self,doc,name=None,value=None): self.__doc__ = doc self.name = name self.value = value def __get__(self,ob,typ=None): if ob is None: return self if not self.name: raise NotImplementedError("Abstract attribute") try: return ob.__dict__[self.name] except KeyError: return self.value def __set__(self,ob,val): if not self.name: raise NotImplementedError("Abstract attribute") ob.__dict__[self.name] = val def __delete__(self,ob): if not self.name: raise NotImplementedError("Abstract attribute") del ob.__dict__[self.name] def __repr__(self): return "Attribute: %s" % self.__doc__ # Interfaces and adapters for declaring protocol/type/object relationships class IAdapterFactory(Interface): """Callable that can adapt an object to a protocol""" def __call__(ob): """Return an implementation of protocol for 'ob'""" class IProtocol(Interface): """Object usable as a protocol by 'adapt()'""" def __hash__(): """Protocols must be usable as dictionary keys""" def __eq__(other): """Protocols must be comparable with == and !=""" def __ne__(other): """Protocols must be comparable with == and !=""" class IAdaptingProtocol(IProtocol): """A protocol that potentially knows how to adapt some object to itself""" def __adapt__(ob): """Return 'ob' adapted to protocol, or 'None'""" class IConformingObject(Interface): """An object that potentially knows how to adapt to a protocol""" def __conform__(protocol): """Return an implementation of 'protocol' for self, or 'None'""" class IOpenProvider(Interface): """An object that can be told how to adapt to protocols""" def declareProvides(protocol, adapter=NO_ADAPTER_NEEDED, depth=1): """Register 'adapter' as providing 'protocol' for this object Return a true value if the provided adapter is the "shortest path" to 'protocol' for the object, or false if a shorter path already existed. """ class IOpenImplementor(Interface): """Object/type that can be told how its instances adapt to protocols""" def declareClassImplements(protocol, adapter=NO_ADAPTER_NEEDED, depth=1): """Register 'adapter' as implementing 'protocol' for instances""" class IOpenProtocol(IAdaptingProtocol): """A protocol that be told what it implies, and what supports it Note that these methods are for the use of the declaration APIs only, and you should NEVER call them directly.""" def addImpliedProtocol(proto, adapter=NO_ADAPTER_NEEDED, depth=1): """'adapter' provides conversion from this protocol to 'proto'""" def registerImplementation(klass, adapter=NO_ADAPTER_NEEDED, depth=1): """'adapter' provides protocol for instances of klass""" def registerObject(ob, adapter=NO_ADAPTER_NEEDED, depth=1): """'adapter' provides protocol for 'ob' directly""" def addImplicationListener(listener): """Notify 'listener' whenever protocol has new implied protocol""" class IImplicationListener(Interface): def newProtocolImplied(srcProto, destProto, adapter, depth): """'srcProto' now implies 'destProto' via 'adapter' at 'depth'""" PKW6Jsttprotocols/_speedups.pydMZ@ !L!This program cannot be run in DOS mode. $PEL$BF# 8Np` N.text4LN``.data `R@.rdatapX@@.bss.edataN^@@.idata `@.reloc j@BUWVS } |$]M\$ $Fƃ 1t[tE 9rtЋ9st&$K1҉$JuuF1t&e[^_] t&$JtlGF&v'9rtЋ9st&$1fJ=$DJoZJ 1_'UET$L$$IɃÍUEL$T$$IÐU]GUS$EЁEED$ED$D$ `D$ pED$E $t=EEE] ;u EP$RE8u EP$RډЃ$[]US$EEED$ED$D$ `D$ pED$E $tEEEE8u EP$RE8u EP$RډЃ$[]US$]EED$D$ `D$pED$E $tSEEC8u CP$REC ;u C$PE8u EP$RЃ$[]U(]u}]u }95u]Z|$t$C$‰Eu=p`Pit :u B$P$p\>E ;u C$P>u F4$P?u G<$PE]u}]UWVS EU EpD$@$9Åup`Pl$lƅup`PlF t$$$Džup`Plm ;u C$P>u F4$PD$D$<$v:?u G<$Pp`Plt ;u C$Pt>u F4$Pt?u G<$P$5p<U :u B$PE 8u U B$PE8u UB$P [^_]UWVS EU pD$@$7Åup`Po$lƅup`PoF t$$$Džup`Pom ;u C$P>u F4$PD$D$<$8?u G<$Pp`Pot ;u C$Pt>u F4$Pt?u G<$P$Tp:E8u UB$PE 8u U B$P [^_]UWVSEEEEU E5=UE P;tD$$xtt9E U9BtD$B$xtt U U B;u.UB;u E D$$<t UC D$E$,ÅE>u F4$Pu ;u C$P$lEup`PU EP D$4$$Eup`PIU :u B$PE?u G<$P}E9=@M }tE8u UB$P}tE8u UB$PED$@$14Eup`PtE$ȡËU :u B$PED$tp84Eup`PE8u UB$PEPD$0$y3Eup`PD$E$$Eup`PU :u B$P$Eup`PDED$U$4Eup`PE8u UB$PE8u UB$PED$E$,Eup`PU :u B$PEE9؋U :u B$PEl5p`P:$ȡtġj1Eup`PE8u UB$PEEE4p`PD$U $,ÅE>u F4$PuE ;u C$P$lEup`P|EUB T$4$$Eup`PEE8u UB$PE?u G<$P}9=j }tE8u UB$P}tE8u UB$PE}tE8u UB$PED$@$/Eup`P$E$ȡËU :u B$PE$tp3/Eup`PE8u UB$PEPD$0$)/Eup`PlD$E$$Eup`P6U :u B$PE$Eup`PED$U$4Eup`PE8u UB$PE8u UB$PED$E$,Eup`PNU :u B$PEE9؋U :u B$PE1p`P$ȡtġj-Eup`PE8u UB$PEEE0p`P]U;E`D$0$,Eup`P$lEup`PUB EBU EPD$U$$Eup`PE8u UB$PEE8u UB$PED$D$E$x-U :u B$PEp`P Eb}tU :u B$P}tE8u UB$P}tE8u UB$P$tp|/>u F4$P?u G<$PE8u UB$PE8u UB$PE 8u U B$PE8u UB$P؃[^_]US4EEEED$ED$ED$D$ aD$pED$E $EEEED$ED$E$‰Åu;p`Pt :u B$P$p-.E8u EP$RE8u EP$RE8u EP$RډЃ4[]US4EEEED$ED$ED$D$ bD$pED$E $EEEED$ED$E$‰Åu;p`Pt :u B$P$p-E8u EP$RE8u EP$RE8u EP$RډЃ4[]UWVS}5|$E $ up`P?u G<$P}tUGE9}FE\ >u F4$PދE D$$`Åt 8u @$PG;}|;p`Pt ;u C$P$p+>u F4$P؃[^_]UWVS,EEEED$ED$D$ (bD$ pED$E $"EE5E@;K$Åup`P=>u F4$Pމ\$E$Åup`P8u @$PE$@yp`P\$4$ up`P~ ;u C$P\$4$ up`P9 ;u C$PuD$@$%Åup`P$lDžup`PЃЃG EEG|$$$Eup`Pu ;u C$P?u G<$PD$D$E$K&U :u B$PEp`Pt ;u C$Pt?u G<$P}tE8u UB$P$pg(>u F4$PE8u EP$RE8u EP$RډЃ,[^_]UWVS E5D$U $ up`P D$E$,Åup`P$8Džup`P ;u C$P<$Åu"ԡtQp`Pi>u F4$PދU T$$Åt,8u@$P?u G<$POp`Pt ;u C$Pt?u G<$P$q&>u F4$PE8u UB$P؃ [^_]UVS E EED$ED$D$ 4bD$ pED$E $EE5$Åup`P>u F4$Pމ\$E$Åup`P8u @$PE$@yp`P\$4$ up`PX ;u C$P\$4$ up`P ;u C$P%t ;u C$P$q$>u F4$PE8u EP$RE8u EP$RډЃ [^]UWVS,EE0EED$ED$D$ @bD$ pED$E $,EEE@;ЂD$0$kDžup`P V$lƅup`P (EEF EEFt$<$$Eup`P ?u G<$P>u F4$P]UB;tD$B$xtt<D$E$,ljÅp`P JUB;tD$B$xtD$0$ƅup`P$lEup`PEEUB EEBT$4$$Džup`Pg>u F4$PE8u UB$P$lƅup`PEEF Ut?u G<$Pt>u F4$P}tE8u UB$P$/q E8u EP$RE8u EP$RډЃ,[^_]UWVSLEEEEEED$ED$D$ LbD$@qED$E $gEEEUEUEUB;u rU :u B$Pu4D$0${ƅup`P) D$E$,>u F4$Pt6E8u UB$Pu ;C$P$ȡt)ġEpE8u UB$Pudƅup`P6 E8u UB$Pup`P7 UB;tD$B$xtt E苘t$U :u B$PuKUB;!$ƅup`PN E8u UB$Put$E$ƅup`PO 8u @4$P5t$U$ up`PPv >u F4$P5t$E$ up`PQ. >u F4$PD$U$,Åt;E8u UB$Pu ;C$PUB;tD$B$xt(ġD$0$ƅup`P^H $Eԅup`P^ $lEЅup`P^EUЉB EԉBT$4$$Eԅup`P^>u F4$PU :u B$PE8u UB$PEԉEEaHƅup`Pc7U :u B$Pu>p`PdD$E$,EЅup`PrD$EЉ$,Eԅup`PrU :u B$PEE8u U܋B$PEԉEEUB;tttD$B$xtEx9&Ut E8u UB$Pu$lEЅEUЉB T$E܉$$EԅU :u B$PEE8u U؋B$PEԉEE9$ƅD$U؉$4EЅ>u F4$P$lEԅwEEUԉB T$EЉ$$ƅjU :u B$PE8u UԋB$PC9UB;tD$B$xtEx9gUB EE8u UB$PEЉEE$lEԅUP D$E܉$$ƅU :u B$PEE8u U؋B$PuؾE9$EЅgD$U؉$4EԅgE8u UЋB$PE$lƅNEEF t$Eԉ$$EЅCU :u B$P>u F4$P]UC9E$8Eԅup`PUԉ$ƅu)ԡp`PeE8u UB$Pu$lEЅEUЉB T$E܉$$ƅ|U :u B$PEE8u U؋B$PuؾE9#$EЅ5D$U؉$4ƅ3E8u UЋB$P$lEЅEEUЉB T$4$$E̅>u F4$PE8u UЋB$P]̋E8UԋB$PnE8u UԋB$PKp`Pxp`Pzp`Pzp`Pzfp`PzKp`P0p`Pp`Pp`Pp`Pp`Pp`Pp`Pvp`P^p`PFp`P.p`Pp`Pxt>u F4$P}tE8u UԋB$P}tE8u UЋB$P}tE8u ŰB$P$CquE8u UB$PE8u UB$PE8u UB$PE8u U܋B$PE8u U؋B$PE8u EP$RE8u EP$RډЃL[^_]UED$$PUS]{tC8u CP$RC$[]UUztED$B$U …uUS]{tC8u CP$RC[]UU EuuD$T$E$UMU EtD$T$ $ T$ $?UWVS1 D$D$ D$`D$`d$r0up`P $r@up`P_ @D$D$r0$Hyp`P! $`byp`P $@c4yp`P (@d$c|yp`P^Y D$cD$Xr0$Hyp`P^  c$Åup`PS S BS BS B S BЂS ЂBS BS B\$@D$0$Dyp`P ;u C$P$Åup`P@PS P\$ $ƅup`P@ ;u C$PPD$4$,Åup`P@WD$PD$0$Dyp`P@ ;u C$P>u F4$P$ƅup`PA`V `t$`$Åup`PA>u F4$P`D$$,ƅup`PADD$`D$0$Dyp`PA >u F4$P ;u C$P$Åup`PDCpS p\$p$ƅup`PD ;u C$PpD$4$,Åup`PDD$pD$0$Dyp`PD ;u C$P>u F4$PpD$0$ƅup`PE*8uP$R5lt ;u C$Pt>u F4$P0D$@$Åup`PF$ȡE ;u C$P}$rk mƅup`PF8u @4$P@D$@$Åup`PGg$Lƅup`PG= ;u C$P8uP$R5@D$@$FÅup`PID$$$ƅup`PI ;u C$P8uP$R5$;`XÅup`PJ<8uP$R$G`Xƅup`PK8uP$R5$Q`XÅup`PLD$D$0$Dyp`PL\ ;u C$P$[`Xƅup`PM8uP$R5ЁPD$@$Åup`PPD$@$ƅup`PE PD$@$yDžup`P0Ht ;u C$Pt>u F4$Pt?u G<$P$rJ[^_]Upd]UWVS,u EED$s@$0Åtkuu$DžteE0$ƅt:Et-ED$UT$t$ ED$D$s$ Et?u G<$Pt ;u C$P}tE8u UB$PE,[^_]U]uu t$E$,Åut$$ܡ؋]u]UVS EEE`ÍED$ED$E$̡ED$ED$E$Сԡ}u E{4tC48u C4P$R{8tC88u C8P$R{<tC<8u Cu F4$P,t(F;htD$s$'u!=ڋ[  :u B$PC;tttD$C$xt $pC;\t\D$C$xt"D$@s$xC;tmD$C$xuTC;tI9=tD$ls$:?u G<$PߋC;u[[t$|$$ءu F4$P [^_]U`H4P8@u F4$P}tE8u UB$P}tE8u UB$P}tE8u UB$PL[^_]Ð%%%l%$%x%<%,%ȡ%%4%ġ% %%@%8%%ԡ%%%H%(%|%D%L%X%0%%% %ܡ%`%̡%С%%p%%ء%T%P%%%dU] Ue8t eQAeuÍ&US \t)t' \Ku$WY[]1=$\ @$\u뾍'US u5 \ t$tt& \Ku$W芹X[]1=$\ @$\uÐUtQtr]ÐUp]HUBSdT$U1ۉT$$| uFJx|*Au Jy;size == sizeof(W32_EH_SHARED)%s:%u: failed assertion `%s' ../../gcc/gcc/config/i386/w32-shared-ptr.cGetAtomNameA (atom, s, sizeof(s)) != 0$BF2(,0A@_speedups.pydinit_speedupsTxthȢԢܢ0DTdṭ(@\pԤ$8Ph|ԥ0@Xx̦$4DXȢԢܢ0DTdṭ(@\pԤ$8Ph|ԥ0@Xx̦$4DXAddAtomAFindAtomAGetAtomNameA$__dllonexit_errno_iobabort0fflush9fprintf?freermallocPyArg_ParseTupleAndKeywordsPyBaseObject_Type(PyClass_Type*PyCode_NewPPyDict_New\PyErr_Clear^PyErr_ExceptionMatches_PyErr_FetchdPyErr_NormalizeExceptionePyErr_OccurrediPyErr_RestorewPyErr_SetObjectxPyErr_SetStringzPyErr_WarnPyExc_AttributeErrorPyExc_DeprecationWarningPyExc_NameErrorPyExc_TypeErrorPyFrame_NewPyImport_AddModulePyInstance_TypePyInt_FromLong PyIter_Next PyList_AppendPyList_NewPyList_Type@PyMethod_NewFPyModule_GetDictPyObject_CallFunctionPyObject_CallObjectPyObject_GC_DelPyObject_GetAttrPyObject_GetAttrStringPyObject_GetItemPyObject_GetIterPyObject_IsInstancePyObject_IsTruePyObject_SetAttrPyObject_SetAttrStringPyObject_TypePyString_FromStringPyString_FromStringAndSizePyString_InternFromString PyString_TypePyThreadState_Get5PyTraceBack_Here7PyTraceBack_Type;PyTuple_New=PyTuple_Size>PyTuple_TypeAPyType_IsSubtypeBPyType_ReadyCPyType_TypePy_InitModule4_Py_NoneStructKERNEL32.dllmsvcrt.dll(((((((((((((((((((((((((((((((((((((((((((((((((((((((python23.dllhC0M0q0000001,1b1l1111122t2222223&3933333344444444444455555555H6Q6d6k6q66666666666>7E7K778 88)808=8j88888899&9,9M9Y9`9f999:::#:8:c:y:::::::::; ;;:;F;M;S;o;{;;;;;;;;R>f>m>s>>>>>>? ??%?+?H?T?[?a?????????  000<0C0I0u0000000000-141:1L1W1`1t1{111111111122222233334"4(4G4444445;5A5`555555x666666 77&7C7Q7d7o7v7|777777778$8.858;8Z8i8s8z88888888888 99.9:9A9G9999 :}::::::::::::;;(;4;=;D;J;;;;;;6v>~>>>>>>>>> ???B?N?U?[?????????000%0;0D0W0^0d0z000000001%1,12112212M2X2b2m2w22222222B3M3W333333333 4U4h4s4z44444445 5505B5L5S5Y5555556662696?6U6a6h6n666666666C7J7P7~7777777777777P8W8g88839F9`999::&:::: ;$;Y;~;;;;;;<<<">>>!>/>6><>J>Q>W>e>l>r>>>>>>>>>>>>>>>>????&?,?7?>?D?O?V?\?g?n?t?????@000m1u1112&2-23282A2H2N2^2d2i2r2y222222222222223 33!3&3-32393>3E3J3Q3V3]3b3i3o3x3333333333333333444#4+454=4G4O4Y4a4k4s4}444444444444555$575>5D5b5o5z5555555555666"6,676J6Q6W6u6666666666677!7'757?7J7]7d7j7777777777778#868=8C8N8Z8i8888888 99%9+9N9W9j9q9w9999999999:: :':2:9:?:]:i:x::::::::::::::;;;*;0;;;B;H;Z;c;l;u;|;;;;;;;;;;;;< <<<i>t>>>>>>PD0-070<0G0V0z000000000000111'1,171T1q111 2T22222223 3 3l3y3333R4b4r44444444455"525B5R5b5r55555555566"626B6R6b6r6666666677787S7]7n7y7777777788 828a8888889959K9Z9b9j9r9|99999999:::J:U:`:k:v::::::::::C;S;r;;;;;;;;;<$<`0000011122 2(2,24282@2D2L2P2`2d2h2l2p2t2x2|222222222222222222222222222222222333 33333 3$3@3D3L3P3X3\3d3h3p3t33333333344(4,444<4`4d4l4p4t4|44444444444444445PKW6D&&protocols/api.pyc; AFc@srdZddddddddgZeZd klZlZlZd kl Z e e fZ d k l Z lZlZd k lZd klZlZdklZlZlZdklZlZedZydklZWnej onXddZddZddZei eei efffdZ!ffdZ"ffdZ#dZ$dS(sAdapter and Declaration APIsadaptsdeclareAdapterForTypesdeclareAdapterForProtocolsdeclareAdapterForObjectsadvisesdeclareImplementationsdeclareAdapters adviseObject(s _getframesexc_infosmodules(s ClassType(sNO_ADAPTER_NEEDEDsDOES_NOT_SUPPORTsAdaptationFailure(s bindAdapter(sdecorate_classs frameinfo(s IOpenProtocols IOpenProvidersIOpenImplementor(sProtocolsInterfaceClasscCsKt|to t||o|Sny |i}Wntj on[Xy%||}|tj o|SnWn1t j o%t di tj oqnXy |i }Wntj on[Xy%||}|tj o|SnWn1t j o%t di tj oq nX|tjotd||n|SdS(sPEP 246-alike: Adapt 'obj' to 'protocol', return 'default' If 'default' is not supplied and no implementation is found, the result of 'factory(obj,protocol)' is returned. If 'factory' is also not supplied, 'NotImplementedError' is then raised.is Can't adaptN(s isinstancesprotocols ClassTypessobjs __conform__s_conformsAttributeErrorsresultsNones TypeErrorsexc_infostb_nexts __adapt__s_adaptsdefaults_markersAdaptationFailure(sobjsprotocolsdefaults_conformsresults_adapt((s&build\bdist.win32\egg\protocols\api.pysadapt*s8            (sadapticCsgt||}t|ti|||}t|tt }|t j o|i |||ndS(s>Declare that 'adapter' adapts instances of 'typ' to 'protocol'N( s bindAdaptersadaptersprotocolsadapts IOpenProtocolsregisterImplementationstypsdepthsIOpenImplementorsNonesoisdeclareClassImplements(sprotocolsadapterstypsdepthsoi((s&build\bdist.win32\egg\protocols\api.pysdeclareAdapterForType[s  cCs6t|tt|ti|t|||dS(s3Declare that 'adapter' adapts 'proto' to 'protocol'N(sadaptsprotocols IOpenProtocolsprotosaddImpliedProtocols bindAdaptersadaptersdepth(sprotocolsadaptersprotosdepth((s&build\bdist.win32\egg\protocols\api.pysdeclareAdapterForProtocolhs cCs)t|ti|t|||dS(s0Declare that 'adapter' adapts 'ob' to 'protocol'N(sadaptsprotocols IOpenProtocolsregisterObjectsobs bindAdaptersadaptersdepth(sprotocolsadaptersobsdepth((s&build\bdist.win32\egg\protocols\api.pysdeclareAdapterForObjectnsc Csxxq|D]i}x|D]}t|||qWx|D]}t|||q5Wx|D]}t |||qVWqWdS(s>'factory' is an IAdapterFactory providing 'provides' protocolsN( sprovidessprotocolsforTypesstypsdeclareAdapterForTypesfactorys forProtocolssprotosdeclareAdapterForProtocols forObjectssobsdeclareAdapterForObject( sfactorysprovidessforTypess forProtocolss forObjectssobsprotocolsprotostyp((s&build\bdist.win32\egg\protocols\api.pysdeclareAdapter~scCsFx|D]}t|t|qWx|D]}t|t|q(WdS(s>Declare information about a class, type, or 'IOpenImplementor'N(sinstancesProvidesprotosdeclareAdapterForTypesNO_ADAPTER_NEEDEDstypsinstancesDoNotProvidesDOES_NOT_SUPPORT(stypsinstancesProvidesinstancesDoNotProvidesproto((s&build\bdist.win32\egg\protocols\api.pysdeclareImplementationscCsFx|D]}t|t|qWx|D]}t|t|q(WdS(s.Tell an object what it does or doesn't provideN(sprovidessprotosdeclareAdapterForObjectsNO_ADAPTER_NEEDEDsobsdoesNotProvidesDOES_NOT_SUPPORT(sobsprovidessdoesNotProvidesproto((s&build\bdist.win32\egg\protocols\api.pys adviseObjectsc s|i}td}t|\} }}}| djoR|i df} |d=x|D]}t d|q]Wt |d| dSn| djotdn|i df|i d f|i d f|i d f|i d f|i d f|i df|i df |i dt|i dft|idix|D]}t d|q}W d}t|dS(NismodulesmoduleProvidess1Invalid keyword argument for advising modules: %ssprovidessclasss`protocols.advise() must be called directly in a class or module body, not in a function or exec.s classProvidessclassDoesNotProvidesinstancesProvidesinstancesDoNotProvidesasAdapterForTypessasAdapterForProtocolssprotocolExtendssprotocolIsSubsetOfs factoryMethodsequivalentProtocolssclassProvides classDoesNotProvide instancesProvide instancesDoNotProvide asAdapterForTypes asAdapterForProtocols protocolExtends protocolIsSubsetOf factoryMethod equivalentProtocolss1Invalid keyword argument for advising classes: %scsKp ot|dd npot|ddnpoU ot dnot |}n|}t |ddnot dnot td|gnot t|gdno0t td|gt t|gdn|SdS( NsprovidessdoesNotProvidesinstancesProvidesinstancesDoNotProvidesLWhen declaring an adapter, you must specify what its instances will provide.sforTypess forProtocolss;'factoryMethod' is only used when declaring an adapter type(s classProvidessclassDoesNotProvides adviseObjectsklasssinstancesProvidesinstancesDoNotProvidesdeclareImplementationsasAdapterForTypessasAdapterForProtocolss TypeErrors factoryMethodsgetattrsfactorysdeclareAdaptersprotocolExtendssNO_ADAPTER_NEEDEDsprotocolIsSubsetOfsequivalentProtocols(sklasssfactory( sasAdapterForTypessprotocolExtendssasAdapterForProtocolssequivalentProtocolssinstancesProvides factoryMethodsinstancesDoNotProvides classProvidessprotocolIsSubsetOfsclassDoesNotProvide(s&build\bdist.win32\egg\protocols\api.pyscallbacks6   (skwscopys _getframesframes frameinfoskindsmodules caller_localsscaller_globalss setdefaultsmoduleProvidessks TypeErrors adviseObjects SyntaxErrors classProvidessclassDoesNotProvidesinstancesProvidesinstancesDoNotProvidesasAdapterForTypessasAdapterForProtocolssprotocolExtendssprotocolIsSubsetOfsNones factoryMethodsequivalentProtocolssmaps __delitem__ssplitscallbacksdecorate_class(skwsframesmodules classProvidessclassDoesNotProvidesasAdapterForTypesscaller_globalss caller_localssinstancesDoNotProvidesasAdapterForProtocolssmoduleProvidessprotocolExtendsskindsequivalentProtocolssinstancesProvidesks factoryMethodscallbacksprotocolIsSubsetOf(( s classProvidessclassDoesNotProvidesasAdapterForTypessinstancesDoNotProvidesasAdapterForProtocolssprotocolExtendssequivalentProtocolssinstancesProvides factoryMethodsprotocolIsSubsetOfs&build\bdist.win32\egg\protocols\api.pysadvises<     '3N(%s__doc__s__all__sobjects_markerssyss _getframesexc_infosmodulesstypess ClassTypestypes ClassTypessadapterssNO_ADAPTER_NEEDEDsDOES_NOT_SUPPORTsAdaptationFailures bindAdapterspeak.util.decoratorssdecorate_classs frameinfos interfacess IOpenProtocols IOpenProvidersIOpenImplementorsProtocolsInterfaceClasssadapts _speedupss ImportErrorsdeclareAdapterForTypesdeclareAdapterForProtocolsdeclareAdapterForObjectsregisterImplementationsdeclareAdaptersdeclareImplementations adviseObjectsadvise(sdeclareAdapterForTypesdeclareAdapterForObjectsDOES_NOT_SUPPORTsdeclareImplementationsdeclareAdapters IOpenProvidersAdaptationFailures frameinfosdeclareAdapterForProtocolsdecorate_classsadaptsInterfaceClasssadvisesNO_ADAPTER_NEEDEDs_markers bindAdapters ClassTypess adviseObjectsProtocols__all__sIOpenImplementors ClassTypesmoduless _getframesexc_infos IOpenProtocol((s&build\bdist.win32\egg\protocols\api.pys?s0     )     PKW66fiiprotocols/zope_support.pyc; AFc@s<dZgZdklZdkTdklZlZlZdk l Z l Z dk l Z lZydkiZWnej ogZeZnXdZydklZWnOej oCydklZWqej oeeii_gZqXnXeieeiigZ[[d ee fd YZdS( s'Declaration support for Zope Interfaces(s ClassType(s*(sdeclareImplementationsadvisesadapt(s IOpenProtocolsProtocol(s metamethods supermetaNcCst|ti|SdS(N(sadaptsselfs IOpenProtocols __adapt__sobj(sselfsobj((s/build\bdist.win32\egg\protocols\zope_support.pys __adapt__s(s adapter_hookssZopeInterfaceAsProtocolcBstZedegdeefZdZeoeeddo dZn dZe dd Z e e Z e dd Z e e Z d Z d Zd ZdZRS(NsinstancesProvidesasAdapterForTypescCs!ti||ti|dS(N(s StickyAdapters__init__sselfsobsProtocol(sselfsob((s/build\bdist.win32\egg\protocols\zope_support.pys__init__3sis providedBycCs5|ii|o|Sntt|i|SdS(N(sselfssubjects providedBysobjs supermetasZopeInterfaceAsProtocols __adapt__(sselfsobj((s/build\bdist.win32\egg\protocols\zope_support.pys __adapt__8scCs5|ii|o|Sntt|i|SdS(N(sselfssubjectsisImplementedBysobjs supermetasZopeInterfaceAsProtocols __adapt__(sselfsobj((s/build\bdist.win32\egg\protocols\zope_support.pys __adapt__=sicCs|tjoti||ine|tjoWtigi }ti |D]}||i qN~|i}ti||ntt|i|||SdS(N(sadaptersNO_ADAPTER_NEEDEDszisclassImplementssklasssselfssubjectsDOES_NOT_SUPPORTs Declarationsappends_[1]s implementedBysis__iro__sifacessclassImplementsOnlys supermetasZopeInterfaceAsProtocolsregisterImplementationsdepth(sselfsklasssadaptersdepthsifacessis_[1]((s/build\bdist.win32\egg\protocols\zope_support.pysregisterImplementationBs   CcCsu|tjoti||in2|tjo$ti|ti||int t |i |||SdS(N( sadaptersNO_ADAPTER_NEEDEDszisdirectlyProvidessobsselfssubjectsDOES_NOT_SUPPORTsdirectlyProvidedBys supermetasZopeInterfaceAsProtocolsregisterObjectsdepth(sselfsobsadaptersdepth((s/build\bdist.win32\egg\protocols\zope_support.pysregisterObjectSs   $cCsntt|i}t|gi}|ii D]0}|t i j o||t dffq2q2~SdS(Ni(ssupersZopeInterfaceAsProtocolsselfsgetImpliedProtocolssprotosslistsappends_[1]ssubjects __bases__siszis InterfacesNO_ADAPTER_NEEDED(sselfsis_[1]sprotos((s/build\bdist.win32\egg\protocols\zope_support.pysgetImpliedProtocolsbscCs%|ii}|d=|d=|SdS(Ns_Protocol__locks_Protocol__listeners(sselfs__dict__scopysstate(sselfsstate((s/build\bdist.win32\egg\protocols\zope_support.pys __getstate__jscCst|iSdS(N(shashsselfssubject(sself((s/build\bdist.win32\egg\protocols\zope_support.pys__hash__pscCst|i|SdS(N(scmpsselfssubjectsother(sselfsother((s/build\bdist.win32\egg\protocols\zope_support.pys__cmp__ss(s__name__s __module__sadvises IOpenProtocolsZopeInterfaceTypessattachForProtocolss__init__shasattrs __adapt__sNO_ADAPTER_NEEDEDsregisterImplementations metamethodsregisterObjectsgetImpliedProtocolss __getstate__s__hash__s__cmp__(((s/build\bdist.win32\egg\protocols\zope_support.pysZopeInterfaceAsProtocol,s           (s__doc__s__all__stypess ClassTypesadapterssapisdeclareImplementationsadvisesadapts interfacess IOpenProtocolsProtocolsadvices metamethods supermetaszope.interfaces interfaceszis ImportErrorsZopeInterfaceTypessNones __adapt__s adapter_hooksszope.interface.interfaces Interfaces __class__sappends StickyAdaptersZopeInterfaceAsProtocol(sProtocolszis__all__s ClassTypes metamethodsZopeInterfaceTypess __adapt__sadapts adapter_hookssdeclareImplementationsadvises supermetas IOpenProtocolsZopeInterfaceAsProtocol((s/build\bdist.win32\egg\protocols\zope_support.pys?s0    PKW6羏<%<%protocols/generate.pyc; AFc @s\dZdklZlZlZdklZlZdkl Z l Z dkl Z l Z dk lZdddd d d d d dg Zd efdYZd efdYZd eefdYZdefdYZd efdYZe edegdeegdZeZhZdZfedZdZdZdS(sCAutogenerated protocols from type+method names, URI, sequence, etc.(sProtocols allocate_locks Interface(s metamethods supermeta(sdeclareAdapterForProtocolsdeclareAdapterForType(sdeclareAdaptersadapt(sNO_ADAPTER_NEEDEDsprotocolForTypesprotocolForURIs sequenceOfsIBasicSequences URIProtocols TypeSubsets WeakSubsetsADAPT_SEQUENCEsSequenceProtocolcBs)tZdZdZdZdZRS(sEProtocol representing a URI, UUID, or other unique textual identifiercCs||_ti|dS(N(surisselfsURIsProtocols__init__(sselfsuri((s+build\bdist.win32\egg\protocols\generate.pys__init__s cCsd|iSdS(NsURIProtocol(%r)(sselfsURI(sself((s+build\bdist.win32\egg\protocols\generate.pys__repr__scCst|iffSdS(N(sprotocolForURIsselfsURI(sself((s+build\bdist.win32\egg\protocols\generate.pys __reduce__s(s__name__s __module__s__doc__s__init__s__repr__s __reduce__(((s+build\bdist.win32\egg\protocols\generate.pys URIProtocols   cBs)tZdZdZdZdZRS(s2Protocol representing some set of a type's methodscCs#||_||_ti|dS(N(sbaseTypesselfsmethodssProtocols__init__(sselfsbaseTypesmethods((s+build\bdist.win32\egg\protocols\generate.pys__init__.s  cCsd|i|ifSdS(NsTypeSubset(%r,%r)(sselfsbaseTypesmethods(sself((s+build\bdist.win32\egg\protocols\generate.pys__repr__3scCst|i|itffSdS(N(sprotocolForTypesselfsbaseTypesmethodssFalse(sself((s+build\bdist.win32\egg\protocols\generate.pys __reduce__6s(s__name__s __module__s__doc__s__init__s__repr__s __reduce__(((s+build\bdist.win32\egg\protocols\generate.pys TypeSubset*s   cBs;tZdZeZdZeeZdZdZRS(s<TypeSubset that accepts any object with the right attributescCsbtt|i|}|tj o|Snx.|iD]}t || otSq7q7W|SdS(N( s supermetas TypeSubsetsselfs __adapt__sobsresultsNonesmethodssnameshasattr(sselfsobsnamesresult((s+build\bdist.win32\egg\protocols\generate.pys __adapt__Ys   cCsd|i|ifSdS(NsWeakSubset(%r,%r)(sselfsbaseTypesmethods(sself((s+build\bdist.win32\egg\protocols\generate.pys__repr__iscCst|i|itffSdS(N(sprotocolForTypesselfsbaseTypesmethodssTrue(sself((s+build\bdist.win32\egg\protocols\generate.pys __reduce__ls( s__name__s __module__s__doc__stypes __metaclass__s __adapt__s metamethods__repr__s __reduce__(((s+build\bdist.win32\egg\protocols\generate.pys WeakSubsetSs   cBs)tZdZdZdZdZRS(s8Protocol representing a "sequence of" some base protocolcCs||_ti|dS(N(s baseProtocolsselfsProtocols__init__(sselfs baseProtocol((s+build\bdist.win32\egg\protocols\generate.pys__init__s cCsd|iSdS(NssequenceOf(%r)(sselfs baseProtocol(sself((s+build\bdist.win32\egg\protocols\generate.pys__repr__scCst|iffSdS(N(s sequenceOfsselfs baseProtocol(sself((s+build\bdist.win32\egg\protocols\generate.pys __reduce__s(s__name__s __module__s__doc__s__init__s__repr__s __reduce__(((s+build\bdist.win32\egg\protocols\generate.pysSequenceProtocol|s   cBstZdZdZRS(s$Non-string, iterable object sequencecCsdS(s$Return an iterator over the sequenceN((((s+build\bdist.win32\egg\protocols\generate.pys__iter__s(s__name__s __module__s__doc__s__iter__(((s+build\bdist.win32\egg\protocols\generate.pysIBasicSequences sprovidessforTypescCset}g}|i}xB|D]:}t|||}||jotSn|i |qW|SdS(s?Convert iterable 'ob' into list of objects implementing 'proto'N( sobjectsmarkersoutsprotos baseProtocolsobsitemsadaptsNonesappend(sobsprotositemsmarkersout((s+build\bdist.win32\egg\protocols\generate.pysADAPT_SEQUENCEs   cCsZtiz>y t|SWn+tj ot|}t|<|SnXWdtiXdS(sBReturn a unique protocol object representing the supplied URI/UUIDN(s__registryLocksacquiresregistrysurisKeyErrors URIProtocolsprotosrelease(surisproto((s+build\bdist.win32\egg\protocols\generate.pysprotocolForURIs   cCsntgi}|D]}|||fq~i}|it|}||| f}t |SdS(sEReturn a protocol representing a subset of methods of a specific typeN( sdictsappends_[1]smethodsskskeysssortstuplesbaseTypesimplicitskeys__protocolForType(sbaseTypesmethodssimplicitsks_[1]skey((s+build\bdist.win32\egg\protocols\generate.pysprotocolForTypes 9  cs|t|f}tizTy t|SWnAtj o5t|t|sN( s sequenceOfs baseProtocolskeys__registryLocksacquiresregistrysKeyErrorsSequenceProtocolsprotosdeclareAdapterForProtocolsIBasicSequencesrelease(s baseProtocolsprotoskey((sprotos+build\bdist.win32\egg\protocols\generate.pys sequenceOfs    c CsStizhy t|SWnUtj oI|\}}}|ot||}nt ||}|t|N( s__doc__s interfacessProtocols allocate_locks Interfacesadvices metamethods supermetasapisdeclareAdapterForProtocolsdeclareAdapterForTypesdeclareAdaptersadaptsadapterssNO_ADAPTER_NEEDEDs__all__s URIProtocols TypeSubsetsobjects WeakSubsetsSequenceProtocolsIBasicSequencesliststuplesADAPT_SEQUENCEs__registryLocksregistrysprotocolForURIsFalsesprotocolForTypes sequenceOfs__protocolForType(sdeclareAdapterForTypes__registryLocks sequenceOfs__all__s metamethodsdeclareAdapterForProtocolsprotocolForTypes TypeSubsetsadapts InterfacesADAPT_SEQUENCEsSequenceProtocolsIBasicSequences WeakSubsetsprotocolForURIsdeclareAdaptersregistrys__protocolForTypesProtocols allocate_locksNO_ADAPTER_NEEDEDs supermetas URIProtocol((s+build\bdist.win32\egg\protocols\generate.pys?s* !))  )   )PKW6s$""protocols/advice.pyc; AFc @s~dklZdklZdklZlZlZdkZdddddd d d d d ddg Z dk l Z de dZ de dZdZe dZdZdZydklZWnej o eZnXeefZedZedZydklZlZlZWnej onXdZdZdklZd efdYZd Z dS(!(s generators(sinstancemethod(s ClassTypes FunctionTypes InstanceTypeNs metamethods supermetasgetMROs classicMROsmkRefs StrongRefsaddClassAdvisorsisClassAdvisorsadd_assignment_advisorsdetermineMetaclasss getFrameInfos minimalBases(s decoratorsicCsBdkl}|titdti||pdd|SdS(s:protocols.advice.addClassAdvisor is deprecated, please use(swarniiiN( swarningsswarnsaddClassAdvisors__doc__sDeprecationWarnings decoratorssdecorate_classscallbacksdepthsframe(scallbacksdepthsframeswarn((s)build\bdist.win32\egg\protocols\advice.pysaddClassAdvisor.s  cCsBdkl}|titdti||pdd|SdS(sAprotocols.advice.add_assignment_advisor is deprecated, please use(swarniiiN( swarningsswarnsadd_assignment_advisors__doc__sDeprecationWarnings decoratorssdecorate_assignmentscallbacksdepthsframe(scallbacksdepthsframeswarn((s)build\bdist.win32\egg\protocols\advice.pysadd_assignment_advisor5s  cCs1dkl}|titdti|SdS(s7protocols.advice.getFrameInfo is deprecated, please use(swarniN(swarningsswarns getFrameInfos__doc__sDeprecationWarnings decoratorss frameinfosframe(sframeswarn((s)build\bdist.win32\egg\protocols\advice.pys getFrameInfo<s  cCs4dkl}|titdti||SdS(s=protocols.advice.determineMetaclass is deprecated, please use(swarniN( swarningsswarnsdetermineMetaclasss__doc__sDeprecationWarnings decoratorssmetaclass_for_basessbasess explicit_mc(sbasess explicit_mcswarn((s)build\bdist.win32\egg\protocols\advice.pysdetermineMetaclassCs  cCs1dkl}|titdti|SdS(s9protocols.advice.isClassAdvisor is deprecated, please use(swarniN(swarningsswarnsisClassAdvisors__doc__sDeprecationWarnings decoratorssmetaclass_is_decoratorsob(sobswarn((s)build\bdist.win32\egg\protocols\advice.pysisClassAdvisorJs  cstdSdS(sEWrapper for metaclass method that might be confused w/instance methodcsi||iS(N(sfuncs__get__sobs __class__(sob(sfunc(s)build\bdist.win32\egg\protocols\advice.pysUsN(sproperty(sfunc((sfuncs)build\bdist.win32\egg\protocols\advice.pys metamethodSs(sExtensionClassccsg}|i}|i}|d|xF|o>|}|Vt|}x|iD]}|||qRWq(W|o t Vt VndS(Ni( sstacksinsertspushspopsobsclsslensps __bases__sbsextendedClassics InstanceTypesobject(sobsextendedClassicsbspopspspushsstackscls((s)build\bdist.win32\egg\protocols\advice.pys classicMRO^s      cCsGt|tot||Snt|to |iSn|fSdS(N(s isinstancesobs ClassicTypess classicMROsextendedClassicstypes__mro__(sobsextendedClassic((s)build\bdist.win32\egg\protocols\advice.pysgetMROls  (s metamethodsgetMROs classicMROcst}|ijo}|intx\D]B}|jo/gi}D]}||i qi~PqHqHWt d|tdt fdY}|SdS(NsNot sub/supertypes:stheSupercstZdZRS(Ncstx]D]U}||joB||}y |i}Wntj o |Sq\X|SqqWti ||SdS(N( smrosdsnamesdescrs__get__sAttributeErrorsobstypsobjects__getattribute__sself(sselfsnamesdescrsd(stypsobsmro(s)build\bdist.win32\egg\protocols\advice.pys__getattribute__s    (s__name__s __module__s__getattribute__((sobsmrostyp(s)build\bdist.win32\egg\protocols\advice.pystheSupers(stypesobs starttypes__mro__smrostypsitersclssappends_[1]s__dict__s TypeErrorsobjectstheSuper(stypsobstheSupers_[1]smros starttypescls((stypsobsmros)build\bdist.win32\egg\protocols\advice.pys supermeta~s      *  cCsdkl}|dtdgi}|D]!}|tj o||q+q+~}g}xl|D]d}x[|D](}t ||o ||j oPqoqoW||jo|i |n|i|qbW|SdS(s DEPRECATED(swarnsAprotocols.advice.minimalBases is deprecated; please do not use itiN( swarningsswarnsDeprecationWarningsappends_[1]sclassesscs ClassTypes candidatessmsns issubclasssremove(sclassess_[1]scsmsnswarns candidates((s)build\bdist.win32\egg\protocols\advice.pys minimalBasess   8  (srefcBsAtZdZdZdZdZdZdZdZRS(s/Like a weakref, but for non-weakrefable objectssreferentcCs ||_dS(N(sreferentsself(sselfsreferent((s)build\bdist.win32\egg\protocols\advice.pys__init__scCs |iSdS(N(sselfsreferent(sself((s)build\bdist.win32\egg\protocols\advice.pys__call__scCst|iSdS(N(shashsselfsreferent(sself((s)build\bdist.win32\egg\protocols\advice.pys__hash__scCs|i|jSdS(N(sselfsreferentsother(sselfsother((s)build\bdist.win32\egg\protocols\advice.pys__eq__scCsd|iSdS(Ns StrongRef(%r)(sselfsreferent(sself((s)build\bdist.win32\egg\protocols\advice.pys__repr__s( s__name__s __module__s__doc__s __slots__s__init__s__call__s__hash__s__eq__s__repr__(((s)build\bdist.win32\egg\protocols\advice.pys StrongRefs     cGs5yt||SWntj ot|SnXdS(swReturn either a weakref or a StrongRef for 'ob' Note that extra args are forwarded to weakref.ref() if applicable.N(srefsobsargss TypeErrors StrongRef(sobsargs((s)build\bdist.win32\egg\protocols\advice.pysmkRefs (!s __future__s generatorssnewsinstancemethodstypess ClassTypes FunctionTypes InstanceTypessyss__all__s peak.utils decoratorssNonesaddClassAdvisorsadd_assignment_advisors getFrameInfosdetermineMetaclasssisClassAdvisors metamethodsExtensionClasss ImportErrors ClassicTypessFalses classicMROsgetMROs _speedupss supermetas minimalBasessweakrefsrefsobjects StrongRefsmkRef(s minimalBasessisClassAdvisors__all__s metamethods StrongRefs generatorssaddClassAdvisorsgetMROs decoratorss InstanceTypes getFrameInfosdetermineMetaclassssyssmkRefs ClassicTypessrefs classicMROsadd_assignment_advisorsinstancemethodsExtensionClasss ClassTypes supermetas FunctionType((s)build\bdist.win32\egg\protocols\advice.pys?s6   *&         ' ) PKW699protocols/__init__.pyc; AFc@sdZdkTdklZlZlZlZdklZdkTdk l Z l Z dk l Z dklZlZdklZlZdS( s!Trivial Interfaces and Adaptation(s*(sNO_ADAPTER_NEEDEDsDOES_NOT_SUPPORTsAdapters StickyAdapter(sAdaptationFailure(s metamethods supermeta(s ProviderMixin(sprotocolForTypesprotocolForURI(s sequenceOfsIBasicSequenceN(s__doc__sapisadapterssNO_ADAPTER_NEEDEDsDOES_NOT_SUPPORTsAdapters StickyAdaptersAdaptationFailures interfacessadvices metamethods supermetasclassics ProviderMixinsgeneratesprotocolForTypesprotocolForURIs sequenceOfsIBasicSequence( sIBasicSequencesAdaptationFailures sequenceOfsAdapters StickyAdaptersprotocolForTypesprotocolForURIsDOES_NOT_SUPPORTs ProviderMixins supermetas metamethodsNO_ADAPTER_NEEDED((s+build\bdist.win32\egg\protocols\__init__.pys?s  PKW6}E;;protocols/twisted_support.pyc; AFc@sdZgZdkTdklZdklZdklZde fdYZ ydk l Z lZlZWnej o gZnXede_egZd e fd YZd S( s*Declaration support for Twisted Interfaces(s*(sadvise(s IOpenProtocol(sWeakKeyDictionarysTwistedAdaptMethodcBs/tZdZdZdZdZdZRS(s/__adapt__ implementation for Twisted interfacessifacecCs ||_dS(N(sifacesself(sselfsiface((s2build\bdist.win32\egg\protocols\twisted_support.pys__init__5scCs/t||io|Sn|i|tSdS(N(sTwistedImplementssobjsselfsifacesNone(sselfsobj((s2build\bdist.win32\egg\protocols\twisted_support.pys__call__9scCs;|iiid}|tjo|Sn|||SdS(Ns __adapt__(sselfsifaces__dict__sgetsmethsNonesdefaultsob(sselfsobsdefaultsmeth((s2build\bdist.win32\egg\protocols\twisted_support.pysim_funcEs (s__name__s __module__s__doc__s __slots__s__init__s__call__sim_func(((s2build\bdist.win32\egg\protocols\twisted_support.pysTwistedAdaptMethod.s   (s implementss MetaInterfaces getInterfacescCs t|S(N(sTwistedAdaptMethodss(ss((s2build\bdist.win32\egg\protocols\twisted_support.pys`ssTwistedInterfaceAsProtocolcBsltZdZedegdedZdZeddZ eddZ edd Z d Z RS( NsifacesinstancesProvidesasAdapterForTypescCs ||_dS(N(sifacesself(sselfsiface((s2build\bdist.win32\egg\protocols\twisted_support.pys__init__scCs|ii|SdS(N(sselfsifaces __adapt__sobj(sselfsobj((s2build\bdist.win32\egg\protocols\twisted_support.pys __adapt__sicCst|}|tjo|it|f|_n]|t jo7|i|jo#|i |it||_qnt d|i||dS(Ns9Twisted interfaces can only declare support, not adapters( sTwistedGetInterfacessklasss oldImplementssadaptersNO_ADAPTER_NEEDEDsselfsifacestuples__implements__sDOES_NOT_SUPPORTsremoves TypeError(sselfsklasssadaptersdepths oldImplements((s2build\bdist.win32\egg\protocols\twisted_support.pysregisterImplementations   csk|i|iid|iidh}x*|iD]}|i |||qGWdS(Ncs |S(N(sadaptersosiface(so(sadaptersiface(s2build\bdist.win32\egg\protocols\twisted_support.pysss_Protocol__listeners( sselfsifaces adaptWithsprotos__dict__sgets listenersskeysslistenersnewProtocolImpliedsadaptersdepth(sselfsprotosadaptersdepthsifaceslisteners listeners((sadaptersifaces2build\bdist.win32\egg\protocols\twisted_support.pysaddImpliedProtocols   cCst|}|tjo|it|f|_n]|t jo7|i|jo#|i |it||_qnt d|i||dS(Ns9Twisted interfaces can only declare support, not adapters( sTwistedGetInterfacessobs oldImplementssadaptersNO_ADAPTER_NEEDEDsselfsifacestuples__implements__sDOES_NOT_SUPPORTsremoves TypeError(sselfsobsadaptersdepths oldImplements((s2build\bdist.win32\egg\protocols\twisted_support.pysregisterObjects   cCs)|iiidt}t||}|iidf}||jo||d|Sq q WdS(Ns__protocols_provided__i(sgetMROsselfsclss__dict__sgetsconfsprotocol(sselfsprotocolsconfscls((s*build\bdist.win32\egg\protocols\classic.pys __conform__Js   ( s__name__s __module__s__doc__sadvises IOpenProvidersIImplicationListenersNO_ADAPTER_NEEDEDsdeclareProvidess metamethodsnewProtocolImplieds __conform__(((s*build\bdist.win32\egg\protocols\classic.pys ProviderMixin*s    sconformsRegistrycBsStZdZdZedZdZdZedZ dZ dZ RS(sBHelper type for objects and classes that need registration supportcCsD||jo3|i}|tj o||d|Sq@ndS(Ni(sprotocolsselfssubjectsNone(sselfsprotocolssubject((s*build\bdist.win32\egg\protocols\classic.pys__call__Ws   cCsxt|D]v}|iid}|tjoq nt|t ot d||n||jo||d|Sq q WdS(Ns __conform__s&Incompatible __conform__ in base classi( sgetMROssubjectsclss__dict__sgetsconfsNones isinstancesconformsRegistrys TypeErrorsprotocol(sselfssubjectsprotocols checkSelfsconfscls((s*build\bdist.win32\egg\protocols\classic.pysfindImplementationcs   cCsk|i}|tjp ||jodSn||\}}t|||}t|||||dS(N( sselfssubjectsNonessrcProtos baseAdaptersdscomposeAdapterssadaptersdeclareAdapterForObjects destProtosdepth(sselfssrcProtos destProtosadaptersdepthsds baseAdapterssubject((s*build\bdist.win32\egg\protocols\classic.pysnewProtocolImplied|s  cCst|SdS(N(sidsself(sself((s*build\bdist.win32\egg\protocols\classic.pys__hash__scCs:|tj otdnt|i|t|SdS(Ns/__conform__ registry does not pass to instances(sobsNonesAttributeErrorsinstancemethodsselfsfindImplementationstypstype(sselfsobstyp((s*build\bdist.win32\egg\protocols\classic.pys__get__s cCs|i|ifSdS(N(sselfssubjectsitems(sself((s*build\bdist.win32\egg\protocols\classic.pys __getstate__scCs<|\}}|i|it|t||_dS(N(ssubjectsitemssselfsclearsupdatesdictsmkRef(sselfs.2ssubjectsitems((s*build\bdist.win32\egg\protocols\classic.pys __setstate__s  ( s__name__s __module__s__doc__s__call__sTruesfindImplementationsnewProtocolImplieds__hash__sNones__get__s __getstate__s __setstate__(((s*build\bdist.win32\egg\protocols\classic.pysconformsRegistrySs      sMiscObjectsAsOpenProviderc BsWtZdZedegdeeeee e gdZ e ddZ dZRS(sCSupply __conform__ registry for funcs, modules, & classic instancessinstancesProvidesasAdapterForTypescCstt|}x|D]}yI|iid}|tjo ||gjot |dt}nWn"t j ot d|nX|tj ot |t  ot d||qqW|iid}|tjo|i|}|_n||_||_dS(Ns __conform__s3Only objects with dictionaries can use this adapters*Incompatible __conform__ on adapted object(slistsgetMROsobsobssitems__dict__sgetsregsNonesgetattrsAttributeErrors TypeErrors isinstancesconformsRegistrysselfs newRegistrys __conform__(sselfsobsregsitemsobs((s*build\bdist.win32\egg\protocols\classic.pys__init__s"  icCs>t|i|||o!t|ti|it SndS(N( supdateWithSimplestAdaptersselfsregsprotocolsadaptersdepthsadapts IOpenProtocolsaddImplicationListenersTrue(sselfsprotocolsadaptersdepth((s*build\bdist.win32\egg\protocols\classic.pysdeclareProvidesscCs t}t||_|SdS(N(sconformsRegistrysregsmkRefssubject(sselfssubjectsreg((s*build\bdist.win32\egg\protocols\classic.pys newRegistrys (s__name__s __module__s__doc__sadvises IOpenProviders FunctionTypes ModuleTypes InstanceTypes ClassTypestypesobjects__init__sNO_ADAPTER_NEEDEDsdeclareProvidess newRegistry(((s*build\bdist.win32\egg\protocols\classic.pysMiscObjectsAsOpenProviders   N(s__doc__s__all__stypess FunctionTypes ModuleTypes InstanceTypes ClassTypesadapterssapisdeclareImplementationsadvisesdeclareAdapterForObjectsadapts interfacessnewsinstancemethodsadvicesgetMROs metamethodsmkRefs ProviderMixinsdictsconformsRegistrysobjectsMiscObjectsAsOpenProvider(sdeclareAdapterForObjects__all__s ClassTypes metamethodsconformsRegistrysinstancemethodsgetMROsMiscObjectsAsOpenProviders ProviderMixinsadaptsmkRefsdeclareImplementations ModuleTypes FunctionTypes InstanceTypesadvise((s*build\bdist.win32\egg\protocols\classic.pys?s  )RPKW64?,protocols/adapters.pyc; AFc @s,dZddddddddd g Zd klZlZlZyeWn)ej od efd YZnXde e fd YZ e dZ e dZydkl Z lZWnej onXdefdYZdefdYZdddZdZdZdZdS(s%Basic Adapters and Adapter OperationssNO_ADAPTER_NEEDEDsDOES_NOT_SUPPORTsAdaptersminimumAdapterscomposeAdapterssupdateWithSimplestAdapters StickyAdaptersAdaptationFailures