def pipeline():
files = goless.chan()
hashes = goless.chan()
results = goless.chan()
def scanner():
for d, dn, f in os.walk('.'):
for fn in f:
files.send(os.path.join(d,fn))
files.close()
def hasher():
for f in files:
with open(f, 'rb') as fd:
md5 = hashlib.md5(fd.read()).hexdigest()
hashes.send((f, md5))
hashes.close()
def collector():
for f, md5 in hashes:
results.send((f, md5))
results.close()
goless.go(scanner)
goless.go(hasher)
goless.go(collector)
for filename, md5hash in results:
print('%s: %s' % (filename, md5hash))
def run():
channels = {
'c1': goless.chan(0),
'c2': goless.chan(0),
'c3': goless.chan(0)
}
workers = [make_worker(logme, channels['c1'], channels['c2']),
make_worker(logme, channels['c2'], channels['c3'])]
logging.info("run: defining send_messages...")
print("run: defining send_messages...")
def send_messages():
for ii in range(10):
print("sending val={} into channel['c1']={}", val, channels['c1'])
val = "val:{}".format(ii)
channels['c1'].send(val)
res = goless.go(send_messages)
print("called goless.go(send_messages) => {}".format(res))
while True:
cases = [goless.rcase(channels['c3']),
goless.dcase()]
case, val = goless.select(cases)
if case == cases[1]:
print("hit default, perhaps things are closed? case={} val={}".format(case, val))
break
print("case={}; c3 => {}".format(case, val))
print("closing channel c3")
channels['c3'].close()
print("exiting")
def main():
done = goless.chan()
msgs = goless.chan()
out = goless.chan()
def produce():
for i in range(10):
msgs.send(i)
msgs.close()
def consume(name):
for msg in msgs:
out.send('%s:%s ' % (name, msg))
out.close()
def logger():
for msg in out:
sys.stdout.write(msg)
sys.stdout.write('\n')
done.send()
goless.go(produce)
goless.go(consume, "one")
goless.go(consume, "two")
goless.go(logger)
done.recv()
def pipeline():
files = goless.chan()
hashes = goless.chan()
results = goless.chan()
def scanner():
for d, dn, f in os.walk('.'):
for fn in f:
files.send(os.path.join(d, fn))
files.close()
def hasher():
for f in files:
with open(f, 'rb') as fd:
md5 = hashlib.md5(fd.read()).hexdigest()
hashes.send((f, md5))
hashes.close()
def collector():
for f, md5 in hashes:
results.send((f, md5))
results.close()
goless.go(scanner)
goless.go(hasher)
goless.go(collector)
for filename, md5hash in results:
print('%s: %s' % (filename, md5hash))
def test_select_chooses_ready_selection(self):
readychan = goless.chan(1)
notreadychan = goless.chan(1)
readychan.send(3)
cases = [goless.rcase(notreadychan), goless.rcase(readychan), goless.dcase()]
result, val = goless.select(cases)
self.assertIs(result, cases[1])
self.assertEqual(val, 3)
def test_select_chooses_ready_selection(self):
readychan = goless.chan(1)
notreadychan = goless.chan(1)
readychan.send(3)
cases = [goless.rcase(notreadychan), goless.rcase(readychan), goless.dcase()]
result, val = goless.select(cases)
self.assertIs(result, cases[1])
self.assertEqual(val, 3)
def test_select_raises_for_list_and_args(self):
chan1 = goless.chan(1)
chan2 = goless.chan(1)
chan3 = goless.chan(1)
cases = [goless.scase(chan1, 1), goless.scase(chan2, 2)]
with self.assertRaises(TypeError):
goless.select(cases, chan3)
def test_select_raises_for_list_and_args(self):
chan1 = goless.chan(1)
chan2 = goless.chan(1)
chan3 = goless.chan(1)
cases = [goless.scase(chan1, 1), goless.scase(chan2, 2)]
with self.assertRaises(TypeError):
goless.select(cases, chan3)
def test_select_no_default_no_ready_blocks(self):
chan1 = goless.chan()
chan2 = goless.chan()
a = []
cases = [goless.rcase(chan2), goless.rcase(chan1)]
def sel():
a.append(goless.select(cases))
be.run(sel)
self.assertEqual(a, [])
chan1.send(5)
be.yield_()
self.assertEqual(len(a), 1)
chosen, val = a[0]
self.assertEqual(chosen, cases[1])
self.assertEqual(val, 5)
def test_select_no_default_no_ready_blocks(self):
chan1 = goless.chan()
chan2 = goless.chan()
a = []
cases = [goless.rcase(chan2), goless.rcase(chan1)]
def sel():
a.append(goless.select(cases))
be.run(sel)
self.assertEqual(a, [])
chan1.send(5)
be.yield_()
self.assertEqual(len(a), 1)
chosen, val = a[0]
self.assertEqual(chosen, cases[1])
self.assertEqual(val, 5)
def test_range_over_channels(self):
# https://gobyexample.com/range-over-channels
queue = goless.chan(2)
queue.send('one')
queue.send('two')
queue.close()
elements = [elem for elem in queue]
self.assertEqual(elements, ['one', 'two'])
def test_range_over_channels(self):
# https://gobyexample.com/range-over-channels
queue = goless.chan(2)
queue.send('one')
queue.send('two')
queue.close()
elements = [elem for elem in queue]
self.assertEqual(elements, ['one', 'two'])
def integers():
yielder = goless.chan()
def counter():
count = 0
while True:
yielder.send(count)
count += 1
goless.go(counter)
return yielder
def test_case_switch(self):
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], chosen
print('Default...')
def test_case_switch(self):
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], chosen
print('Default...')
def simple():
channel = goless.chan()
def goroutine():
while True:
value = channel.recv()
channel.send(value ** 2)
goless.go(goroutine)
for i in range(2, 5):
channel.send(i)
squared = channel.recv()
print('%s squared is %s' % (i, squared))
def test_select(self):
# https://gobyexample.com/select
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)
# We don't print since we run this as a test.
callbacks = []
for i in range(2):
_, val = goless.select([goless.rcase(c1), goless.rcase(c2)])
callbacks.append(val)
self.assertEqual(callbacks, ['one', 'two'])
def test_select(self):
# https://gobyexample.com/select
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)
# We don't print since we run this as a test.
callbacks = []
for i in range(2):
_, val = goless.select([goless.rcase(c1), goless.rcase(c2)])
callbacks.append(val)
self.assertEqual(callbacks, ['one', 'two'])
def simple():
channel = goless.chan()
def goroutine():
while True:
value = channel.recv()
channel.send(value**2)
goless.go(goroutine)
for i in range(2, 5):
channel.send(i)
squared = channel.recv()
print('%s squared is %s' % (i, squared))
def read_infrared_sensor(port):
infrared_readings = goless.chan()
start_infrared_sensor(brick, port, infrared_readings)
while True:
value = infrared_readings.recv()
if isinstance(value, brickpi3.SensorError):
socketio.emit('error', {'message': 'error in infrared sensor', 'error': str(value)})
break
message_type = 'infrared_' + value[0]
message_data = {'data': value[1]}
socketio.emit(message_type, message_data)
print('emitted', message_type, message_data)
socketio.sleep(0.05)
def read_touch_sensor(port):
touch_readings = goless.chan()
start_touch_sensor(brick, port, touch_readings)
while True:
value = touch_readings.recv()
if isinstance(value, brickpi3.SensorError):
socketio.emit('error', {'message': 'error in touch sensor', 'error': str(value)})
break
message_type = 'touch'
message_data = {'data': value}
socketio.emit(message_type, message_data)
print('emitted', message_type, message_data)
socketio.sleep(0.05)
def test_worker_pool(self):
# https://gobyexample.com/worker-pools
jobs_done = []
# noinspection PyShadowingNames,PyShadowingBuiltins
def worker(id, jobs, results):
for j in jobs:
jobs_done.append('w %s j %s' % (id, j))
time.sleep(.01)
results.send(j * 2)
jobs = goless.chan(100)
results = goless.chan(100)
for w in range(1, 4):
goless.go(lambda: worker(w, jobs, results))
for j in range(1, 10):
jobs.send(j)
jobs.close()
for a in range(1, 10):
results.recv()
self.assertEqual(len(jobs_done), 9)
def test_worker_pool(self):
# https://gobyexample.com/worker-pools
jobs_done = []
# noinspection PyShadowingNames,PyShadowingBuiltins
def worker(id, jobs, results):
for j in jobs:
jobs_done.append('w %s j %s' % (id, j))
time.sleep(.01)
results.send(j * 2)
jobs = goless.chan(100)
results = goless.chan(100)
for w in range(1, 4):
goless.go(lambda: worker(w, jobs, results))
for j in range(1, 10):
jobs.send(j)
jobs.close()
for a in range(1, 10):
results.recv()
self.assertEqual(len(jobs_done), 9)
def pfor():
n = 10
items = range(n)
results = [None] * n
semaphore = goless.chan(n)
def mapper(index, value):
results[index] = dosomething(value)
semaphore.send()
for i, item in enumerate(items):
mapper(i, item)
for _ in range(n):
semaphore.recv()
print('Finished: %s' % results)
def bench_channel(chan_size):
c = chan(chan_size)
def func():
for _ in xrange(QUEUE_LEN):
c.send(0)
c.close()
count = 0
go(func)
start = time.clock()
for _ in xrange(QUEUE_LEN):
c.recv()
count += 1
end = time.clock()
return end - start
def bench_channel(chan_size):
c = chan(chan_size)
def func():
for _ in xrange(QUEUE_LEN):
c.send(0)
c.close()
count = 0
go(func)
start = time.clock()
for _ in xrange(QUEUE_LEN):
c.recv()
count += 1
end = time.clock()
return end - start
def test_successful_recv_does_yield_control(self):
"""Test that send with a waiting receiver
*does* give control to the waiting receiver."""
chan = goless.chan()
actions = []
def other():
actions.append('send pending')
chan.send()
actions.append('send acted')
goless.go(other)
actions.append('recv pending')
chan.recv()
actions.append('recv acted')
self.assertEqual(actions, [
'recv pending',
'send pending',
'recv acted',
])
def bench_select(use_default):
c = chan(0)
cases = [
selecting.scase(c, 1),
selecting.rcase(c),
selecting.scase(c, 1),
selecting.rcase(c),
]
if use_default:
cases.append(selecting.dcase())
def sender():
while True:
c.send(0)
c.recv()
go(sender)
start = time.clock()
for i in xrange(QUEUE_LEN):
selecting.select(cases)
end = time.clock()
return end - start
def test_successful_recv_continues(self):
"""Test that recv with a waiting sender
*does not* give control to the waiting sender."""
chan = goless.chan()
actions = []
def other():
actions.append('recv pending')
chan.recv()
actions.append('recv acted')
goless.go(other)
actions.append('send pending')
chan.send()
actions.append('send acted')
self.assertEqual(actions, [
'send pending',
'recv pending',
'recv acted',
'send acted',
])
def bench_select(use_default):
c = chan(0)
cases = [
selecting.scase(c, 1),
selecting.rcase(c),
selecting.scase(c, 1),
selecting.rcase(c),
]
if use_default:
cases.append(selecting.dcase())
def sender():
while True:
c.send(0)
c.recv()
go(sender)
start = time.clock()
for i in xrange(QUEUE_LEN):
selecting.select(cases)
end = time.clock()
return end - start
def test_select_accepts_args(self):
chan1 = goless.chan(1)
scase = goless.scase(chan1, 1)
chosen, val = goless.select(scase)
self.assertIs(chosen, scase)
self.assertIsNone(val)
def setUp(self):
BaseTests.setUp(self)
self.ch = goless.chan(self.chansize)
self.ca = goless.rcase(self.ch)
def setUp(self):
BaseTests.setUp(self)
self.chan1 = goless.chan()
def setUp(self):
BaseTests.setUp(self)
self.ch = goless.chan(self.chansize)
self.sendval = 1
self.ca = goless.scase(self.ch, self.sendval)
def test_raises_deadlock_if_no_goroutines(self):
with self.assertRaises(goless.Deadlock):
goless.select(goless.rcase(goless.chan()))
def inverse_async(future):
c = goless.chan()
goless.go(lambda: c.send(future.recv() * -1))
return c
def setUp(self):
BaseTests.setUp(self)
self.ch = goless.chan(self.chansize)
self.sendval = 1
self.ca = goless.scase(self.ch, self.sendval)
import goless, time
channels = []
channels.append(goless.chan())
channels.append(goless.chan())
channels.append(goless.chan())
def makeWorker(params):
name = params['name']
def func1():
print("{}[{}] waiting for val".format(name, params['val']))
case, val = goless.select([goless.rcase(params['cin'])])
print("{}[{}] got case={}, val={}".format(name, params['val'], case, val))
time.sleep(params['sleep'])
print("{}[{}] sending to cout...".format(name, params['val']))
params['cout'].send("(" + name + ")=" + val + ";" + params['val'])
return func1
funcs = [makeWorker({
'name': 'workerA',
'cin': channels[0],
'cout': channels[1],
'val': 'one',
'sleep': 1
}),
makeWorker({
'name': 'workerB',
'cin': channels[1],
'cout': channels[2],
'val': 'two',
'sleep': 1
def __init__(self, function, bufferSize=0):
self.__pause = False
self.__function = function
self.__channel = chan(bufferSize)
def product_async(future_a, future_b):
c = goless.chan()
goless.go(lambda: c.send(future_a.recv() * future_b.recv()))
return c
def inverse_async(future):
c = goless.chan()
goless.go(lambda: c.send(future.recv() * -1))
return c
def promise(value):
future = goless.chan(1)
future.send(value)
return future
def product_async(future_a, future_b):
c = goless.chan()
goless.go(lambda: c.send(future_a.recv() * future_b.recv()))
return c
def test_main_tasklet_can_select(self):
chan1 = goless.chan(1)
cases = [goless.scase(chan1, 3)]
chosen, val = goless.select(cases)
self.assertIs(chosen, cases[0])
self.assertIsNone(val)
def test_raises_deadlock_if_no_goroutines(self):
with self.assertRaises(goless.Deadlock):
goless.select(goless.rcase(goless.chan()))
if sensor_value:
channel.send((sensor_mode[1], sensor_value))
if isinstance(sensor_value, brickpi3.SensorError):
break
def read_sensor(brick, port, sensor_type):
try:
brick.set_sensor_type(port, sensor_type)
time.sleep(0.01)
return brick.get_sensor(port)
except brickpi3.SensorError as error:
print("error infrared", error)
return error
if __name__ == '__main__':
print('for local testing read 100 infrared readings from port 1')
brick = brickpi3.BrickPi3()
readings = goless.chan()
print('start infrared sensor')
start_infrared_sensor(brick, brick.PORT_2, readings)
for i in range(100):
case, val = goless.select([goless.rcase(readings)])
print(case, val)
print('100 reading are done, time to clean and exit')
brick.reset_all()
def promise(value):
future = goless.chan(1)
future.send(value)
return future
def setUp(self):
BaseTests.setUp(self)
self.ch = goless.chan(self.chansize)
self.ca = goless.rcase(self.ch)
def __init__(self, bufferSize=0):
self.__pause = False
self.__channel = chan(bufferSize)
def test_main_tasklet_can_select(self):
chan1 = goless.chan(1)
cases = [goless.scase(chan1, 3)]
chosen, val = goless.select(cases)
self.assertIs(chosen, cases[0])
self.assertIsNone(val)
def test_select_accepts_args(self):
chan1 = goless.chan(1)
scase = goless.scase(chan1, 1)
chosen, val = goless.select(scase)
self.assertIs(chosen, scase)
self.assertIsNone(val)
def setUp(self):
BaseTests.setUp(self)
self.chan1 = goless.chan()
