def __call__(self, wrapped): def callback(scanner, name, ob): setattr(wrapped, '__meta__', {'tablename': None, 'alias': 't{}'.format(self._counter), 'database': self.database, 'collation': self.collation, 'columns': None, # column name in the database 'attributes': None, # map col name to attribute name # Populate on column descriptors 'primary_key': {}, 'pkv': None, 'foreign_keys': {}, }) self.__class__._counter += 1 if not self.name: self.name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', wrapped.__name__) self.name = re.sub('([a-z0-9])([A-Z])', r'\1_\2', self.name).lower() wrapped.__meta__['tablename'] = self.name meta.register(self.database, self.name, wrapped) venusian.attach(wrapped, callback, category='aiorm') return wrapped
def __call__(self, wrapped): def callback(scanner, name, ob): ob.name = self.name ob.islocal = self.islocal ob.superiors = list(ob.superiors) ob.superiors.extend(self.superiors) ob.superiors = list(set(ob.superiors)) def get_allsuperiors(role_ob): superiors = list(role_ob.superiors) for sup in role_ob.superiors: superiors.extend(get_allsuperiors(sup)) return list(set(superiors)) ob.all_superiors = list(ob.all_superiors) ob.all_superiors.extend(get_allsuperiors(ob)) ob.all_superiors = list(set(ob.all_superiors)) for role in ob.all_superiors: role.lowers = list(set(getattr(role, 'lowers', []))) role.lowers.append(ob) role.lowers = list(set(role.lowers)) for role in getattr(ob, 'lowers', self.lowers): role.superiors = list(role.superiors) role.superiors.append(ob) role.superiors = list(set(role.superiors)) role.all_superiors = list(role.all_superiors) role.all_superiors.append(ob) role.all_superiors.extend(ob.all_superiors) role.all_superiors = list(set(role.all_superiors)) DACE_ROLES[ob.name] = ob venusian.attach(wrapped, callback) return wrapped
def decorate(factory): def callback(scanner, factory_name, factory): scanner.config.action(('location', name), set_location, args=(scanner.config, name, factory), order=PHASE2_CONFIG) venusian.attach(factory, callback, category='pyramid') return factory
def _add_argument(function, *args, **kwargs): """Add arguments to a function. This adds a :mod:`venusian` callback to the given function in the ``serverstf:arguments`` category that, when scanned, will attempt to add the given command line argument to the corresponding subcommand. :param function: the function to add the callback to. This function must be decorated by :func:`subcommand`. :param args: passed to :meth:`argparse.ArgumentParser.add_argument`. :param kwargs: passed to :meth:`argparse.ArgumentParser.add_argument`. :return: the given ``function``. """ def callback(scanner, name, obj): # pylint: disable=unused-argument,missing-docstring subcommands = getattr(obj, _SUBCOMMANDS, None) if not subcommands: raise CLIError("Can't set CLI arugments for " "{} as it is not a subcommand".format(obj)) for command in subcommands: command.arguments.append((args, kwargs)) # Depth 2 is required so that we can use this from within decorators. venusian.attach(function, callback, category=__package__ + ":arguments", depth=2) return function
def decorator(wrapped): def callback(scanner, name, obj): for scheme in schemes: scanner.config.registry.registerUtility( obj, IStorageFactory, scheme) venusian.attach(wrapped, callback) return wrapped
def __call__(self, wrapped): def callback(scanner, name, ob): if ob.classification_id not in CLASSIFICATIONS: CLASSIFICATIONS[ob.classification_id] = ob venusian.attach(wrapped, callback) return wrapped
def decorate(checker): def callback(scanner, factory_name, factory): scanner.config.add_audit_checker( checker, item_type, condition, frame) venusian.attach(checker, callback, category='auditor') return checker
def __new__(mcl, name, bases, d): testing_config = d.get('testing_config') d['registry'] = Registry(name, bases, testing_config, d.get('variables', [])) result = super(AppMeta, mcl).__new__(mcl, name, bases, d) venusian.attach(result, callback) return result
def attach(self, action, cfg=None, depth=1): action.info = self if action.hash is None: action.hash = self.hash data = getattr(self.module, ATTACH_ATTR, None) if data is None: data = AttachData() setattr(self.module, ATTACH_ATTR, data) if cfg is None and action.hash in data: raise TypeError( "Directive registered twice: %s" % (action.discriminator,)) data[action.hash] = action def callback(context, name, ob): config = context.config.with_package(self.module) config.info = action.info config.action( action.discriminator, self._runaction, (action, config), introspectables=action.introspectables, order=action.order) venusian.attach(data, callback, category='ptah', depth=depth+1) if cfg is not None: cfg.action( action.discriminator, self._runaction, (action, cfg), introspectables=action.introspectables, order=action.order)
def decorator(wrapped): def callback(scanner, name, ob): scanner.registry.add(name, ob, internals, pass_msg) venusian.attach(wrapped, callback) return wrapped
def method(method_class): """Decorator to use to mark an API method. When invoking L{Registry.scan} the classes marked with this decorator will be added to the registry. @param method_class: The L{Method} class to register. """ def callback(scanner, name, method_class): if method_class.actions is not None: actions = method_class.actions else: actions = [name] if method_class.versions is not None: versions = method_class.versions else: versions = [None] for action in actions: for version in versions: scanner.registry.add(method_class, action=action, version=version) from venusian import attach attach(method_class, callback, category="method") return method_class
def __call__(self, wrapped): def callback(scanner, name, ob): ob.component_id = self.component_id ob.loading_component = self.loading_component ob.on_demand = self.on_demand ob.delegate = self.delegate old_call = ob.update def update(self): if not self.params('load_view') or (self.on_demand and self.params('on_demand') != 'load'): component = self.loading_component( self.context, self.request, component_id=self.component_id) component.wrapper_template = ob.wrapper_template component.title = ob.title component.viewid = ob.viewid component.view_icon = getattr(ob, 'view_icon', '') component.counter_id = getattr(ob, 'counter_id', '') component.css_class = ob.css_class + ' async-component-container' component.container_css_class = ob.container_css_class + \ ' async-component' component.isactive = getattr(ob, 'isactive', False) return component.update() return old_call(self) ob.update = update ON_LOAD_VIEWS[self.component_id] = ob venusian.attach(wrapped, callback, category='site_widget') return wrapped
def __call__(self, wrapped): decorator = self def callback(scanner, name, obj): #pylint: disable-msg=W0613 if hasattr(scanner, 'plugin_registry'): scanner.plugin_registry.add('administration_link', decorator.link_text, PluginRegistryItem(decorator)) venusian.attach(wrapped, callback, category='pvs.plugins') return wrapped
def wrapped_grokker(wrapped): def callback(scanner, name, ob): kw = make_arguments(directives, wrapped) # XXX give better feedback identifying grokker in # case of a TypeError grokker(scanner, name, ob, **kw) venusian.attach(wrapped, callback, category=self.category) return wrapped
def deco(wrapped): def callback(scanner, _name, wrapped): wrapped = functools.partial(wrapped, scanner.config) event.listen(target, identifier, wrapped, *args, **kwargs) venusian.attach(wrapped, callback) return wrapped
def subcommand(wrapped): """This decorator makes a function becomes a subcommand """ def callback(scanner, name, ob): scanner.subcommands[ob.name] = ob venusian.attach(wrapped, callback, category='subcommands') return wrapped
def deco(wrapped): def callback(scanner, name, wrapped): celery_app = scanner.config.registry["celery.app"] celery_app.task(**kwargs)(wrapped) venusian.attach(wrapped, callback) return wrapped
def scan(package): """Scan the package for registered venusian callbacks""" scope, module, f_locals, f_globals, codeinfo = \ venusian.advice.getFrameInfo(sys._getframe(1)) venusian.attach( module, # module, where scan was called lambda scanner, name, ob, package=package: _scan(scanner, package) )
def conf_deco(func): def callback(venusian_scanner, *_): """This gets called by venusian at scan time.""" self.register(venusian_scanner, key, func) venusian.attach(func, callback, category=self.category) return func
def wrapper(wrapped): def callback(scanner, name, obj): celery_app = scanner.config.registry.celery_app celery_app.task(**kwargs)(obj) venusian.attach(wrapped, callback) return wrapped
def _wrapped(cls): def callback(scanner, obj_name, obj): registry = scanner.config.registry registry["filters"].append((name, obj)) venusian.attach(cls, callback) return cls
def doc_type(cls): def callback(scanner, _name, item): types_ = scanner.config.registry.setdefault("search.doc_types", set()) types_.add(item) venusian.attach(cls, callback) return cls
def dec(mapper): def callback(scanner, name, ob): config = scanner.config todict_adapter = mapper_adapter(ob) config.set_todict(cls, todict_adapter, name=register_name) venusian.attach(mapper, callback, category='pyramid') return mapper
def plugin(wrapped): """register a class as plugin""" def callback(context, name, ob): bot = context.bot bot.get_plugin(ob) assert isinstance(wrapped, type) venusian.attach(wrapped, callback, category='irc3') return wrapped
def i18n_domain(domain): """Set i18n domain for the current context""" scope, module, f_locals, f_globals, codeinfo = \ venusian.advice.getFrameInfo(sys._getframe(1)) venusian.attach( module, # module, where i18n_domain was called lambda scanner, name, ob, domain=domain: setattr(scanner.context, 'i18n_domain', domain) )
def decorate(Item): def callback(scanner, factory_name, factory): scanner.config.action(('collection', name), set_collection, args=(scanner.config, Item.AbstractCollection, name, Item), kw=kw, order=PHASE2_CONFIG) venusian.attach(Item, callback, category='pyramid') return Item
def attach(identity, category, task_factory, *a, **kw): p_task_factory = partial(task_factory, *a, **kw) def callback(venusian_scanner, f_name, obj): logger.info("Found %r as '%s' while scanning.", task_factory, f_name) f = partial(p_task_factory, f_name=f_name) venusian_scanner.registry[identity(f_name, obj)] = f venusian.attach(task_factory, callback, category=category)
def __call__(self, schema): ct = make_content_type( schema, schema.__name__, schema.__module__, meta=self.meta, property_factory=self.property_factory ) def callback(scanner, name, ob): scanner.limone.register_content_type(ct) venusian.attach(ct, callback, category='limone') return ct
def decorator(cls): ct = make_content_type( schema, cls.__name__, cls.__module__, (cls,), self.meta, property_factory=self.property_factory ) def callback(scanner, name, ob): scanner.limone.register_content_type(ct) venusian.attach(ct, callback, category='limone') return ct
def __call__(self, wrapped): def callback(scanner, name, ob): task_ = Task(scanner.driver, wrapped, **self.task_options) log.info('Register task {}'.format(task_.name)) scanner.driver.register_task(task_) venusian.attach(wrapped, callback, category='apium') return wrapped
def __init__(self, name, path, description=None, cors_policy=None, depth=1, **kw): self.name = name self.path = path self.description = description self.cors_expose_all_headers = True self._cors_enabled = None if cors_policy: for key, value in cors_policy.items(): kw.setdefault('cors_' + key, value) for key in self.list_arguments: # default_{validators,filters} and {filters,validators} don't # have to be mutables, so we need to create a new list from them extra = to_list(kw.get(key, [])) kw[key] = [] kw[key].extend(getattr(self, 'default_%s' % key, [])) kw[key].extend(extra) self.arguments = self.get_arguments(kw) for key, value in self.arguments.items(): # avoid squashing Service.decorator if ``decorator`` # argument is used to specify a default pyramid view # decorator if key != 'decorator': setattr(self, key, value) if hasattr(self, 'factory') and hasattr(self, 'acl'): raise KeyError("Cannot specify both 'acl' and 'factory'") # instantiate some variables we use to keep track of what's defined for # this service. self.defined_methods = [] self.definitions = [] # add this service to the list of available services SERVICES.append(self) # register aliases for the decorators for verb in ('GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH'): setattr(self, verb.lower(), functools.partial(self.decorator, verb)) if VENUSIAN: # this callback will be called when config.scan (from pyramid) will # be triggered. def callback(context, name, ob): config = context.config.with_package(info.module) config.add_cornice_service(self) info = venusian.attach(self, callback, category='pyramid', depth=depth)
def user_model(wrapped): def callback(context, name, ob): set_user_model(context.config.registry, ob) info = venusian.attach(wrapped, callback, category='procyon') return wrapped
def extend(func): """Allow to extend a bot: Create a module with some useful routine: .. literalinclude:: ../examples/myextends.py .. >>> import sys >>> sys.path.append('examples') >>> from irc3 import IrcBot >>> IrcBot.defaults.update(async=False, testing=True) Now you can use those routine in your bot:: >>> bot = IrcBot() >>> bot.include('myextends') >>> print(bot.my_usefull_function(1)) my_usefull_function(*(1,)) >>> print(bot.my_usefull_method(2)) my_usefull_method(*(2,)) """ def callback(context, name, ob): obj = context.context if info.scope == 'class': f = getattr(obj.get_plugin(ob), func.__name__) else: f = func setattr(obj, f.__name__, f.__get__(obj, obj.__class__)) info = venusian.attach(func, callback, category='irc3.extend') return func
def _api(func): _api_kw = api_kw.copy() docstring = func.__doc__ for validator in validators: func = _apply_validator(func, validator) if validator.__doc__ is not None: if docstring is not None: docstring += validator.__doc__.strip() else: docstring = validator.__doc__.strip() def callback(context, name, ob): config = context.config.with_package(info.module) self._define(config, method) config.add_apidoc((self.route_pattern, method), docstring, self.renderer, self) config.add_view(view=ob, route_name=self.route_name, **_api_kw) info = venusian.attach(func, callback, category='pyramid') if info.scope == 'class': # if the decorator was attached to a method in a class, or # otherwise executed at class scope, we need to set an # 'attr' into the settings if one isn't already in there if 'attr' not in kw: kw['attr'] = func.__name__ kw['_info'] = info.codeinfo # fbo "action_method" return func
def __call__(self, wrapped): settings = self.__dict__.copy() def callback(context, name, ob): config = context.config.with_package(info.module) config.add_panel(panel=ob, **settings) ADVERTISING_CONTAINERS[self.name] = { 'title': ob.title, 'description': ob.description, 'order': ob.order, 'validator': ob.validator, 'tags': ob.tags # TODO add validator ob.validator } info = venusian.attach(wrapped, callback, category='pyramid_layout') if info.scope == 'class': # if the decorator was attached to a method in a class, or # otherwise executed at class scope, we need to set an # 'attr' into the settings if one isn't already in there if settings['attr'] is None: settings['attr'] = wrapped.__name__ settings['_info'] = info.codeinfo # fbo "action_method" return wrapped
def __init__(cls, name, bases, attrs): def cb(context, name, ob): config = context.config.with_package(info.module) configurator = cls.view_configurator_class(config, cls) list_route = configurator.configure_list_view() edit_route = configurator.configure_edit_view() new_route = configurator.configure_new_view() delete_confirm_route = configurator.configure_delete_confirm_view() cls.routes = { 'list': list_route, 'edit': edit_route, 'new': new_route, 'delete_confirm': delete_confirm_route, } if '__abstract__' not in attrs: have_attrs = set(attrs) need_attrs = set(('schema', 'model', 'url_path')) if have_attrs & need_attrs != need_attrs: missing = need_attrs - (have_attrs & need_attrs) raise AttributeError( "Invalid configuration. The following attributes are " "missing and need to be defined for a complete " "configuration : %s" % ", ".join(missing)) if cls.view_configurator_class is not None: info = venusian.attach(cls, cb) # Initialize mutable defaults cls.actions = []
def __call__(self, view): def callback(context, name, ob): config = context.config config.kotti_snippets(self.name, self.slots) info = venusian.attach(view, callback, category='kotti_snippets') return view
def __init__( self, resource_name, plural_name=None, singular=False, documentation="", acl=None, ): super(Resource, self).__init__( resource_name, plural_name, singular, documentation, acl, ) self.info = venusian.attach(self, self.callback) # define REST decorators if not self.singular: iter_methods = iter(self.methods) if self.singular: iter_methods = iter(self.singular_methods) for method in iter_methods: setattr(self, method, functools.partial(self.decorator, method))
def attach_command(func, depth=2, **predicates): commands = predicates.pop('commands', 'irc3.plugins.command.Commands') category = predicates.pop('venusian_category', 'irc3.plugins.command') def callback(context, name, ob): obj = context.context if info.scope == 'class': callback = func.__get__(obj.get_plugin(ob), ob) else: callback = utils.wraps_with_context(func, obj) plugin = obj.get_plugin(utils.maybedotted(commands)) predicates.update(module=func.__module__) cmd_name = predicates.get('name', func.__name__) if not plugin.case_sensitive: cmd_name = cmd_name.lower() plugin[cmd_name] = (predicates, callback) aliases = predicates.get('aliases', None) if aliases is not None: for alias in aliases: plugin.aliases[alias] = cmd_name obj.log.debug('Register command %r %r', cmd_name, aliases) else: obj.log.debug('Register command %r', cmd_name) info = venusian.attach(func, callback, category=category, depth=depth)
def __call__(self, func): """ Registers the wrapped func as a path function that executes at the terminal path in each path in `self.paths`. """ # callback runs synchronously when venusian.Scanner.scan is called # in graph.scan. def callback(scanner, name, obj): """ Register path function with contexts """ _func = func # enclose the reference for use in conditionals for path in self._paths: path.execute = _func venusian.attach(func, callback) return func
def __call__(self, wrapped): """Attach the decorator with Venusian""" args = self.args kwargs = self.kwargs def callback(scanner, _name, wrapped): """Register a view; called on config.scan""" config = scanner.config # pylint: disable=W0142 add_simple_route(config, self.prefixed_route_path, wrapped, *args, route_kwargs=dict(traverse=self.prefixed_route_path), **kwargs) request_method = kwargs.get("request_method", "GET") registry = config.registry registry.getUtility(IRouteRegistry).register(namespace, self.route_path, request_method, kwargs.get("api",{})) info = venusian.attach(wrapped, callback) if info.scope == 'class': # pylint:disable=E1101 # if the decorator was attached to a method in a class, or # otherwise executed at class scope, we need to set an # 'attr' into the settings if one isn't already in there if kwargs.get('attr') is None: kwargs['attr'] = wrapped.__name__ return wrapped
def root(factory): """ Set the root """ def set_root(config, factory): root = factory(config.registry) config.registry[ROOT] = root def callback(scanner, factory_name, factory): scanner.config.action(('root', ), set_root, args=(scanner.config, factory), order=PHASE1_5_CONFIG) venusian.attach(factory, callback, category='pyramid') return factory
def __call__(self, wrapped): def callback(scanner: Scanner, name: str, cls): registry: ServiceRegistry = getattr(scanner, 'registry') # Later we can do some dataclass field sniffing on singletons instance = cls() # If there is a for_ use it, otherwise, register for the same # class as the instance for_ = self.for_ if self.for_ else cls registry.register_singleton( instance, for_, context=self.context, name=self.name ) attach(wrapped, callback, category='wired') return wrapped
def __call__(self, wrapped): from venusian import attach def callback(scanner: Scanner, name: str, cls): registry: ServiceRegistry = getattr(scanner, 'registry') register_dataclass( registry, cls, for_=self.for_, context=self.context, # name=self.name, ) attach(wrapped, callback, category='wired_component') return wrapped
def __call__(self, wrapped): def callback(context, name, ob): cfg = context.config.with_package(info.module) add_fieldpreview(cfg, self.cls, ob) info = venusian.attach(wrapped, callback, category='ptah.form') return wrapped
def __call__(self, wrapped): """Attach the decorator with Venusian""" args = self.args kwargs = self.kwargs def callback(scanner, _name, wrapped): """Register a view; called on config.scan""" config = scanner.config # Default to not appending slash if not "append_slash" in kwargs: append_slash = False # pylint: disable=W0142 add_simple_route(config, self.path, wrapped, *args, **kwargs) info = venusian.attach(wrapped, callback) if info.scope == 'class': # pylint:disable=E1101 # if the decorator was attached to a method in a class, or # otherwise executed at class scope, we need to set an # 'attr' into the settings if one isn't already in there if kwargs.get('attr') is None: kwargs['attr'] = wrapped.__name__ return wrapped
def __init__(self, name='', parent=None): super(App, self).__init__() self.name = name self.root_model = None self.root_obj = None self.child_apps = {} self.parent = parent self.traject = Traject() if self.parent is not None: parent.add_child(self) # allow being scanned by venusian def callback(scanner, name, obj): scanner.config.action(self, self) venusian.attach(self, callback)
def wrapper(klass): services = {} if 'collection_path' in kw: prefixes = ('collection_', '') else: prefixes = ('', ) for prefix in prefixes: # get clean view arguments service_args = {} for k in list(kw): if k.startswith('collection_'): if prefix == 'collection_': service_args[k[len(prefix):]] = kw[k] elif k not in service_args: service_args[k] = kw[k] # create service service_name = prefix + klass.__name__.lower() service = services[service_name] = Service(name=service_name, depth=2, **service_args) # initialize views for verb in ('get', 'post', 'put', 'delete', 'options', 'patch'): view_attr = prefix + verb meth = getattr(klass, view_attr, None) if meth is not None: # if the method has a __views__ arguments, then it had # been decorated by a @view decorator. get back the name of # the decorated method so we can register it properly views = getattr(meth, '__views__', []) if views: for view_args in views: service.add_view(verb, view_attr, klass=klass, **view_args) else: service.add_view(verb, view_attr, klass=klass) setattr(klass, '_services', services) if VENUSIAN: def callback(context, name, ob): # get the callbacks registred by the inner services # and call them from here when the @resource classes are being # scanned by venusian. for service in services.values(): config = context.config.with_package(info.module) config.add_cornice_service(service) info = venusian.attach(klass, callback, category='pyramid') return klass
def decorator(wrapped): def callback(scanner, name, ob): try: testfixtures = scanner.testfixtures except AttributeError: return logger.debug('scanned %s.%s as %r', ob.__module__, ob.__name__, args) if args in testfixtures.registry: logger.warning( 'duplicated testfixture found for %r', args, ) testfixtures.registry[args] = ob venusian.attach(wrapped, callback, category='testfixture') return wrapped
def __call__(self, wrapped): def callback(context, name, ob): config = context.config.with_package(info.module) config.add_renderer_adapter(self.type_or_iface, ob, **settings) info = venusian.attach(wrapped, callback) settings = {'_info': info.codeinfo} return wrapped
def _inner(func): proxy = TaskProxy(func) def callback(scanner, name, task_proxy): config = scanner.config def register(): registry = config.registry celery = get_celery(registry) celery_task = celery.task(task_proxy.original_func, *args, **kwargs) proxy.bind_celery_task(celery_task) config.action('bind_celery_task - %s' % name, register) venusian.attach(proxy, callback, category='pyramid') return proxy
def __call__(self, wrapped): def callback(scanner, name, ob): provides = self.provides if self.direct: component = ob if self.provides is None: provides = list(implementedBy(component))[0] else: component = ob(**self.kw) if self.provides is None: provides = list(providedBy(component))[0] scanner.config.registry.registerUtility(component, provides, self.name) venusian.attach(wrapped, callback) return wrapped
def __call__(self, wrapped): settings = self.__dict__.copy() ## # Register view method defaults for the game class wrapped.__view_defaults__ = { "context": wrapped, "route_name": "traversal", "renderer": "json", "http_cache": 0 } ## def callback(context, name, ob): name = name.lower() # game id is its class name in lowercase config = context.config.with_package(info.module) logger.info("Registering game '%s'." % name) # Register game so that sessions will be able to find it config.registry.registerAdapter( ob, name=name, required=(IApplication,), provided=IGame) # Register main template for the game if settings.get("add_view", True): config.add_route(name, "/%s/" % name, request_method="GET") config.add_view(route_name=name, renderer="%s.html" % name) # Register game specific static assets if settings.get("add_asset_views", True): dirname = os.path.dirname(info.module.__file__) try: resources = map(lambda x: os.path.join(dirname, x), os.listdir(dirname)) except OSError: resources = () for path in filter(lambda x: os.path.isfile(x), resources): basename = os.path.basename(path) config.add_route(path, "/%s/%s" % (name, basename), request_method="GET") if path.endswith('.js') or path.endswith('.css'): #print 'register', path config.add_view(route_name=path, view=static_file(path), http_cache=3600) else: config.add_view(route_name=path, view=static_file(path)) for path in filter(lambda x: os.path.isdir(x), resources): #print 'static register', path basename = os.path.basename(path) config.add_static_view("%s/%s" % (name, basename), path=path, cache_max_age=3600) info = venusian.attach(wrapped, callback, category="pyramid") return wrapped
def __call__(self, callable): def callback(context, name, callable): config = context.config.with_package(info.module) config.add_deserializer(self.content_type, callable, **settings) info = venusian.attach(callable, callback) settings = {'_info': info.codeinfo} return callable
def __init__(self, name, path=None, description=None, cors_policy=None, depth=1, pyramid_route=None, **kw): self.name = name self.path = path self.pyramid_route = pyramid_route if not self.path and not self.pyramid_route: raise TypeError('You need to pass path or pyramid_route arg') self.description = description self.cors_expose_all_headers = True self._cors_enabled = None if cors_policy: for key, value in cors_policy.items(): kw.setdefault('cors_' + key, value) for key in self.list_arguments: # default_{validators,filters} and {filters,validators} don't # have to be mutables, so we need to create a new list from them extra = to_list(kw.get(key, [])) kw[key] = [] kw[key].extend(getattr(self, 'default_%s' % key, [])) kw[key].extend(extra) self.arguments = self.get_arguments(kw) for key, value in self.arguments.items(): # avoid squashing Service.decorator if ``decorator`` # argument is used to specify a default pyramid view # decorator if key != 'decorator': setattr(self, key, value) if hasattr(self, 'acl'): raise ConfigurationError("'acl' is not supported") # instantiate some variables we use to keep track of what's defined for # this service. self.defined_methods = [] self.definitions = [] # add this service to the list of available services SERVICES.append(self) # this callback will be called when config.scan (from pyramid) will # be triggered. def callback(context, name, ob): config = context.config.with_package(info.module) config.add_cornice_service(self) info = venusian.attach(self, callback, category='pyramid', depth=depth)
def __call__(self, wrapped): def callback(context, name, ob): cfg = context.config.with_package(info.module) add_template_filter(cfg, self.template, ob, self.name, self.description) info = venusian.attach(wrapped, callback, category='djed.renderer') return wrapped
def wrapper(wrapped): info = venusian.attach(wrapped, callback, category="pyramid") # Support use as a class method decorator. # Taken from Pyramid's `view_config` decorator implementation. if info.scope == "class": if settings.get("attr") is None: settings["attr"] = wrapped.__name__ return wrapped
def __call__(self, wrapped): original_name = wrapped.__name__ self._settings["original_name"] = original_name if self._settings["method_name"] is None: self._settings["method_name"] = original_name self.info = venusian.attach(wrapped, self.register, category='extdirect') return wrapped
def __call__(self, cls): def callback(context, name, cls): config = context.config.with_package(info.module) directive = getattr(config, self.directive_name) directive(self.resource_path, cls, **settings) info = venusian.attach(cls, callback) settings = {'_info': info.codeinfo} return cls
def __call__(self, cls): self.info = venusian.attach(cls, self.callback, category='pyramid') self.view_class = cls self.__doc__ = cls.__doc__ methods = self.singular_methods if self.singular else self.methods views = inspect.getmembers( cls, lambda m: inspect.ismethod(m) and m.__name__ in methods) for name, view in views: self.views[name] = ViewInfo(view, self.info, name, {}) return cls