Python interface.classImplements函数代码示例

 def afterSetUp(self):
     classImplements(ATDocument, IOrderable)
     # have to delete previously created content manually
     # because of test isolation problems
     if 'test' in self.portal:
         del self.portal['test']
         transaction.commit()

    def test_builtins(self):
        # Setup

        intspec = implementedBy(int)
        olddeclared = intspec.declared

        classImplements(int, I1)
        class myint(int):
            implements(I2)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I1'])

        x = myint(42)
        directlyProvides(x, I3)
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I3', 'I2', 'I1'])

        # cleanup
        intspec.declared = olddeclared
        classImplements(int)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         [])

 def infoClass(self, data, ds=False):
     '''build info class'''
     if ds == True:  self.infoclass = type(self.infoname,(RRDDataSourceInfo,),data)
     else:  self.infoclass = type(self.infoname,(ComponentInfo,),data)
     classImplements(self.infoclass,self.interfaceclass)
     self.info_path = "%s.info.%s" % (self.zenpackname, self.infoname)
     self.addClassData(self.infoname, self.info_path, self.infoclass)

def apply_customization_workflow(name, ti):
    """Apply customizations, features as per configuration from a workflow. 
    Must (currently) be run after db setup.
    """
    # support to infer/get the domain class from the type key
    from bungeni.models import domain, orm
    def get_domain_kls(name):
        """Infer the target domain kls from the type key, following underscore 
        naming to camel case convention.
        """
        return getattr(domain, naming.camel(name))
    
    # get the domain class, and associate with type
    kls = get_domain_kls(name)
    ti.domain_model = kls
    
    # We "mark" the domain class with IWorkflowed, to be able to 
    # register/lookup adapters generically on this single interface.
    classImplements(kls, IWorkflowed)
    
    # dynamic features from workflow
    wf = ti.workflow
    # decorate/modify domain/schema/mapping as needed
    kls = domain.configurable_domain(kls, wf)
    orm.configurable_mappings(kls)
    
    # !+ following should be part of the domain.feature_audit(kls) logic
    if wf.has_feature("audit"):
        # create/set module-level dedicated auditor singleton for auditable kls
        bungeni.core.audit.set_auditor(kls)

    def _register(name, category, schema, klass, title, description):
        ConfigletClass = configlettype.ConfigletType(
            str(name), schema, klass, title, description)
        interface.classImplements(ConfigletClass, schema)

        # register behavior for configlet
        bname = 'memphis.controlpanel-%s'%name

        # behavior
        bfactory = configlet.BehaviorFactory(name, bname)
        storage.registerBehavior(
            bname, schema, bfactory, schema = IConfigletData,
            title=title, description=description, configContext=None)

        # set additional attributes
        ConfigletClass.__category__ = category

        # configlet instance
        inst = ConfigletClass()

        # register configlet as utility
        config.registerUtility(inst, schema, '')

        # register configlet in control panel
        getUtility(IControlPanel).addConfiglet(inst)
        inst.__behavior__ = storage.getBehavior(schema)

    def prepareContent(self):
        
        classImplements(ATNewsItem, ITestTaggable)
        provideAdapter(TestExtender, name=u"archetypes.schemaextender.test.adapter")

        self.portal.invokeFactory('News Item', 'taggable-news')
        self.taggable_news = getattr(self.portal, 'taggable-news')

    def __call__(aspect, origin=None, *args, **kw):
        if kw.get('pdb'):
            import pdb;pdb.set_trace()

        # if called without positional arg, return partially applied
        # aspect
        if origin is None:
            if not kw:
                raise NeedKw
            return Partial(aspect, **kw)

        workbench = Workbench(origin, **kw)
        Instructions(aspect)(workbench)

            #raise AspectCollision(instr.name, aspect, target)

            # in case of instances functions need to be bound
            # if not x_is_class and (type(instr) is types.FunctionType):
            #     instr = instr.__get__(x)

        # build a new class, with the same name and bases as the
        # target class, but a new dictionary with the aspect applied.
        cls = workbench.type(workbench.name, workbench.baseclasses,
                             workbench.dct)
        if ZOPE_INTERFACE_AVAILABLE:
            classImplements(cls, *tuple(implementedBy(aspect)))
        if isclass(origin):
            if type(cls) is AspectMeta and kw:
                return Partial(cls, **kw)
            return cls
        return cls()

def patch():
    CMFCatalogTool.unindexObject = unindexObjectCMF
    setattr(CMFCatalogTool, '__old_unindexObject', original_unindexObjectCMF)

    CatalogMultiplex.unindexObject = unindexObject
    setattr(CatalogMultiplex, '__old_unindexObject', original_unindexObject)

    DefaultOrdering.moveObjectsByDelta = moveObjectsByDelta
    setattr(DefaultOrdering, '__old_moveObjectsByDelta',
            original_moveObjectsByDelta)

    PloneSite.moveObjectsByDelta = PloneSite_moveObjectsByDelta
    setattr(PloneSite, '__old_moveObjectsByDelta',
            original_PloneSite_moveObjectsByDelta)

    prefix = '__old_'
    for patch in patches:
        klass = patch.kls
        if not IElasticSearchCatalog.implementedBy(klass):
            patched[klass] = {}
            for name, method in patch.method_map.items():
                classImplements(klass, IElasticSearchCatalog)
                old = getattr(klass, name, method)
                patched[klass][name] = old
                setattr(klass, prefix + name, old)
                setattr(klass, name, method)
                info('patched %s', str(getattr(klass, name)))

    def execute(self, renderer, config, layer, name,
                macro, target, template, configuration, **kw):
        """Register a renderer.
        """        
        provides = (name == DEFAULT and interfaces.IStructuredDefaultRenderer
                    or interfaces.IStructuredRenderer)

        renderer.__view_name__ = name
        renderer.__renderer_macro__ = macro
        templates = renderer.module_info.getAnnotation(
            'grok.templates', None
            )

        if configuration is not None:
            classImplements(renderer, interfaces.IConfigurableRenderer)
        
        if templates is not None:
            config.action(
                discriminator=None,
                callable=self.checkTemplates,               
                args=(templates, renderer.module_info, renderer)
                )

        for context in target:
            adapts = (context, layer)
            config.action(
                discriminator=('adapter', adapts, provides, name),
                callable=zope.component.provideAdapter,
                args=(renderer, adapts, provides, name),
                )
        return True

 def updateSchema(self):
     sch = getUtility(ISchemaType, self.__context__.oid)
     sch.spec = self.schema
     sch.Type.__schema__ = self.schema
     interface.classImplements(sch.Type, self.schema)
     
     self.model = unicode(supermodel.serializeSchema(self.schema))

 def testNoViewOnClassicClassException(self):
     from zope.interface import Interface
     from types import ClassType
     class ClassicError:
         __metaclass__ = ClassType
     class IClassicError(Interface):
         pass
     classImplements(ClassicError, IClassicError)
     support.setDefaultViewName(IClassicError, 'name',
                                self.presentation_type)
     view_text = 'You made a classic error ;-)'
     def _view(obj, request):
         return lambda: view_text
     component.provideAdapter(
         _view, (ClassicError, self.presentation_type), Interface,
         name='name')
     try:
         raise ClassicError
     except:
         pass
     self.publication.handleException(
         self.object, self.request, sys.exc_info(), retry_allowed=False)
     # check we don't get the view we registered
     self.failIf(''.join(self.request.response._result) == view_text)
     # check we do actually get something
     self.failIf(''.join(self.request.response._result) == '')

def check_testcase_implements_trial_reporter(done=[]):
    if done:
        return
    from zope.interface import classImplements
    from twisted.trial.itrial import IReporter
    classImplements(TestCaseFunction, IReporter)
    done.append(1)

def Portlet(name, class_=None, title='', description='',
            template=None, schema=None, **kw):
    cdict = {}
    cdict.update(kw)
    cdict['__name__'] = name
    cdict['title'] = title
    cdict['description'] = description

    if template:
        cdict['template'] = ViewPageTemplateFile(template)

    if class_ is not None:
        class_name = 'Portlet<%s:%s>'%(class_.__name__, name)
    else:
        class_name = 'Portlet<%s>'%name

    if class_ is None:
        bases = (PortletBase,)
    else:
        bases = (class_, PortletBase)

    PortletClass = type(str(class_name), bases, cdict)

    if schema is not None:
        for f_id in getFields(schema):
            if not hasattr(PortletClass, f_id):
                setattr(PortletClass, f_id, ConfigurationProperty(schema[f_id]))

        PortletClass.__schema__ = schema
        interface.classImplements(PortletClass, schema)

    return PortletClass

 def testExceptionSideEffects(self):
     from zope.publisher.interfaces import IExceptionSideEffects
     @implementer(IExceptionSideEffects)
     class SideEffects(object):
         def __init__(self, exception):
             self.exception = exception
         def __call__(self, obj, request, exc_info):
             self.obj = obj
             self.request = request
             self.exception_type = exc_info[0]
             self.exception_from_info = exc_info[1]
     class SideEffectsFactory:
         def __call__(self, exception):
             self.adapter = SideEffects(exception)
             return self.adapter
     factory = SideEffectsFactory()
     from ZODB.POSException import ConflictError
     from zope.interface import Interface
     class IConflictError(Interface):
         pass
     classImplements(ConflictError, IConflictError)
     component.provideAdapter(factory, (IConflictError,),
                              IExceptionSideEffects)
     exception = ConflictError()
     try:
         raise exception
     except:
         self.publication.handleException(
             self.object, self.request, sys.exc_info(), retry_allowed=False)
     adapter = factory.adapter
     self.assertEqual(exception, adapter.exception)
     self.assertEqual(exception, adapter.exception_from_info)
     self.assertEqual(ConflictError, adapter.exception_type)
     self.assertEqual(self.object, adapter.obj)
     self.assertEqual(self.request, adapter.request)

def viewletManager(
    _context, name, permission,
    for_=Interface, layer=interfaces.IFlourishLayer, view=interfaces.IPageBase,
    provides=interfaces.IViewletManager,
    class_=ViewletManager, template=None,
    update='update', render='render',
    allowed_interface=(), allowed_attributes=(),
    **kwargs):

    bases = (class_, )
    if not interfaces.IViewletManager.implementedBy(class_):
        bases = bases + (ViewletManager, )
    class_ = type(class_.__name__, bases, {})

    allowed_interface = (tuple(allowed_interface) +
                         (interfaces.IViewletManager, ))

    if not provides.implementedBy(class_):
        classImplements(class_, provides)

    contentDirective(
        _context, name, permission,
        for_=for_, layer=layer, view=view,
        class_=class_, template=template,
        update=update, render=render,
        allowed_interface=allowed_interface,
        allowed_attributes=allowed_attributes,
        **kwargs)