The goless library provides Go programming languagesemantics built on top of gevent, PyPy, or Stackless Python.

For an example of what goless can do,here is the Go program at https://gobyexample.com/selectreimplemented with goless:

c1 = goless.chan()c2 = goless.chan()def func1():    time.sleep(1)    c1.send(one)goless.go(func1)def func2():    time.sleep(2)    c2.send(two)goless.go(func2)for i in range(2):    case, val = goless.select([goless.rcase(c1), goless.rcase(c2)])    print(val)

It is surely a testament to Gos style that it isnt much less Python code than Go code,but I quite like this. Dont you?

The goless.go() function mimics Gos goroutines by, unsurprisingly,running the routine in a tasklet/greenlet.If an unhandled exception occurs in a goroutine, goless.on_panic() is called.

Run a function in a new tasklet, like a goroutine.If the goroutine raises an unhandled exception (panics),the goless.on_panic() will be called,which by default logs the error and exits the process.

Called when there is an unhandled error in a goroutine.By default, logs and exits the process.

There are three types of channels available in goless.Use the goless.chan() function to create a channel.The channel implementations contain more thorough documentationabout how they actually work.

Returns a bidirectional channel.

A 0 or None size indicates a blocking channel(the send method will block until a receiver is available,and the recv method will block until a sender is available).

A positive integer value will return a channel with a buffer.Once the buffer is filled, the send method will block.When the buffer is empty, the recv method will block.

A negative integer will return a channel that willnever block when the send method is called.The recv method will block if the buffer is empty.

A Go-like channel that can be sent to, received from,and closed.Callers should never create this directly.Always use goless.chan() to create channels.

Closes the channel, not allowing further communication.Any blocking senders or receivers will be woken up andraise goless.ChannelClosed.Receiving or sending to a closed channelwill raise goless.ChannelClosed.

Receive a value from the channel.Receiving will always block if no value is available.If the channel is already closed,goless.ChannelClosed will be raised.If the channel closes during a blocking recv,goless.ChannelClosed will be raised. (#TODO)

Sends the value. Blocking behavior depends on the channel type.Unbufferred channels block if no receiver is waiting.Buffered channels block if the buffer is full.Asynchronous channels never block on send.

If the channel is already closed,goless.ChannelClosed will be raised.If the channel closes during a blocking send,goless.ChannelClosed will be raised. (#TODO)

Exception raised to indicate a channel is closing or has closed.

Gos select statement is implemented through the goless.select() function.Because Python lacks anonymous blocks (multiline lambdas),goless.select() works like Gos reflect.Select function.Callers should create any number of goless.case classesthat are passed into goless.select().The function returns the chosen case, which the caller will usually switch off of.For example:

chan = goless.chan()cases = [goless.rcase(chan), goless.scase(chan, 1), goless.dcase()]chosen, value = goless.select(cases)if chosen is cases[0]:    print(Received %s % value)elif chosen is cases[1]:    assert value is None    print(Sent.)else:    assert chosen is cases[2]    print(Default...)

Callers should never have to do anything with cases,other than create and switch off of them.

Select the first case that becomes ready.If a default case (goless.dcase) is present,return that if no other cases are ready.If there is no default case and no case is ready,block until one becomes ready.

See Gos reflect.Select method for an analog(http://golang.org/pkg/reflect/#Select).

The default case.

A case that will chan.recv() when the channel is able to receive.

A case that will chan.send(value)when the channel is able to send.

Exception handling is a tricky topic and may change in the future.The default behavior right now is that an unhandled exception in a goroutine willlog the exception and take down the entire process.This in theory emulates Gos panic behavior:if a goroutine panics, the process will exit.

If you are not happy with this behavior,you should patch goless.on_panic to provide custom behavior.

If you find a better pattern, create an issue on GitHub.

The examples/ folder contains a number of examples.

In addtion,there are many examples from http://gobyexample.com implementedvia goless in the tests/test_examples.py file.

If there is an example youd like to see,or an idiomatic Go example youd like converted,please see Contributing below.

You can run benchmarks using the current Python interpreter and configuredbackend by running the following from the goless project directory:

$ python -m benchmark

Developers may run benchmarks locally and report them into the following table.The Go versions of the benchmarks are also run.The numbers are useful for relative comparisons only:

To regenerate this table, run:

$ python write_benchmarks.py

To print the table to stdout, run (notice the trailing - char):

$ python write_benchresults.py -

Assuming you have Go installed, you can run the benchmarks with:

$ go run benchmark.go

There are two backends for concurrently available ingoless.backends.Backends should only be used by goless,and not by any client code.You can choose between backends by setting the environment variableGOLESS_BACKEND to gevent or stackless.Otherwise, an appropriate backend will be chosen.If neither gevent or stackless are available,goless will raise an error when used (but will still be importable).

The good news is that you probably dont need to worry about any of this,and goless works almost everywhere.

The bad news is, almost all abstractions are leaky,and there can be some nuances to compatibility.If you run into an issue where goless cannot create a backend,you may need to read the following sections.

goless works under PyPy out of the box with the stacklessbackend, because PyPy includes a stackless.py file in its standard library.This appears to work properly, but fails the goless test suite.We are not sure why yet, as stackless.py does not have a real maintainerand the bug is difficult to track down.However, the examples and common usages seem to all work fine.

Using PyPy 2.2+ and the tip of gevents GitHub repo( https://github.com/surfly/gevent ),the gevent backend works and is fully tested.

Using Python 2 and the CPython interpreter,you can use the gevent backend for golesswith no problems.Under Python 2, you can just do:

$ pip install gevent$ pip install goless

Newer versions of gevent include Python 3 compatibility.To install gevent on Python3, you also must install Cython.So you can use thew following commands to install golessunder Python3 with its gevent backend:

$ pip install cython$ pip install git+https://github.com/surfly/gevent.git#gevent-egg$ pip install goless

This works and is tested.

All versions of Stackless Python (2 and 3) should work with goless.However, we cannot test with Stackless Python on Travis,so we only test with it locally.If you find any problems, please report an issue.

goless does not address CPythons Global Interpreter Lock (GIL) at all.goless does not magically provide any parallelization.It provides Go-like semantics, but not its performance.Perhaps this will change in the future if the GIL is removed.Another option is PyPys STM branch,which goless will (probably) benefit heartily.

I am definitely not a Go expert,so improvements to make things more idiomatic are very welcome.Please create an issue or pull request on GitHub: https://github.com/rgalanakis/goless

goless was created by a number of people at the PyCon 2014 sprints.Even a small library like goless is the product of lots of collaboration.

Maintainers:

Special thanks:

Coverage is wrong. It should be higher.The coverage module does not work properly with gevent and stackless.