Author: Maries Ionel Cristian


This is a library for network oriented, coroutine based programming.

*cogen*'s goal is to enable writing code in a seemingly synchronous and easy
manner in the form of generators that yield calls and receive the result
from that yield. These calls translate to asynchronous and fast os calls
in *cogen*'s internals.

Notable features

* a WSGI server, HTTP1.1 compliant, with asynchronous extensions
* epoll, kqueue, select, i/o completion ports, sendfile behind the scenes
* a couple of useful classes for putting the coroutine to sleep, wait for
  signals, queues, timeouts etc.

Quick introduction
A coroutine is just a generator wrapped in a helper class:


    from cogen.core.coroutines import coroutine

    def mycoro(bla):
        result = yield <operation>
        result = yield <operation>

* the `operation` instructs the scheduler what to do with the coroutine:
  suspend it till something happens, add another coro in the scheduler, raise
  a event and so on.
* if a `operation` has a result associated then the yield will return that
  result (eg. a string or a (connection, address) tuple) otherwise it will
  return the operation instance.

Echo server example


    from cogen.core import sockets
    from cogen.core import schedulers
    from cogen.core.coroutines import coroutine

    def server():
        srv = sockets.Socket()
        print type(srv)
        while 1:
            print "Listening..."
            conn, addr = yield srv.accept()
            print "Connection from %s:%s" % addr
            m.add(handler, args=(conn, addr))

    def handler(sock, addr):
        yield sock.write("WELCOME TO ECHO SERVER !\r\n")

        while 1:
            line = yield sock.readline(8192)
            if line.strip() == 'exit':
                yield sock.write("GOOD BYE")
            yield sock.write(line)

    m = schedulers.Scheduler()



Takes place at:

Grab the latest and greatest from `trunk <>`_ with::

    easy_install cogen==dev