def bind(self, **kwargs):
aio_loop = kwargs.pop('<STR_LIT>', None)<EOL>props = self.__property_events<EOL>events = self.__events<EOL>for name, cb in kwargs.items():<EOL><INDENT>if name in props:<EOL><INDENT>e = props[name]<EOL><DEDENT>else:<EOL><INDENT>e = events[name]<EOL><DEDENT>e.add_listener(cb, __aio_loop__=aio_loop)<EOL><DEDENT>
Subscribes to events or to :class:`~pydispatch.properties.Property` updates

        Keyword arguments are used with the Event or Property names as keys
        and the callbacks as values::

            class Foo(Dispatcher):
                name = Property()

            foo = Foo()

            foo.bind(name=my_listener.on_foo_name_changed)
            foo.bind(name=other_listener.on_name,
                     value=other_listener.on_value)

        The callbacks are stored as weak references and their order is not
        maintained relative to the order of binding.

        **Async Callbacks**:

            Callbacks may be :term:`coroutine functions <coroutine function>`
            (defined using :keyword:`async def` or decorated with
            :func:`@asyncio.coroutine <asyncio.coroutine>`), but an event loop
            must be explicitly provided with the keyword
            argument ``"__aio_loop__"`` (an instance of
            :class:`asyncio.BaseEventLoop`)::

                import asyncio
                from pydispatch import Dispatcher

                class Foo(Dispatcher):
                    _events_ = ['test_event']

                class Bar(object):
                    def __init__(self):
                        self.got_foo_event = asyncio.Event()
                    async def wait_for_foo(self):
                        await self.got_foo_event.wait()
                        print('got foo!')
                    async def on_foo_test_event(self, *args, **kwargs):
                        self.got_foo_event.set()

                foo = Foo()
                bar = Bar()

                loop = asyncio.get_event_loop()
                foo.bind(test_event=bar.on_foo_test_event, __aio_loop__=loop)

                loop.run_until_complete(bar.wait_for_foo())

            This can also be done using :meth:`bind_async`.

            .. versionadded:: 0.1.0