def ViewletManager(name, interface, template=None, bases=()): """ Create and return a new viewlet manager class that implements :class:`zope.viewlet.interfaces.IViewletManager`. :param str name: The name of the generated class. :param interface: The additional interface the class will implement. :keyword tuple bases: The base classes to extend. """ attrDict = {'__name__' : name} if template is not None: attrDict['template'] = ViewPageTemplateFile(template) if ViewletManagerBase not in bases: # Make sure that we do not get a default viewlet manager mixin, if the # provided base is already a full viewlet manager implementation. if not (len(bases) == 1 and interfaces.IViewletManager.implementedBy(bases[0])): bases = bases + (ViewletManagerBase,) ViewletManagerCls = type( '<ViewletManager providing %s>' % interface.getName(), bases, attrDict) zope.interface.classImplements(ViewletManagerCls, interface) return ViewletManagerCls
def ViewletManager(name, interface, template=None, bases=()): """ Create and return a new viewlet manager class that implements :class:`zope.viewlet.interfaces.IViewletManager`. :param str name: The name of the generated class. :param interface: The additional interface the class will implement. :keyword tuple bases: The base classes to extend. """ attrDict = {'__name__': name} if template is not None: attrDict['template'] = ViewPageTemplateFile(template) if ViewletManagerBase not in bases: # Make sure that we do not get a default viewlet manager mixin, if the # provided base is already a full viewlet manager implementation. if not (len(bases) == 1 and interfaces.IViewletManager.implementedBy(bases[0])): bases = bases + (ViewletManagerBase, ) ViewletManagerCls = type( '<ViewletManager providing %s>' % interface.getName(), bases, attrDict) zope.interface.classImplements(ViewletManagerCls, interface) return ViewletManagerCls
def __protectByInterface(self, interface, permission_id): "Set a permission on names in an interface." for n, d in interface.namesAndDescriptions(1): self.__protectName(n, permission_id) self._context.action( discriminator = None, callable = provideInterface, args = (interface.__module__+'.'+interface.getName(), interface))
def ViewletManager(name, interface, template=None, bases=()): attrDict = {'__name__' : name} if template is not None: attrDict['template'] = ViewPageTemplateFile(template) if ViewletManagerBase not in bases: # Make sure that we do not get a default viewlet manager mixin, if the # provided base is already a full viewlet manager implementation. if not (len(bases) == 1 and interfaces.IViewletManager.implementedBy(bases[0])): bases = bases + (ViewletManagerBase,) ViewletManager = type( '<ViewletManager providing %s>' % interface.getName(), bases, attrDict) zope.interface.classImplements(ViewletManager, interface) return ViewletManager
def ViewletManager(name, interface, template=None, bases=()): attrDict = {'__name__': name} if template is not None: attrDict['template'] = ViewPageTemplateFile(template) if ViewletManagerBase not in bases: # Make sure that we do not get a default viewlet manager mixin, if the # provided base is already a full viewlet manager implementation. if not (len(bases) == 1 and interfaces.IViewletManager.implementedBy(bases[0])): bases = bases + (ViewletManagerBase, ) ViewletManager = type( '<ViewletManager providing %s>' % interface.getName(), bases, attrDict) zope.interface.classImplements(ViewletManager, interface) return ViewletManager
def fossilize_obj(cls, obj, interfaceArg=None, useAttrCache=False, mapClassType={}, **kwargs): """ Fossilizes the object, using the fossil provided by `interface`. :param interfaceArg: the target fossile type :type interfaceArg: IFossil, NoneType, or dict :param useAttrCache: use caching of attributes if same fields are repeated for a fossil :type useAttrCache: boolean """ interface = cls.__obtainInterface(obj, interfaceArg) name = interface.getName() fossilName = cls.__extractFossilName(name) result = {} # cache method names for each interface names = cls.__fossilInterfaceCache.get(interface) if names is None: names = interface.names(all=True) cls.__fossilInterfaceCache[interface] = names ### for methodName in names: method = interface[methodName] tags = method.getTaggedValueTags() isAttribute = False # In some cases it is better to use the attribute cache to # speed up the fossilization cacheUsed = False if useAttrCache: try: methodResult = cls.__fossilAttrsCache[ obj._p_oid][methodName] cacheUsed = True except KeyError: pass if not cacheUsed: # Please use 'produce' as little as possible; # there is almost always a more elegant and modular solution! if 'produce' in tags: methodResult = method.getTaggedValue('produce')(obj) else: attr = getattr(obj, methodName) if callable(attr): try: methodResult = attr() except: logging.getLogger('indico.fossilize').error( "Problem fossilizing '%r' with '%s'" % (obj, interfaceArg)) raise else: methodResult = attr isAttribute = True if hasattr(obj, "_p_oid"): cls.__fossilAttrsCache.setdefault( obj._p_oid, {})[methodName] = methodResult if 'filterBy' in tags: if 'filters' not in kwargs: raise Exception('No filters defined!') filterName = method.getTaggedValue('filterBy') if filterName in kwargs['filters']: filterBy = kwargs['filters'][filterName] else: raise Exception("No filter '%s' defined!" % filterName) else: filterBy = None # Result conversion if 'result' in tags: targetInterface = method.getTaggedValue('result') #targetInterface = globals()[targetInterfaceName] methodResult = Fossilizable.fossilizeIterable( methodResult, targetInterface, filterBy=filterBy, mapClassType=mapClassType, **kwargs) # Conversion function if 'convert' in tags: convertFunction = method.getTaggedValue('convert') converterArgNames = inspect.getargspec(convertFunction)[0] converterArgs = dict((name, kwargs[name]) for name in converterArgNames if name in kwargs) try: methodResult = convertFunction(methodResult, **converterArgs) except: logging.getLogger('indico.fossilize').error( "Problem fossilizing '%r' with '%s' (%s)" % (obj, interfaceArg, methodName)) raise # Re-name the attribute produced by the method if 'name' in tags: attrName = method.getTaggedValue('name') elif isAttribute: attrName = methodName else: attrName = cls.__extractName(methodName) # In case the name contains dots, each of the 'domains' but the # last one are translated into nested dictionnaries. For example, # if we want to re-name an attribute into "foo.bar.tofu", the # corresponding fossilized attribute will be of the form: # {"foo":{"bar":{"tofu": res,...},...},...} # instead of: # {"foo.bar.tofu": res, ...} current = result attrList = attrName.split('.') while len(attrList) > 1: attr = attrList.pop(0) if attr not in current: current[attr] = {} current = current[attr] # For the last attribute level current[attrList[0]] = methodResult if "_type" in result or "_fossil" in result: raise InvalidFossilException('"_type" or "_fossil"' ' cannot be a fossil attribute name') else: result["_type"] = mapClassType.get(obj.__class__.__name__, obj.__class__.__name__) if fossilName: #we check that it's not an empty string result["_fossil"] = fossilName else: result["_fossil"] = "" return result
def fossilize_obj(cls, obj, interfaceArg=None, useAttrCache=False, mapClassType=None, **kwargs): """ Fossilizes the object, using the fossil provided by `interface`. :param interfaceArg: the target fossile type :type interfaceArg: IFossil, NoneType, or dict :param useAttrCache: use caching of attributes if same fields are repeated for a fossil :type useAttrCache: boolean """ mapClassType = dict(mapClassType or {}, AvatarUserWrapper='Avatar', AvatarProvisionalWrapper='Avatar', EmailPrincipal='Email') interface = cls.__obtainInterface(obj, interfaceArg) name = interface.getName() fossilName = cls.__extractFossilName(name) result = {} # cache method names for each interface names = _fossil_cache.fossilInterface.get(interface) if names is None: names = interface.names(all=True) _fossil_cache.fossilInterface[interface] = names ### for methodName in names: method = interface[methodName] tags = method.getTaggedValueTags() isAttribute = False if 'onlyIf' in tags: onlyIf = method.getTaggedValue('onlyIf') # If the condition not in the kwargs or the condition False, we do not fossilize the method if not kwargs.get(onlyIf, False): continue # In some cases it is better to use the attribute cache to # speed up the fossilization cacheUsed = False if useAttrCache: try: methodResult = _fossil_cache.fossilAttrs[obj._p_oid][methodName] cacheUsed = True except KeyError: pass if not cacheUsed: # Please use 'produce' as little as possible; # there is almost always a more elegant and modular solution! if 'produce' in tags: methodResult = method.getTaggedValue('produce')(obj) else: attr = getattr(obj, methodName) if callable(attr): try: methodResult = attr() except: logging.getLogger('indico.fossilize').error("Problem fossilizing '%r' with '%s'", obj, interfaceArg) raise else: methodResult = attr isAttribute = True if hasattr(obj, "_p_oid"): _fossil_cache.fossilAttrs.setdefault(obj._p_oid, {})[methodName] = methodResult if 'filterBy' in tags: if 'filters' not in kwargs: raise Exception('No filters defined!') filterName = method.getTaggedValue('filterBy') if filterName in kwargs['filters']: filterBy = kwargs['filters'][filterName] else: raise Exception("No filter '%s' defined!" % filterName) else: filterBy = None # Result conversion if 'result' in tags: targetInterface = method.getTaggedValue('result') #targetInterface = globals()[targetInterfaceName] methodResult = Fossilizable.fossilizeIterable( methodResult, targetInterface, filterBy=filterBy, mapClassType=mapClassType, **kwargs) # Conversion function if 'convert' in tags: convertFunction = method.getTaggedValue('convert') converterArgNames = inspect.getargspec(convertFunction)[0] converterArgs = dict((name, kwargs[name]) for name in converterArgNames if name in kwargs) if '_obj' in converterArgNames: converterArgs['_obj'] = obj try: methodResult = convertFunction(methodResult, **converterArgs) except: logging.getLogger('indico.fossilize').error("Problem fossilizing '%r' with '%s' (%s)", obj, interfaceArg, methodName) raise # Re-name the attribute produced by the method if 'name' in tags: attrName = method.getTaggedValue('name') elif isAttribute: attrName = methodName else: attrName = cls.__extractName(methodName) # In case the name contains dots, each of the 'domains' but the # last one are translated into nested dictionnaries. For example, # if we want to re-name an attribute into "foo.bar.tofu", the # corresponding fossilized attribute will be of the form: # {"foo":{"bar":{"tofu": res,...},...},...} # instead of: # {"foo.bar.tofu": res, ...} current = result attrList = attrName.split('.') while len(attrList) > 1: attr = attrList.pop(0) if attr not in current: current[attr] = {} current = current[attr] # For the last attribute level current[attrList[0]] = methodResult if "_type" in result or "_fossil" in result: raise InvalidFossilException('"_type" or "_fossil"' ' cannot be a fossil attribute name') else: result["_type"] = mapClassType.get(obj.__class__.__name__, obj.__class__.__name__) if fossilName: #we check that it's not an empty string result["_fossil"] = fossilName else: result["_fossil"] = "" return result
def type(cls): for interface in zope.interface.implementedBy(cls): if interface.getName().startswith('D') or interface.getName().startswith('I'): return interface.getName()[1:] return cls.__name__