def __call__(self, html, fields, context):
     html.data("fields", len(fields))
     for name, value in iteritems(fields):
         if is_string(value):
             html.append(Html("div", value, field=name))
         else:
             html.append(Html("div", field=name, value=value))

 def _auth_header(self, type, **options):
     """Convert the stored values into a WWW-Authenticate header."""
     return '%s %s' % (type.title(), ', '.join((
         '%s=%s' % (key, quote_header_value(
             value, allow_token=key not in _require_quoting))
         for key, value in iteritems(options)
     )))

 def stream(self, whitespace=''):
     '''This function convert the :class:`css` element into a string.'''
     # First we execute mixins
     if self.rendered:
         raise RuntimeError('%s already rendered' % self)
     self.rendered = True
     children = self._children
     self._children = OrderedDict()
     for tag, clist in iteritems(children):
         for c in clist:
             c._parent = None
             s = c.set_parent(self)
             if s:   # the child (mixin) has return a string, added it.
                 yield (None, s)
     data = []
     for k, v in self._attributes:
         v = as_value(v)
         if v is not None:
             data.append('%s    %s: %s;' % (whitespace, k, v))
     if data:
         yield (self.tag, '\n'.join(data))
     # yield Mixins and children
     for child_list in itervalues(self._children):
         if isinstance(child_list, list):
             child = child_list[0]
             for c in child_list[1:]:
                 child.extend(c)
             for s in child.stream(whitespace):
                 yield s
         else:
             yield None, child_list

def stream_mapping(value, request=None):
    result = {}
    for key, value in iteritems(value):
        if isinstance(value, AsyncString):
            value = value.render(request)
        result[key] = value
    return multi_async(result)

    def zadd(self, name, *args, **kwargs):
        """
        Set any number of score, element-name pairs to the key ``name``. Pairs
        can be specified in two ways:

        As ``*args``, in the form of::

            score1, name1, score2, name2, ...

        or as ``**kwargs``, in the form of::

            name1=score1, name2=score2, ...

        The following example would add four values to the 'my-key' key::

            client.zadd('my-key', 1.1, 'name1', 2.2, 'name2',
                        name3=3.3, name4=4.4)
        """
        pieces = []
        if args:
            if len(args) % 2 != 0:
                raise ValueError("ZADD requires an equal number of "
                                 "values and scores")
            pieces.extend(args)
        for pair in iteritems(kwargs):
            pieces.append(pair[1])
            pieces.append(pair[0])
        return self.execute_command('ZADD', name, *pieces)

 def apply_content(self, elem, content):
     elem.data({'id': content.id, 'content_type': content.content_type})
     for name, value in chain((('title', content.title),
                               ('keywords', content.keywords)),
                              iteritems(content.data)):
         if not is_string(value):
             elem.data(name, value)
         elif value:
             elem.append(Html('div', value, field=name))

 def _():
     for data, tags in iteritems(od):
         if tags:
             yield ',\n'.join(('%s%s' % (whitespace, t) for t in tags)
                              ) + ' {'
             yield data
             yield whitespace + '}\n'
         else:
             yield data

def _spawn_actor(cls, monitor, cfg=None, name=None, aid=None, **kw):
    # Internal function which spawns a new Actor and return its
    # ActorProxyMonitor.
    # *cls* is the Actor class
    # *monitor* can be either the ariber or a monitor
    kind = None
    if issubclass(cls, PoolMixin):
        kind = 'monitor'
    if monitor:
        params = monitor.actorparams()
        name = params.pop('name', name)
        aid = params.pop('aid', aid)
        cfg = params.pop('cfg', cfg)

    # get config if not available
    if cfg is None:
        if monitor:
            cfg = monitor.cfg.copy()
        else:
            cfg = Config()

    if not monitor:  # monitor not available, this is the arbiter
        if kind != 'monitor':
            raise TypeError('class %s not a valid monitor' % cls)
        kind = 'arbiter'
        params = {}
        if not cfg.exc_id:
            if not aid:
                aid = gen_unique_id()[:8]
            cfg.set('exc_id', aid)
    #
    for key, value in iteritems(kw):
        if key in cfg.settings:
            cfg.set(key, value)
        else:
            params[key] = value
    #
    if monitor:
        if not kind:
            if not issubclass(cls, Actor):
                raise TypeError('Class %s not a valid actor.' % cls)
            kind = cfg.concurrency
    if not kind:
        raise TypeError('Cannot spawn class %s. not a valid concurrency.'
                        % cls)
    actor_proxy = concurrency(kind, cls, monitor, cfg, name=name,
                              aid=aid, **params)
    # Add to the list of managed actors if this is a remote actor
    if isinstance(actor_proxy, Actor):
        return actor_proxy
    else:
        actor_proxy.monitor = monitor
        monitor.managed_actors[actor_proxy.aid] = actor_proxy
        future = actor_proxy_future(actor_proxy)
        actor_proxy.start()
        return future

def stream_mapping(value, request=None):
    result = {}
    async = False
    for key, value in iteritems(value):
        if isinstance(value, AsyncString):
            value = value.content(request)
        value = maybe_async(value)
        async = async or isinstance(value, Deferred)
        result[key] = value
    return multi_async(result) if async else result

    def manage_actors(self, stop=False):
        '''Remove :class:`Actor` which are not alive from the
:class:`PoolMixin.managed_actors` and return the number of actors still alive.

:parameter stop: if ``True`` stops all alive actor.
'''
        alive = 0
        if self.managed_actors:
            for aid, actor in list(iteritems(self.managed_actors)):
                alive += self.manage_actor(actor, stop)
        return alive

    def initials(cls):
        '''Iterator over initial field values.

        Check the :attr:`Field.initial` attribute for more information.
        This class method can be useful when using forms outside web
        applications.
        '''
        for name, field in iteritems(cls.base_fields):
            initial = field.get_initial(cls)
            if initial is not None:
                yield name, initial

 def poll(self, timeout=None):
     readable, writeable, errors = _select(
         self.read_fds, self.write_fds, self.error_fds, timeout)
     events = {}
     for fd in readable:
         events[fd] = events.get(fd, 0) | READ
     for fd in writeable:
         events[fd] = events.get(fd, 0) | WRITE
     for fd in errors:
         events[fd] = events.get(fd, 0) | ERROR
     return list(iteritems(events))

 def update(self, *args, **kwargs):
     if len(args) == 1:
         iterable = args[0]
         if isinstance(iterable, Mapping):
             iterable = iteritems(iterable)
         super(Model, self).update(((mstr(k), v)
                                    for k, v in iterable))
         self._modified = 1
     elif args:
         raise TypeError('expected at most 1 arguments, got %s' % len(args))
     if kwargs:
         super(Model, self).update(**kwargs)
         self._modified = 1

    def commit(self):
        '''Commit the transaction.

        This method can be invoked once only otherwise an
        :class:`.InvalidOperation` occurs.

        :return: a :class:`~asyncio.Future` which results in this transaction
        '''
        if self._executed is None:
            fut = multi_async((store.execute_transaction(commands) for
                               store, commands in iteritems(self._commands)))
            self._executed = fut
            return self._executed
        else:
            raise InvalidOperation('Transaction already executed.')

 def data(self, *args):
     '''Add or retrieve data values for this :class:`Html`.'''
     data = self._data
     if not args:
         return data or {}
     result, adding = self._attrdata('data', *args)
     if adding:
         if data is None:
             self._extra['data'] = {}
         add = self._visitor.add_data
         for key, value in iteritems(result):
             add(self, key, value)
         return self
     else:
         return result

    def copy_many_times_events(self, other):
        '''Copy :ref:`many times events <many-times-event>` from  ``other``.

        All many times events of ``other`` are copied to this handler
        provided the events handlers already exist.
        '''
        if isinstance(other, EventHandler):
            events = self._events
            for name, event in iteritems(other._events):
                if isinstance(event, Event) and event._handlers:
                    ev = events.get(name)
                    # If the event is available add it
                    if ev:
                        for callback in event._handlers:
                            ev.bind(callback)

def pubsub_publish(request, id, channel, message):
    monitor = request.actor
    if not channel or channel == '*':
        matched = ((c, reg[1]) for c, reg in
                   iteritems(_get_pubsub_channels(monitor)))
    else:
        matched = _channel_groups(monitor, channel)
    clients = set()
    # loop over matched channels
    for channel, group in matched:
        for aid, pid in group:
            # if the id is matched we have a client
            if pid == id:
                clients.add(aid)
                monitor.send(aid, 'pubsub_broadcast', id, channel, message)
    return len(clients)

 def _setup(self, cn=None, attr=None, css=None, data=None, type=None,
            **params):
     self._visitor = html_visitor(self._tag)
     self.addClass(cn)
     self.data(data)
     self.attr(attr)
     self.css(css)
     attributes = self.available_attributes
     if type and 'type' in attributes:
         self.attr('type', type)
         attributes = self.available_attributes
     for name, value in iteritems(params):
         if name in attributes:
             self.attr(name, value)
         else:
             self.data(name, value)

 def css(self, tag, *components, **attributes):
     '''A child :class:`Css` elements.'''
     if tag:
         elems = [Css(t) for t in alltags(tag)]
     else:
         elems = [Css(tag)]
     for clone, css in enumerate(elems):
         for name, value in iteritems(attributes):
             css[name] = value
         css.set_parent(self)
         # Loop over components to add them to self
         for cl in components:
             if not isinstance(cl, list):
                 cl = (cl,)
             for c in cl:
                 css.add(c.clone() if clone else c)
     return elems[0] if len(elems) == 1 else elems

    def commit(self):
        """Commit the transaction.

        This method can be invoked once only otherwise an
        :class:`.InvalidOperation` occurs.

        :return: a :class:`~asyncio.Future` which results in the list
            of  transaction
        """
        if self._executed is None:
            executed = dict(
                ((store, store.execute_transaction(commands)) for store, commands in iteritems(self._commands))
            )
            self._executed = multi_async(executed, loop=self._loop)
            return self._executed
        else:
            raise InvalidOperation("Transaction already executed.")