def __init__(self, subscriptions):
self.subscriptions = subscriptions
self.updates_chan = Chan()
self.quit = Chan()
self.thread = threading.Thread(name="Merged", target=self._run)
self.thread.start()
def __init__(self, fetcher):
self.fetcher = fetcher
self.updates_chan = Chan()
self.quit = Chan()
self.thread = threading.Thread(name='Subscription', target=self._run)
#self.thread.daemon = True
self.thread.start()
def test_select_and_closed(self):
a, b, c = [Chan() for _ in range(3)]
out = Chan()
go(sayset, a, [0, 1, 2], delay=0.01, __name='sayset1')
go(sayset, b, [3, 4, 5], delay=0.01, __name='sayset2')
go(sayset, c, [6, 7, 8], delay=0.01, __name='sayset2')
def fanin_until_closed(inchans, outchan):
inchans = inchans[:]
while inchans:
try:
_, val = select(inchans, [])
out.put(val)
except ChanClosed as ex:
inchans.remove(ex.which)
out.close()
go(fanin_until_closed, [a, b, c], out, __name='fanin')
into = []
acc = go(accumulator, out, into)
acc.join(10)
self.assertFalse(acc.is_alive())
results = set(into)
self.assertEqual(len(results), 9)
self.assertEqual(results, set(range(9)))
def write_write_default():
"""Two channels can be read and there's a default clause
Expected output :
-----------------
Writing (42|51) to ch(1|2)
Writing (42|51) to ch(1|2)
Received number (42|51) from ch(1|2)
"""
ch1A = Chan()
ch1B = Chan()
ch2A = Chan()
ch2B = Chan()
def read_channel1():
"""Read the value in ch1A and write it in ch1B"""
py_output.write('Reading from ch1\n'.encode())
x = ch1A.get()
ch1B.put(x)
def read_channel2():
"""Read the value in ch2A and write it in ch2B"""
py_output.write('Reading from ch2\n'.encode())
x = ch2A.get()
ch2B.put(x)
go(read_channel1)
go(read_channel2)
time.sleep(0.1)
# Hopefully this is enough time to let
# the other two goroutines block on their channel writes
nb1 = 42
nb2 = 51
sent = 0
chan, nb = select(consumers=[],
producers=[(ch1A, 42), (ch2A, 51)],
default=True)
if chan == ch1A:
py_output.write('Sent number 42 to ch2\n'.encode())
sent = nb1
elif chan == ch2A:
py_output.write('Sent number 51 to ch2\n'.encode())
sent = nb2
elif chan == 'default':
raise Exception('Selected default behavior')
if sent == 42: # ch1.put(42) happened
ch2A.put(17)
assert ch1B.get() == 42, "We should be able to read 42 from ch1B"
elif sent == 51: # ch2.put(51) happened
ch1A.put(17)
assert ch2B.get() == 51, "We should be able to read 51 from ch2B"
else:
raise Exception('WTF ?')
def test_select_timeout(self):
a = Chan()
b = Chan()
c = Chan()
self.assertRaises(Timeout, select, [a, b], [(c, 42)], timeout=0)
self.assertRaises(Timeout, select, [a, b], [(c, 42)], timeout=0.01)
# Verifies that select didn't leave any wishes lying around.
self.assertRaises(Timeout, a.put, 12, timeout=0)
self.assertRaises(Timeout, c.get, timeout=0)
def boring(msg):
c = Chan()
wait_for_it = Chan()
def sender():
i = 0
while True:
c.put(Message("%s: %d" % (msg, i), wait_for_it))
time.sleep(0.2 * random.random())
wait_for_it.get()
i += 1
go(sender)
return c
def test_putget_timeout(self):
c = Chan()
self.assertRaises(Timeout, c.put, 'x', timeout=0)
self.assertRaises(Timeout, c.put, 'x', timeout=0.01)
self.assertRaises(Timeout, c.get, timeout=0)
self.assertRaises(Timeout, c.get, timeout=0.01)
self.assertRaises(Timeout, c.put, 'x', timeout=0)
def update():
global itemK,itemBi,itemLine,itemZhongshu
dataToNowDf = DataFrame(index=dataToNow.Times,data = dataToNow.Data[0],columns=['price'])
dataToNowDf = dataToNowDf.between_time('9:30','11:30').append(dataToNowDf.between_time('13:00','15:00'))
a = dataToNowDf.resample('30T',how = {'price':'ohlc'},label='right').dropna()
for i in a.iterrows():
data.Times.append(i[0].to_datetime())
data.Data[0].append(i[1]['price']['open'])
data.Data[1].append(i[1]['price']['high'])
data.Data[2].append(i[1]['price']['low'])
data.Data[3].append(i[1]['price']['close'])
data.Data[4].append(0)
quotes = []
for i in range(len(data.Times)):
quotes.append([i, data.Data[0][i], data.Data[3][i],
data.Data[2][i], data.Data[1][i]])
chan = Chan(data.Data[0], data.Data[1], data.Data[2],
data.Data[3], data.Data[4], data.Times)
chan.barsMerge()
chan.findFenxing()
chan.findBi()
chan.findLines()
chan.findZhongshus()
chan.calculate_ta()
a += 1
itemK.set_data(quotes)
# itemBi.set_data(chan.bis)
# itemLine.set_data(chan.lines)
# itemZhongshu.set_data(chan.zhongshus)
app.processEvents() ## force complete redraw for every plot
def test_buf_overfull(self):
c = Chan(5)
go(sayset, c, list(range(20)), delay=0)
time.sleep(0.1) # Fill up buffer
results = list(c)
self.assertEqual(results, list(range(20)))
def play(self):
'''round-robin'''
self.open_start_urls()
loops_without_progress = 0
while True:
import time
start = time.time()
if len(self.bots) == 0:
return
# bots got stuck if there's 2 wait pages in a row
if loops_without_progress > 10:
raise AssertionError('Bots got stuck')
results = Chan(buflen=len(self.bots))
threads = []
for bot in self.bots.values():
if bot.on_wait_page():
pass
else:
thread = SubmitThread(bot, results)
threads.append(thread)
thread.start()
for thread in threads:
bot, status = results.get()
if isinstance(status, Exception):
raise status
elif status == 'finished':
del self.bots[bot.participant.id]
else:
bot.submit(status)
results.close()
if not threads:
loops_without_progress += 1
def close(self):
errc = Chan()
self.quit.put(errc)
result = errc.get()
self.thread.join(0.2)
assert not self.thread.is_alive()
return result
def read_write_default():
"""One channel can be read, the written and there's a default clause
Expected output :
-----------------
(Writing 42 to ch1|Reading from ch2)
(Writing 42 to ch1|Reading from ch2)
(Received number 42 from ch1|Sent number 51 to ch2)
"""
ch1 = Chan()
ch2 = Chan()
def write_channel():
"""Write 42 into ch1"""
py_output.write('Writing 42 to ch1\n'.encode())
ch1.put(42)
def read_channel():
"""Read the value in ch2 and write it in ch1"""
py_output.write('Reading from ch2\n'.encode())
x = ch2.get()
ch1.put(x)
go(write_channel)
go(read_channel)
time.sleep(0.1)
# Hopefully this is enough time to let
# the other two goroutines block on their channel writes
nb = 51
chan, nb = select(consumers=[ch1], producers=[(ch2, 51)], default=True)
if chan == ch1:
py_output.write('Received number {} from ch1\n'.format(nb).encode())
elif chan == ch2:
py_output.write('Sent number 51 to ch2\n'.encode())
elif chan == 'default':
raise Exception('Selected default behavior')
if nb == 42: # ch1.get() happened
ch2.put(17)
assert ch1.get() == 17, "We should be able to read 17 from ch1"
elif nb is None: # ch2.put(51) happened
assert ch1.get() == 42, "We should be able to read '42' from ch1"
else:
raise Exception('WTF ?')
def timer(duration):
def timer_thread(chan, duration):
time.sleep(duration)
chan.put(time.time())
c = Chan()
go(timer_thread, c, duration)
return c
def __init__(self, period=DEFAULT_PERIOD, yellow=DEFAULT_YELLOW):
self.period = period
self.yellow = yellow
self.trip = False
self._stop = threading.Event()
self.chan = Chan()
self._thread = threading.Thread(name='LightTimer', target=self.run)
self._thread.daemon = True
self._thread.start()
def fan_in(*input_list):
def forward(input, output):
while True:
output.put(input.get())
c = Chan()
for input in input_list:
go(forward, input, c)
return c
def fan_in(input1, input2):
def forwarder(input, output):
while True:
output.put(input.get())
c = Chan()
go(forwarder, input1, c)
go(forwarder, input2, c)
return c
def __init__(self, color, blink=False, period=0.5):
self.blink = blink
self.period = period
self.color = color.split('-')[0]
self.chan = Chan()
self._stop = threading.Event()
self._thread = threading.Thread(name='LightTimer', target=self.run)
self._thread.daemon = True
self._thread.start()
def test_buf_simple(self):
S = 5
c = Chan(S)
for i in range(S):
c.put(i)
c.close()
results = list(c)
self.assertEqual(results, list(range(S)))
def timeout_after(delay):
def thread(ch):
time.sleep(delay)
ch.put(None)
c = Chan()
t = threading.Thread(name='timeout', target=thread, args=(c, ))
t.daemon = True
t.start()
return c
def read_read_default():
"""Two channels can be read and there's a default clause
Expected output :
-----------------
Writing (42|51) to ch(1|2)
Writing (42|51) to ch(1|2)
Received number (42|51) from ch(1|2)
"""
ch1 = Chan()
ch2 = Chan()
def write_channel1():
"""Write 42 into ch1"""
py_output.write('Writing 42 to ch1\n'.encode())
ch1.put(42)
def write_channel2():
"""Write 51 into ch2"""
py_output.write('Writing 51 to ch2\n'.encode())
ch2.put(51)
go(write_channel1)
go(write_channel2)
time.sleep(0.1)
# Hopefully this is enough time to let
# the other two goroutines block on their channel writes
chan, nb = select(consumers=[ch1, ch2], producers=[], default=True)
if chan == ch1:
py_output.write('Received number {} from ch1\n'.format(nb).encode())
elif chan == ch2:
py_output.write('Received number {} from ch2\n'.format(nb).encode())
elif chan == 'default':
raise Exception('Selected default behavior')
if nb == 42: # ch1.get() happened
assert ch2.get() == 51, "We should be able to read '51' from ch2"
elif nb == 51: # ch2.get() happened
assert ch1.get() == 42, "We should be able to read '42' from ch1"
else:
raise Exception('WTF ?')
def example_daisy():
def f(left, right):
left.put(1 + right.get())
N = 1000 # Python's threads aren't that lightweight
leftmost = Chan()
rightmost = leftmost
left = leftmost
for i in xrange(N):
right = Chan()
go(f, left, right)
left = right
def putter():
right.put(1)
go(putter)
print leftmost.get()
def test_simple(self):
chan = Chan()
results = []
go(accumulator, chan, results)
chan.put("Hello")
time.sleep(0.01) # Technically unsafe
self.assertEqual(len(results), 1)
self.assertEqual(results[0], "Hello")
def fan_in(input1, input2):
c = Chan()
def forward():
while True:
chan, value = chanselect([input1, input2], [])
c.put(value)
quickthread(forward)
return c
def __init__(self, base=1000, jitter=500):
self.trip = False
self._stop = threading.Event()
self.chan = Chan()
self._thread = threading.Thread(name='LightTimer', target=self.run)
self._thread.daemon = True
self._thread.start()
self.base = base
self.jitter = jitter
random.seed()
def status(self):
st = {'server': 'ok'}
try:
resp_chan = Chan(1)
self.chan.put(('status', resp_chan), timeout=0.5)
resp = resp_chan.get(timeout=0.5)
st.update(resp)
except Timeout:
st['loop'] = 'Error: Did not hear from main thread in time'
return st
def fan_in(input1, input2):
c = Chan()
def forward():
while True:
chan, value = select([input1, input2], [])
c.put(value)
go(forward)
return c
def boring(message):
def sender(message, c):
i = 0
while True:
c.put("%s: %d" % (message, i))
time.sleep(0.2 * random.random())
i += 1
c = Chan()
go(sender, message, c)
return c
def test_nothing_lost(self):
phrases = ['Hello_%03d' % x for x in range(1000)]
firstchan = Chan()
chan_layer1 = [Chan() for i in range(6)]
lastchan = Chan()
sayer = quickthread(sayset,
firstchan,
phrases,
delay=0.001,
__name='sayer')
# Distribute firstchan -> chan_layer1
for i in range(12):
outchans = [
chan_layer1[(i + j) % len(chan_layer1)] for j in range(3)
]
quickthread(distributer, [firstchan],
outchans,
delay_max=0.005,
__name='dist_layer1_%02d' % i)
# Distribute chan_layer1 -> lastchan
for i in range(12):
inchans = [
chan_layer1[(i + j) % len(chan_layer1)]
for j in range(0, 9, 3)
]
quickthread(distributer,
inchans, [lastchan],
delay_max=0.005,
__name='dist_layer2_%02d' % i)
results = []
quickthread(accumulator, lastchan, results, __name='accumulator')
sayer.join(10)
self.assertFalse(sayer.is_alive())
time.sleep(1) # Unsafe. Lets the data propagate to the accumulator
# Checks that none are missing, and there are no duplicates.
self.assertEqual(len(results), len(phrases))
self.assertEqual(set(results), set(phrases))
def boring(msg):
c = Chan()
def sender():
i = 0
while True:
c.put("%s: %d" % (msg, i))
time.sleep(1.5 * random.random())
i += 1
go(sender)
return c
def read_default():
"""The select should execute the default code as many times as needed
(hopefully once)
Then the <-ch1 case should happen
Expected output :
-----------------
Selected default behavior
Writing 42 to ch1
Received number 42 from ch1 after 1[0-9].[0-9]*µs
"""
ch1 = Chan()
ch2 = Chan()
def write_channel(ch):
"""Wait for ch to be readable and Write an int nb
into a channel ch"""
ch.get()
py_output.write('Writing 42 to ch1\n'.encode())
ch1.put(42)
go(write_channel, ch2)
from_ch1 = 0
wrote_to_ch2 = False
start = time.time()
while from_ch1 == 0:
chan, nb = select(consumers=[ch1], producers=[], default=True)
if chan == ch1:
elapsed = time.time() - start
from_ch1 = nb
py_output.write('Received number '
'{} from ch1 after '
'{}\n'.format(from_ch1, elapsed).encode())
if chan is 'default':
py_output.write('Selected default behavior\n'.encode())
if not wrote_to_ch2:
ch2.put(1)
wrote_to_ch2 = True
