portal 3.7.4__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- portal/__init__.py +31 -0
- portal/batching.py +179 -0
- portal/buffers.py +94 -0
- portal/client.py +190 -0
- portal/client_socket.py +259 -0
- portal/contextlib.py +198 -0
- portal/packlib.py +140 -0
- portal/poollib.py +17 -0
- portal/process.py +128 -0
- portal/server.py +172 -0
- portal/server_socket.py +200 -0
- portal/sharray.py +45 -0
- portal/thread.py +90 -0
- portal/utils.py +131 -0
- portal-3.7.4.dist-info/METADATA +85 -0
- portal-3.7.4.dist-info/RECORD +17 -0
- portal-3.7.4.dist-info/WHEEL +4 -0
portal/__init__.py
ADDED
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import multiprocessing as mp
|
|
2
|
+
try:
|
|
3
|
+
mp.set_start_method('spawn')
|
|
4
|
+
except RuntimeError:
|
|
5
|
+
pass
|
|
6
|
+
|
|
7
|
+
from .contextlib import context
|
|
8
|
+
from .contextlib import initfn
|
|
9
|
+
from .contextlib import reset
|
|
10
|
+
from .contextlib import setup
|
|
11
|
+
|
|
12
|
+
from .thread import Thread
|
|
13
|
+
from .process import Process
|
|
14
|
+
|
|
15
|
+
from .server_socket import ServerSocket
|
|
16
|
+
from .client_socket import ClientSocket
|
|
17
|
+
from .client_socket import Disconnected
|
|
18
|
+
|
|
19
|
+
from .client import Client
|
|
20
|
+
from .server import Server
|
|
21
|
+
from .batching import BatchServer
|
|
22
|
+
|
|
23
|
+
from .packlib import pack
|
|
24
|
+
from .packlib import unpack
|
|
25
|
+
from .packlib import tree_equals
|
|
26
|
+
|
|
27
|
+
from .sharray import SharedArray
|
|
28
|
+
|
|
29
|
+
from .utils import free_port
|
|
30
|
+
from .utils import proc_alive
|
|
31
|
+
from .utils import run
|
portal/batching.py
ADDED
|
@@ -0,0 +1,179 @@
|
|
|
1
|
+
import threading
|
|
2
|
+
|
|
3
|
+
import numpy as np
|
|
4
|
+
import portal
|
|
5
|
+
|
|
6
|
+
from . import client
|
|
7
|
+
from . import packlib
|
|
8
|
+
from . import process
|
|
9
|
+
from . import server
|
|
10
|
+
from . import server_socket
|
|
11
|
+
from . import sharray
|
|
12
|
+
from . import thread
|
|
13
|
+
from . import utils
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
class BatchServer:
|
|
17
|
+
|
|
18
|
+
def __init__(
|
|
19
|
+
self, port, name='Server', workers=1, errors=True,
|
|
20
|
+
process=True, shmem=False, **kwargs):
|
|
21
|
+
inner_port = utils.free_port()
|
|
22
|
+
while inner_port == port:
|
|
23
|
+
inner_port = utils.free_port()
|
|
24
|
+
self.name = name
|
|
25
|
+
self.server = server.Server(inner_port, name, workers, errors, **kwargs)
|
|
26
|
+
if process:
|
|
27
|
+
self.running = portal.context.mp.Event()
|
|
28
|
+
else:
|
|
29
|
+
self.running = threading.Event()
|
|
30
|
+
self.process = process
|
|
31
|
+
self.batsizes = {}
|
|
32
|
+
self.batargs = (
|
|
33
|
+
self.running, port, inner_port, f'{name}Batcher',
|
|
34
|
+
self.batsizes, errors, shmem, kwargs)
|
|
35
|
+
self.started = False
|
|
36
|
+
|
|
37
|
+
def bind(self, name, workfn, donefn=None, batch=0, workers=0):
|
|
38
|
+
assert not self.started
|
|
39
|
+
self.batsizes[name] = batch
|
|
40
|
+
self.server.bind(name, workfn, donefn, workers=workers)
|
|
41
|
+
|
|
42
|
+
def start(self, block=True):
|
|
43
|
+
assert not self.started
|
|
44
|
+
self.started = True
|
|
45
|
+
self.running.set()
|
|
46
|
+
if self.process:
|
|
47
|
+
self.batcher = process.Process(
|
|
48
|
+
batcher, *self.batargs, name=f'{self.name}Batcher', start=True)
|
|
49
|
+
else:
|
|
50
|
+
self.batcher = thread.Thread(
|
|
51
|
+
batcher, *self.batargs, name=f'{self.name}Batcher', start=True)
|
|
52
|
+
self.server.start(block=block)
|
|
53
|
+
|
|
54
|
+
def close(self, timeout=None):
|
|
55
|
+
assert self.started
|
|
56
|
+
self.running.clear()
|
|
57
|
+
self.server.close(timeout)
|
|
58
|
+
self.batcher.join(timeout)
|
|
59
|
+
self.batcher.kill()
|
|
60
|
+
|
|
61
|
+
def stats(self):
|
|
62
|
+
return self.server.stats()
|
|
63
|
+
|
|
64
|
+
def __enter__(self):
|
|
65
|
+
self.start(block=False)
|
|
66
|
+
return self
|
|
67
|
+
|
|
68
|
+
def __exit__(self, *e):
|
|
69
|
+
self.close()
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
def batcher(
|
|
73
|
+
running, outer_port, inner_port, name, batsizes, errors, shmem,
|
|
74
|
+
kwargs):
|
|
75
|
+
|
|
76
|
+
def maybe_recv(outer, inner, jobs, batches):
|
|
77
|
+
if not running.is_set(): # Do not accept further requests.
|
|
78
|
+
return
|
|
79
|
+
try:
|
|
80
|
+
addr, data = outer.recv(timeout=0.0001)
|
|
81
|
+
except TimeoutError:
|
|
82
|
+
return
|
|
83
|
+
reqnum = bytes(data[:8])
|
|
84
|
+
data = data[8:]
|
|
85
|
+
strlen = int.from_bytes(data[:8], 'little', signed=False)
|
|
86
|
+
data = data[8:]
|
|
87
|
+
name, data = bytes(data[:strlen]).decode('utf-8'), data[strlen:]
|
|
88
|
+
if name not in batsizes:
|
|
89
|
+
send_error(addr, reqnum, 3, f'Unknown method {name}')
|
|
90
|
+
return
|
|
91
|
+
data = packlib.unpack(data)
|
|
92
|
+
batch_size = batsizes[name]
|
|
93
|
+
if not batch_size:
|
|
94
|
+
job = inner.call(name, *data)
|
|
95
|
+
job.args = (False, addr, reqnum)
|
|
96
|
+
jobs.append(job)
|
|
97
|
+
return
|
|
98
|
+
leaves, structure = packlib.tree_flatten(data)
|
|
99
|
+
leaves = [np.asarray(x) for x in leaves]
|
|
100
|
+
if any(x.dtype == object for x in leaves):
|
|
101
|
+
send_error(addr, reqnum, 5, 'Only array arguments can be batched.')
|
|
102
|
+
return
|
|
103
|
+
if name not in batches:
|
|
104
|
+
if shmem:
|
|
105
|
+
buffers = [
|
|
106
|
+
sharray.SharedArray((batch_size, *leaf.shape), leaf.dtype)
|
|
107
|
+
for leaf in leaves]
|
|
108
|
+
else:
|
|
109
|
+
buffers = [
|
|
110
|
+
np.empty((batch_size, *leaf.shape), leaf.dtype)
|
|
111
|
+
for leaf in leaves]
|
|
112
|
+
batches[name] = ([], [], structure, buffers)
|
|
113
|
+
addrs, reqnums, reference, buffers = batches[name]
|
|
114
|
+
if structure != reference:
|
|
115
|
+
send_error(addr, reqnum, 6, (
|
|
116
|
+
f'Argument structure {structure} does not match previous ' +
|
|
117
|
+
f'requests with structure {reference} for batched server ' +
|
|
118
|
+
f'method {name}.'))
|
|
119
|
+
return
|
|
120
|
+
index = len(addrs)
|
|
121
|
+
addrs.append(addr)
|
|
122
|
+
reqnums.append(reqnum)
|
|
123
|
+
for buffer, leaf in zip(buffers, leaves):
|
|
124
|
+
buffer[index] = leaf
|
|
125
|
+
if len(addrs) == batch_size:
|
|
126
|
+
del batches[name]
|
|
127
|
+
data = packlib.tree_unflatten(buffers, reference)
|
|
128
|
+
job = inner.call(name, *data)
|
|
129
|
+
job.args = (True, addrs, reqnums)
|
|
130
|
+
jobs.append(job)
|
|
131
|
+
|
|
132
|
+
def maybe_send(outer, inner, jobs):
|
|
133
|
+
done, waiting = [], []
|
|
134
|
+
[done.append(x) if x.done() else waiting.append(x) for x in jobs]
|
|
135
|
+
for job in done:
|
|
136
|
+
batched, addr, reqnum = job.args
|
|
137
|
+
try:
|
|
138
|
+
result = job.result()
|
|
139
|
+
except RuntimeError as e:
|
|
140
|
+
if batched:
|
|
141
|
+
for i, (addr, reqnum) in enumerate(zip(addr, reqnum)):
|
|
142
|
+
send_error(addr, reqnum, 6, e.args[0])
|
|
143
|
+
else:
|
|
144
|
+
send_error(addr, reqnum, 6, e.args[0])
|
|
145
|
+
continue
|
|
146
|
+
status = int(0).to_bytes(8, 'little', signed=True)
|
|
147
|
+
if batched:
|
|
148
|
+
for i, (addr, reqnum) in enumerate(zip(addr, reqnum)):
|
|
149
|
+
data = packlib.pack(packlib.tree_map(lambda x: x[i], result))
|
|
150
|
+
outer.send(addr, reqnum, status, *data)
|
|
151
|
+
else:
|
|
152
|
+
data = packlib.pack(result)
|
|
153
|
+
outer.send(addr, reqnum, status, *data)
|
|
154
|
+
return waiting
|
|
155
|
+
|
|
156
|
+
def send_error(addr, reqnum, status, message):
|
|
157
|
+
assert 1 <= status, status
|
|
158
|
+
status = status.to_bytes(8, 'little', signed=False)
|
|
159
|
+
data = message.encode('utf-8')
|
|
160
|
+
outer.send(addr, reqnum, status, data)
|
|
161
|
+
if errors:
|
|
162
|
+
raise RuntimeError(message)
|
|
163
|
+
|
|
164
|
+
try:
|
|
165
|
+
outer = server_socket.ServerSocket(outer_port, f'{name}Server', **kwargs)
|
|
166
|
+
inner = client.Client(inner_port, f'{name}Client', **kwargs)
|
|
167
|
+
batches = {} # {method: ([addr], [reqnum], structure, [array])}
|
|
168
|
+
jobs = []
|
|
169
|
+
shutdown = False
|
|
170
|
+
while running.is_set() or jobs:
|
|
171
|
+
if running.is_set():
|
|
172
|
+
maybe_recv(outer, inner, jobs, batches)
|
|
173
|
+
elif not shutdown:
|
|
174
|
+
shutdown = True
|
|
175
|
+
outer.shutdown()
|
|
176
|
+
jobs = maybe_send(outer, inner, jobs)
|
|
177
|
+
finally:
|
|
178
|
+
outer.close()
|
|
179
|
+
inner.close()
|
portal/buffers.py
ADDED
|
@@ -0,0 +1,94 @@
|
|
|
1
|
+
import collections
|
|
2
|
+
import os
|
|
3
|
+
import weakref
|
|
4
|
+
|
|
5
|
+
import numpy as np
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
class SendBuffer:
|
|
9
|
+
|
|
10
|
+
def __init__(self, *buffers, maxsize=None):
|
|
11
|
+
for buffer in buffers:
|
|
12
|
+
assert isinstance(buffer, (bytes, bytearray, memoryview)), type(buffer)
|
|
13
|
+
assert not isinstance(buffer, memoryview) or buffer.c_contiguous
|
|
14
|
+
buffers = tuple(
|
|
15
|
+
x.cast('c') if isinstance(x, memoryview) else x for x in buffers)
|
|
16
|
+
length = sum(len(x) for x in buffers)
|
|
17
|
+
assert all(len(x) for x in buffers)
|
|
18
|
+
assert 1 <= length, length
|
|
19
|
+
assert not maxsize or length <= length, (length, maxsize)
|
|
20
|
+
lenbuf = length.to_bytes(8, 'little', signed=False)
|
|
21
|
+
self.buffers = [lenbuf, *buffers]
|
|
22
|
+
self.remaining = collections.deque(self.buffers)
|
|
23
|
+
self.pos = 0
|
|
24
|
+
|
|
25
|
+
def __repr__(self):
|
|
26
|
+
lens = [len(x) for x in self.buffers]
|
|
27
|
+
left = [len(x) for x in self.remaining]
|
|
28
|
+
return f'SendBuffer(pos={self.pos}, lengths={lens} remaining={left})'
|
|
29
|
+
|
|
30
|
+
def reset(self):
|
|
31
|
+
self.remaining = collections.deque(self.buffers)
|
|
32
|
+
self.pos = 0
|
|
33
|
+
|
|
34
|
+
def send(self, sock):
|
|
35
|
+
first, *others = self.remaining
|
|
36
|
+
assert self.pos < len(first)
|
|
37
|
+
# The writev() call blocks but seems to be slightly faster than sendmsg().
|
|
38
|
+
size = os.writev(sock.fileno(), [memoryview(first)[self.pos:], *others])
|
|
39
|
+
# size = sock.sendmsg(
|
|
40
|
+
# [memoryview(first)[self.pos:], *others], (), socket.MSG_DONTWAIT)
|
|
41
|
+
if size == 0:
|
|
42
|
+
raise ConnectionResetError
|
|
43
|
+
assert 0 <= size, size
|
|
44
|
+
self.pos += max(0, size)
|
|
45
|
+
while self.remaining and self.pos >= len(self.remaining[0]):
|
|
46
|
+
self.pos -= len(self.remaining.popleft())
|
|
47
|
+
return size
|
|
48
|
+
|
|
49
|
+
def done(self):
|
|
50
|
+
return not self.remaining
|
|
51
|
+
|
|
52
|
+
|
|
53
|
+
class RecvBuffer:
|
|
54
|
+
|
|
55
|
+
def __init__(self, maxsize):
|
|
56
|
+
self.maxsize = maxsize
|
|
57
|
+
self.lenbuf = b''
|
|
58
|
+
self.buffer = None
|
|
59
|
+
self.pos = 0
|
|
60
|
+
|
|
61
|
+
def __repr__(self):
|
|
62
|
+
length = self.buffer and len(self.buffer)
|
|
63
|
+
return f'RecvBuffer(pos={self.pos}, length={length})'
|
|
64
|
+
|
|
65
|
+
def recv(self, sock):
|
|
66
|
+
if self.buffer is None:
|
|
67
|
+
part = sock.recv(8 - len(self.lenbuf))
|
|
68
|
+
self.lenbuf += part
|
|
69
|
+
size = len(part)
|
|
70
|
+
if len(self.lenbuf) == 8:
|
|
71
|
+
length = int.from_bytes(self.lenbuf, 'little', signed=False)
|
|
72
|
+
assert 1 <= length <= self.maxsize, (1, length, self.maxsize)
|
|
73
|
+
# We use Numpy to allocate uninitialized memory because Python's
|
|
74
|
+
# `bytearray(length)` zero initializes which is slow. This also means
|
|
75
|
+
# the buffer cannot be pickled accidentally unless explicitly converted
|
|
76
|
+
# to a `bytes()` object, which is a nice bonus for preventing
|
|
77
|
+
# performance bugs in user code.
|
|
78
|
+
arr = np.empty(length, np.uint8)
|
|
79
|
+
self.buffer = memoryview(arr.data)
|
|
80
|
+
weakref.finalize(self.buffer, lambda arr=arr: arr)
|
|
81
|
+
self.pos = 0
|
|
82
|
+
else:
|
|
83
|
+
size = sock.recv_into(self.buffer[self.pos:])
|
|
84
|
+
self.pos += max(0, size)
|
|
85
|
+
assert 0 <= self.pos <= len(self.buffer), (0, self.pos, len(self.buffer))
|
|
86
|
+
if size == 0:
|
|
87
|
+
raise ConnectionResetError
|
|
88
|
+
return size
|
|
89
|
+
|
|
90
|
+
def done(self):
|
|
91
|
+
return self.buffer and self.pos == len(self.buffer)
|
|
92
|
+
|
|
93
|
+
def result(self):
|
|
94
|
+
return self.buffer
|
portal/client.py
ADDED
|
@@ -0,0 +1,190 @@
|
|
|
1
|
+
import collections
|
|
2
|
+
import functools
|
|
3
|
+
import itertools
|
|
4
|
+
import threading
|
|
5
|
+
import time
|
|
6
|
+
import weakref
|
|
7
|
+
|
|
8
|
+
from . import client_socket
|
|
9
|
+
from . import packlib
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class Client:
|
|
13
|
+
|
|
14
|
+
def __init__(self, addr, name='Client', maxinflight=16, **kwargs):
|
|
15
|
+
assert 1 <= maxinflight, maxinflight
|
|
16
|
+
self.maxinflight = maxinflight
|
|
17
|
+
self.reqnum = iter(itertools.count(0))
|
|
18
|
+
self.futures = {}
|
|
19
|
+
self.errors = collections.deque()
|
|
20
|
+
self.sendrate = [0, time.time()]
|
|
21
|
+
self.recvrate = [0, time.time()]
|
|
22
|
+
self.waitmean = [0, 0]
|
|
23
|
+
self.cond = threading.Condition()
|
|
24
|
+
self.lock = threading.Lock()
|
|
25
|
+
# Socket is created after the above attributes because the callbacks access
|
|
26
|
+
# some of the attributes.
|
|
27
|
+
self.socket = client_socket.ClientSocket(addr, name, start=False, **kwargs)
|
|
28
|
+
self.socket.callbacks_recv.append(self._recv)
|
|
29
|
+
self.socket.callbacks_disc.append(self._disc)
|
|
30
|
+
self.socket.callbacks_conn.append(self._conn)
|
|
31
|
+
self.socket.start()
|
|
32
|
+
|
|
33
|
+
@property
|
|
34
|
+
def connected(self):
|
|
35
|
+
return self.socket.connected
|
|
36
|
+
|
|
37
|
+
def __getattr__(self, name):
|
|
38
|
+
if name.startswith('_'):
|
|
39
|
+
raise AttributeError(name)
|
|
40
|
+
try:
|
|
41
|
+
return functools.partial(self.call, name)
|
|
42
|
+
except AttributeError:
|
|
43
|
+
raise ValueError(name)
|
|
44
|
+
|
|
45
|
+
def stats(self):
|
|
46
|
+
now = time.time()
|
|
47
|
+
stats = {
|
|
48
|
+
'inflight': len(self.futures),
|
|
49
|
+
'numsend': self.sendrate[0],
|
|
50
|
+
'numrecv': self.recvrate[0],
|
|
51
|
+
'sendrate': self.sendrate[0] / (now - self.sendrate[1]),
|
|
52
|
+
'recvrate': self.recvrate[0] / (now - self.recvrate[1]),
|
|
53
|
+
'waitmean': self.waitmean[0] and (self.waitmean[1] / self.waitmean[0]),
|
|
54
|
+
}
|
|
55
|
+
self.sendrate = [0, now]
|
|
56
|
+
self.recvrate = [0, now]
|
|
57
|
+
self.waitmean = [0, 0]
|
|
58
|
+
return stats
|
|
59
|
+
|
|
60
|
+
def connect(self, timeout=None):
|
|
61
|
+
return self.socket.connect(timeout)
|
|
62
|
+
|
|
63
|
+
def call(self, method, *data):
|
|
64
|
+
reqnum = next(self.reqnum).to_bytes(8, 'little', signed=False)
|
|
65
|
+
start = time.time()
|
|
66
|
+
while len(self.futures) >= self.maxinflight:
|
|
67
|
+
with self.cond: self.cond.wait(timeout=0.2)
|
|
68
|
+
try:
|
|
69
|
+
self.socket.require_connection(timeout=0)
|
|
70
|
+
except TimeoutError:
|
|
71
|
+
pass
|
|
72
|
+
with self.lock:
|
|
73
|
+
self.waitmean[1] += time.time() - start
|
|
74
|
+
self.waitmean[0] += 1
|
|
75
|
+
self.sendrate[0] += 1
|
|
76
|
+
if self.errors: # Raise errors of dropped futures.
|
|
77
|
+
raise self.errors.popleft()
|
|
78
|
+
name = method.encode('utf-8')
|
|
79
|
+
strlen = len(name).to_bytes(8, 'little', signed=False)
|
|
80
|
+
sendargs = (reqnum, strlen, name, *packlib.pack(data))
|
|
81
|
+
rai = [False]
|
|
82
|
+
future = Future(rai)
|
|
83
|
+
future.sendargs = sendargs
|
|
84
|
+
self.futures[reqnum] = future
|
|
85
|
+
# Store future before sending request because the response may come fast
|
|
86
|
+
# and the response handler runs in the socket's background thread.
|
|
87
|
+
try:
|
|
88
|
+
self.socket.send(*sendargs)
|
|
89
|
+
except client_socket.Disconnected:
|
|
90
|
+
future = self.futures.pop(reqnum)
|
|
91
|
+
future.rai[0] = True
|
|
92
|
+
raise
|
|
93
|
+
return future
|
|
94
|
+
|
|
95
|
+
def close(self, timeout=None):
|
|
96
|
+
for future in self.futures.values():
|
|
97
|
+
self._seterr(future, client_socket.Disconnected)
|
|
98
|
+
self.futures.clear()
|
|
99
|
+
self.socket.close(timeout)
|
|
100
|
+
|
|
101
|
+
def _recv(self, data):
|
|
102
|
+
assert len(data) >= 16, 'Unexpectedly short response'
|
|
103
|
+
reqnum = bytes(data[:8])
|
|
104
|
+
status = int.from_bytes(data[8:16], 'little', signed=False)
|
|
105
|
+
future = self.futures.pop(reqnum, None)
|
|
106
|
+
if not future:
|
|
107
|
+
existing = sorted(self.futures.keys())
|
|
108
|
+
print(f'Unexpected request number: {reqnum}', existing)
|
|
109
|
+
elif status == 0:
|
|
110
|
+
data = packlib.unpack(data[16:])
|
|
111
|
+
future.set_result(data)
|
|
112
|
+
with self.cond: self.cond.notify_all()
|
|
113
|
+
else:
|
|
114
|
+
message = bytes(data[16:]).decode('utf-8')
|
|
115
|
+
self._seterr(future, RuntimeError(message))
|
|
116
|
+
with self.cond: self.cond.notify_all()
|
|
117
|
+
try:
|
|
118
|
+
self.socket.recv()
|
|
119
|
+
except AssertionError:
|
|
120
|
+
pass # Socket is already closed.
|
|
121
|
+
|
|
122
|
+
def _disc(self):
|
|
123
|
+
if self.socket.options.autoconn:
|
|
124
|
+
for future in list(self.futures.values()):
|
|
125
|
+
future.resend = True
|
|
126
|
+
else:
|
|
127
|
+
for future in list(self.futures.values()):
|
|
128
|
+
self._seterr(future, client_socket.Disconnected)
|
|
129
|
+
self.futures.clear()
|
|
130
|
+
|
|
131
|
+
def _conn(self):
|
|
132
|
+
if self.socket.options.autoconn:
|
|
133
|
+
for future in list(self.futures.values()):
|
|
134
|
+
if getattr(future, 'resend', False):
|
|
135
|
+
self.socket.send(*future.sendargs)
|
|
136
|
+
|
|
137
|
+
def _seterr(self, future, e):
|
|
138
|
+
future.set_error(e)
|
|
139
|
+
rai = future.rai
|
|
140
|
+
weakref.finalize(future, lambda: (
|
|
141
|
+
None if rai[0] else self.errors.append(e)))
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
class Future:
|
|
145
|
+
|
|
146
|
+
def __init__(self, rai):
|
|
147
|
+
assert rai == [False]
|
|
148
|
+
self.rai = rai
|
|
149
|
+
self.con = threading.Condition()
|
|
150
|
+
self.don = False
|
|
151
|
+
self.res = None
|
|
152
|
+
self.err = None
|
|
153
|
+
|
|
154
|
+
def __repr__(self):
|
|
155
|
+
if not self.done:
|
|
156
|
+
return 'Future(done=False)'
|
|
157
|
+
elif self.err:
|
|
158
|
+
return f"Future(done=True, error='{self.err}', raised={self.rai[0]})"
|
|
159
|
+
else:
|
|
160
|
+
return 'Future(done=True)'
|
|
161
|
+
|
|
162
|
+
def wait(self, timeout=None):
|
|
163
|
+
if self.don:
|
|
164
|
+
return self.don
|
|
165
|
+
with self.con: return self.con.wait(timeout)
|
|
166
|
+
|
|
167
|
+
def done(self):
|
|
168
|
+
return self.don
|
|
169
|
+
|
|
170
|
+
def result(self, timeout=None):
|
|
171
|
+
if not self.wait(timeout):
|
|
172
|
+
raise TimeoutError
|
|
173
|
+
assert self.don
|
|
174
|
+
if self.err is None:
|
|
175
|
+
return self.res
|
|
176
|
+
if not self.rai[0]:
|
|
177
|
+
self.rai[0] = True
|
|
178
|
+
raise self.err
|
|
179
|
+
|
|
180
|
+
def set_result(self, result):
|
|
181
|
+
assert not self.don
|
|
182
|
+
self.don = True
|
|
183
|
+
self.res = result
|
|
184
|
+
with self.con: self.con.notify_all()
|
|
185
|
+
|
|
186
|
+
def set_error(self, e):
|
|
187
|
+
assert not self.don
|
|
188
|
+
self.don = True
|
|
189
|
+
self.err = e
|
|
190
|
+
with self.con: self.con.notify_all()
|