pygolang 0.0.1

GPython

Command gpython provides Python interpreter that supports lightweight threads via tight integration with gevent. The standard library of GPython is API compatible with Python standard library, but inplace of OS threads lightweight coroutines are provided, and IO is internally organized via libuv/libev-based IO scheduler. Consequently programs can spawn lots of coroutines cheaply, and modules like time, socket, ssl, subprocess etc - all could be used from all coroutines simultaneously, and in the same blocking way as if every coroutine was a full OS thread. This gives ability to scale programs without changing concurrency model and existing code.

Additionally GPython sets UTF-8 to be default encoding always, and puts go, chan, select etc into builtin namespace.

Goroutines and channels

go spawns a coroutine, or thread if gevent was not activated. It is possible to exchange data in between either threads or coroutines via channels. chan creates a new channel with Go semantic - either synchronous or buffered. Use chan.recv, chan.send and chan.close for communication. nilchan stands for the nil channel. select can be used to multiplex on several channels. For example:

ch1 = chan()    # synchronous channel
ch2 = chan(3)   # channel with buffer of size 3

def _():
    ch1.send('a')
    ch2.send('b')
go(_)

ch1.recv()      # will give 'a'
ch2.recv_()     # will give ('b', True)

ch2 = nilchan   # rebind ch2 to nil channel
_, _rx = select(
    ch1.recv,           # 0
    ch1.recv_,          # 1
    (ch1.send, obj),    # 2
    ch2.recv,           # 3
    default,            # 4
)
if _ == 0:
    # _rx is what was received from ch1
    ...
if _ == 1:
    # _rx is (rx, ok) of what was received from ch1
    ...
if _ == 2:
    # we know obj was sent to ch1
    ...
if _ == 3:
    # this case will be never selected because
    # send/recv on nil channel block forever.
    ...
if _ == 4:
    # default case
    ...

Methods

func decorator allows to define methods separate from class.

For example:

@func(MyClass)
def my_method(self, ...):
    ...

will define MyClass.my_method().

func can be also used on just functions, for example:

@func
def my_function(...):
    ...

Defer / recover / panic

defer allows to schedule a cleanup to be executed when current function returns. It is similar to try/finally but does not force the cleanup part to be far away in the end. For example:

wc = wcfs.join(zurl)    │     wc = wcfs.join(zurl)
defer(wc.close)         │     try:
                        │        ...
...                     │        ...
...                     │        ...
...                     │     finally:
                        │        wc.close()

For completeness there is recover and panic that allow to program with Go-style error handling, for example:

def _():
   r = recover()
   if r is not None:
      print("recovered. error was: %s" % (r,))
defer(_)

...

panic("aaa")

But recover and panic are probably of less utility since they can be practically natively modelled with try/except.

If defer is used, the function that uses it must be wrapped with @func decorator.

Import

gimport provides way to import python modules by full path in a Go workspace.

For example

lonet = gimport('lab.nexedi.com/kirr/go123/xnet/lonet')

will import either

• lab.nexedi.com/kirr/go123/xnet/lonet.py, or

• lab.nexedi.com/kirr/go123/xnet/lonet/__init__.py

located in src/ under $GOPATH.

Additional packages and utilities

The following additional packages and utilities are also provided to close gaps between Python and Go environments:

print('hello %s' % qq(name))

def bench_add(b):
    x, y = 1, 2
    for i in xrange(b.N):
        x + y

$ py.bench --count=3 x.py
...
pymod: bench_add.py
Benchmarkadd    50000000        0.020 µs/op
Benchmarkadd    50000000        0.020 µs/op
Benchmarkadd    50000000        0.020 µs/op

0.0.1 (2019-05-09)

• Add support for nil channels (commit).

• Add context package to propagate cancellation and task-scoped values among spawned goroutines (commit, overview).

• Add sync package with sync.WorkGroup to spawn group of goroutines working on a common task (commit 1, 2).

• Kill deprecated @method (commit).

0.0.0.dev8 (2019-03-24)

• Fix gpython to properly initialize sys.path (commit).

• Fix channel tests to pass irregardless of surround OS load (commit).

• Deprecate @method(cls) in favour of @func(cls) (commit).

• Support both PyPy2 and PyPy3 (commit 1, 2, 3).

0.0.0.dev7 (2019-01-16)

• Provide gpython interpreter, that sets UTF-8 as default encoding, integrates gevent and puts go, chan, select etc into builtin namespace (commit).

0.0.0.dev6 (2018-12-13)

• Add strconv package with quote and unquote (commit 1, 2).

• Support PyPy as well (commit).

0.0.0.dev5 (2018-10-30)

• Fix select bug that was causing several cases to be potentially executed at the same time (commit 1, 2, 3).

• Add defer and recover (commit). The implementation is partly inspired by work of Denis Kolodin (1, 2).

• Fix @method on Python3 (commit).

• A leaked goroutine no longer prevents whole program to exit (commit 1, 2).

0.0.0.dev4 (2018-07-04)

• Add py.bench program and golang.testing package with corresponding bits (commit).

0.0.0.dev3 (2018-07-02)

• Support both Python2 and Python3; qq now does not escape printable UTF-8 characters. (commit 1, 2, 3).

• golang/x/perf/benchlib: New module to load & work with data in Go benchmark format (commit).

0.0.0.dev2 (2018-06-20)

• Turn into full pygolang: go, chan, select, method and gcompat.qq are provided in addition to gimport (commit). The implementation is not very fast, but should be working correctly including select - select sends for synchronous channels.

0.0.0.dev1 (2018-05-21)

• Initial release; gimport functionality only (commit).