peffect 0.1.2__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.
- peffect/__init__.py +223 -0
- peffect/cause.py +177 -0
- peffect/clock.py +130 -0
- peffect/console.py +99 -0
- peffect/context.py +258 -0
- peffect/core.py +1273 -0
- peffect/deferred.py +99 -0
- peffect/duration.py +497 -0
- peffect/fiber.py +1082 -0
- peffect/latch.py +120 -0
- peffect/layer.py +789 -0
- peffect/logger.py +166 -0
- peffect/managed_runtime.py +325 -0
- peffect/option.py +50 -0
- peffect/pull.py +116 -0
- peffect/py.typed +0 -0
- peffect/queue.py +670 -0
- peffect/ref.py +133 -0
- peffect/resources.py +113 -0
- peffect/scheduler.py +55 -0
- peffect/scope.py +394 -0
- peffect/semaphore.py +255 -0
- peffect/synchronized_ref.py +183 -0
- peffect/testing/__init__.py +7 -0
- peffect/testing/_clock.py +453 -0
- peffect/testing/_console.py +105 -0
- peffect/timeout.py +67 -0
- peffect-0.1.2.dist-info/METADATA +6 -0
- peffect-0.1.2.dist-info/RECORD +30 -0
- peffect-0.1.2.dist-info/WHEEL +4 -0
peffect/queue.py
ADDED
|
@@ -0,0 +1,670 @@
|
|
|
1
|
+
"""Queue at Effect v4 289a53f7: FIFO ownership, backpressure and completion.
|
|
2
|
+
|
|
3
|
+
Queue.ts:480-2175. Public module duals become methods; capability views are the
|
|
4
|
+
same object. No Ref or kernel protocol dependency. The creator dispatcher owns
|
|
5
|
+
coalesced taker releases. A wake means retry, never reservation. Destructive
|
|
6
|
+
reads use suspend_exit to deliver to the first accepting continuation atomically.
|
|
7
|
+
|
|
8
|
+
Numeric capacities are deliberately not normalized (including vendor quirks).
|
|
9
|
+
Counts are normalized. Metadata/Pipeable/Inspectable spellings are not ported.
|
|
10
|
+
Batch capability methods bind their receiver type independently: Python list is
|
|
11
|
+
invariant, but each result contains only that call's supplied/read messages.
|
|
12
|
+
This preserves the vendor's contravariant Enqueue and covariant Dequeue views.
|
|
13
|
+
"""
|
|
14
|
+
|
|
15
|
+
from __future__ import annotations
|
|
16
|
+
|
|
17
|
+
from abc import ABC, abstractmethod
|
|
18
|
+
from collections import deque
|
|
19
|
+
from collections.abc import Callable, Iterable, Iterator
|
|
20
|
+
from dataclasses import dataclass, field
|
|
21
|
+
from math import floor, inf, isnan
|
|
22
|
+
from typing import Literal, Never, TypeIs, final, overload
|
|
23
|
+
|
|
24
|
+
from .cause import Cause, Done
|
|
25
|
+
from .core import (
|
|
26
|
+
Effect,
|
|
27
|
+
Exit,
|
|
28
|
+
Failure,
|
|
29
|
+
Success,
|
|
30
|
+
async_,
|
|
31
|
+
exit_,
|
|
32
|
+
fiber_id,
|
|
33
|
+
succeed,
|
|
34
|
+
suspend,
|
|
35
|
+
suspend_exit,
|
|
36
|
+
sync,
|
|
37
|
+
uninterruptible_mask,
|
|
38
|
+
)
|
|
39
|
+
from .fiber import with_dispatcher
|
|
40
|
+
from .option import Some
|
|
41
|
+
from .pull import catch_done
|
|
42
|
+
from .scheduler import SchedulerDispatcher
|
|
43
|
+
|
|
44
|
+
type Strategy = Literal["suspend", "dropping", "sliding"]
|
|
45
|
+
type _Resume[A, E] = Callable[[Effect[A, E, Never]], None]
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
class Enqueue[A, E = Never](ABC):
|
|
49
|
+
"""Write capability, contravariant in both message and error (Queue.ts:175)."""
|
|
50
|
+
|
|
51
|
+
@abstractmethod
|
|
52
|
+
def offer(self, message: A) -> Effect[bool, Never, Never]: ...
|
|
53
|
+
|
|
54
|
+
@abstractmethod
|
|
55
|
+
def offer_unsafe(self, message: A) -> bool: ...
|
|
56
|
+
|
|
57
|
+
@abstractmethod
|
|
58
|
+
def offer_all[B](
|
|
59
|
+
self: Enqueue[B, E], messages: Iterable[B]
|
|
60
|
+
) -> Effect[list[B], Never, Never]: ...
|
|
61
|
+
|
|
62
|
+
@abstractmethod
|
|
63
|
+
def offer_all_unsafe[B](self: Enqueue[B, E], messages: Iterable[B]) -> list[B]: ...
|
|
64
|
+
|
|
65
|
+
@abstractmethod
|
|
66
|
+
def fail_cause_unsafe(self, cause: Cause[E]) -> bool: ...
|
|
67
|
+
|
|
68
|
+
def fail_cause(self, cause: Cause[E]) -> Effect[bool, Never, Never]:
|
|
69
|
+
return sync(lambda: self.fail_cause_unsafe(cause))
|
|
70
|
+
|
|
71
|
+
def fail(self, error: E) -> Effect[bool, Never, Never]:
|
|
72
|
+
return self.fail_cause(Cause.fail(error))
|
|
73
|
+
|
|
74
|
+
def end[B, F](self: Enqueue[B, F | Done]) -> Effect[bool, Never, Never]:
|
|
75
|
+
return self.fail_cause(Cause.fail(Done()))
|
|
76
|
+
|
|
77
|
+
def end_unsafe[B, F](self: Enqueue[B, F | Done]) -> bool:
|
|
78
|
+
return self.fail_cause_unsafe(Cause.fail(Done()))
|
|
79
|
+
|
|
80
|
+
def interrupt(self) -> Effect[bool, Never, Never]:
|
|
81
|
+
return fiber_id.flat_map(lambda by: self.fail_cause(Cause.interrupt(by)))
|
|
82
|
+
|
|
83
|
+
@abstractmethod
|
|
84
|
+
def shutdown_unsafe(self) -> bool: ...
|
|
85
|
+
|
|
86
|
+
def shutdown(self) -> Effect[bool, Never, Never]:
|
|
87
|
+
return sync(self.shutdown_unsafe)
|
|
88
|
+
|
|
89
|
+
@abstractmethod
|
|
90
|
+
def flush_unsafe(self) -> None: ...
|
|
91
|
+
|
|
92
|
+
def flush(self) -> Effect[None, Never, Never]:
|
|
93
|
+
return sync(self.flush_unsafe)
|
|
94
|
+
|
|
95
|
+
def into[B, F, X, R](
|
|
96
|
+
self: Enqueue[B, F | Done], effect: Effect[X, F, R]
|
|
97
|
+
) -> Effect[bool, Never, R]:
|
|
98
|
+
"""1963-1991: publish the producer Exit, ignoring its success value."""
|
|
99
|
+
|
|
100
|
+
def publish(result: Exit[X, F]) -> Effect[bool, Never, Never]:
|
|
101
|
+
return self.fail_cause(result.cause) if isinstance(result, Failure) else self.end()
|
|
102
|
+
|
|
103
|
+
return uninterruptible_mask(lambda restore: exit_(restore(effect)).flat_map(publish))
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
class Dequeue[A, E = Never](ABC):
|
|
107
|
+
"""Read capability, covariant in message and error (Queue.ts:245)."""
|
|
108
|
+
|
|
109
|
+
@abstractmethod
|
|
110
|
+
def take_unsafe(self) -> Exit[A, E] | None: ...
|
|
111
|
+
|
|
112
|
+
@abstractmethod
|
|
113
|
+
def _await_take(self, ready: Callable[[], bool]) -> Effect[None, E, Never]: ...
|
|
114
|
+
|
|
115
|
+
@abstractmethod
|
|
116
|
+
def _can_take(self, minimum: float) -> bool: ...
|
|
117
|
+
|
|
118
|
+
def take(self) -> Effect[A, E, Never]:
|
|
119
|
+
def attempt() -> Effect[A, E, Never]:
|
|
120
|
+
result = self.take_unsafe()
|
|
121
|
+
if result is not None:
|
|
122
|
+
return result
|
|
123
|
+
return self._await_take(lambda: self._can_take(1)).flat_map(lambda _: self.take())
|
|
124
|
+
|
|
125
|
+
return suspend_exit(attempt)
|
|
126
|
+
|
|
127
|
+
def poll(self) -> Effect[Some[A] | None, Never, Never]:
|
|
128
|
+
def attempt() -> Effect[Some[A] | None, Never, Never]:
|
|
129
|
+
result = self.take_unsafe()
|
|
130
|
+
return Success(Some(result.value) if isinstance(result, Success) else None)
|
|
131
|
+
|
|
132
|
+
return suspend_exit(attempt)
|
|
133
|
+
|
|
134
|
+
@abstractmethod
|
|
135
|
+
def peek(self) -> Effect[A, E, Never]: ...
|
|
136
|
+
|
|
137
|
+
@abstractmethod
|
|
138
|
+
def take_between[B](
|
|
139
|
+
self: Dequeue[B, E], minimum: float, maximum: float
|
|
140
|
+
) -> Effect[list[B], E, Never]: ...
|
|
141
|
+
|
|
142
|
+
def take_n[B](self: Dequeue[B, E], count: float) -> Effect[list[B], E, Never]:
|
|
143
|
+
return self.take_between(count, count)
|
|
144
|
+
|
|
145
|
+
def take_all[B](self: Dequeue[B, E]) -> Effect[list[B], E, Never]:
|
|
146
|
+
return self.take_between(1, inf)
|
|
147
|
+
|
|
148
|
+
@abstractmethod
|
|
149
|
+
def _clear_raw[B](self: Dequeue[B, E]) -> Effect[list[B], E, Never]: ...
|
|
150
|
+
|
|
151
|
+
@overload
|
|
152
|
+
def clear[B](self: Dequeue[B, Done[object]]) -> Effect[list[B], Never, Never]: ...
|
|
153
|
+
@overload
|
|
154
|
+
def clear[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]: ...
|
|
155
|
+
def clear[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]:
|
|
156
|
+
return catch_done(self._clear_raw(), lambda _: succeed(list[B]()))
|
|
157
|
+
|
|
158
|
+
@overload
|
|
159
|
+
def collect[B](self: Dequeue[B, Done[object]]) -> Effect[list[B], Never, Never]: ...
|
|
160
|
+
@overload
|
|
161
|
+
def collect[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]: ...
|
|
162
|
+
def collect[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]:
|
|
163
|
+
def begin() -> Effect[list[B], F, Never]:
|
|
164
|
+
messages: list[B] = []
|
|
165
|
+
|
|
166
|
+
def append(batch: list[B]) -> Effect[list[B], Done[object] | F, Never]:
|
|
167
|
+
messages.extend(batch)
|
|
168
|
+
return suspend(loop)
|
|
169
|
+
|
|
170
|
+
def loop() -> Effect[list[B], Done[object] | F, Never]:
|
|
171
|
+
return self.take_all().flat_map(append)
|
|
172
|
+
|
|
173
|
+
return catch_done(suspend(loop), lambda _: succeed(messages))
|
|
174
|
+
|
|
175
|
+
return suspend(begin)
|
|
176
|
+
|
|
177
|
+
@abstractmethod
|
|
178
|
+
def _await_raw(self) -> Effect[None, E, Never]: ...
|
|
179
|
+
|
|
180
|
+
@overload
|
|
181
|
+
def await_[B](self: Dequeue[B, Done[object]]) -> Effect[None, Never, Never]: ...
|
|
182
|
+
@overload
|
|
183
|
+
def await_[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[None, F, Never]: ...
|
|
184
|
+
def await_[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[None, F, Never]:
|
|
185
|
+
return catch_done(self._await_raw(), lambda _: succeed(None))
|
|
186
|
+
|
|
187
|
+
@abstractmethod
|
|
188
|
+
def size_unsafe(self) -> int: ...
|
|
189
|
+
|
|
190
|
+
def size(self) -> Effect[int, Never, Never]:
|
|
191
|
+
return sync(self.size_unsafe)
|
|
192
|
+
|
|
193
|
+
@abstractmethod
|
|
194
|
+
def is_full_unsafe(self) -> bool: ...
|
|
195
|
+
|
|
196
|
+
def is_full(self) -> Effect[bool, Never, Never]:
|
|
197
|
+
return sync(self.is_full_unsafe)
|
|
198
|
+
|
|
199
|
+
|
|
200
|
+
class _Registry[T]:
|
|
201
|
+
"""Live ordered Set traversal, including append/delete during callbacks.
|
|
202
|
+
|
|
203
|
+
Python dict iteration forbids mutation. Tokens keep cancellation ownership;
|
|
204
|
+
tombstones remain during iteration, then compact with amortized bounded slack.
|
|
205
|
+
No copied waiter snapshot can accidentally wake a cancelled waiter.
|
|
206
|
+
"""
|
|
207
|
+
|
|
208
|
+
def __init__(self) -> None:
|
|
209
|
+
self._values: dict[int, T] = {}
|
|
210
|
+
self._order: list[int] = []
|
|
211
|
+
self._next = 0
|
|
212
|
+
self._iterators = 0
|
|
213
|
+
|
|
214
|
+
def __len__(self) -> int:
|
|
215
|
+
return len(self._values)
|
|
216
|
+
|
|
217
|
+
def add(self, value: T) -> int:
|
|
218
|
+
token = self._next
|
|
219
|
+
self._next += 1
|
|
220
|
+
self._values[token] = value
|
|
221
|
+
self._order.append(token)
|
|
222
|
+
return token
|
|
223
|
+
|
|
224
|
+
def remove(self, token: int) -> None:
|
|
225
|
+
self._values.pop(token, None)
|
|
226
|
+
self._compact()
|
|
227
|
+
|
|
228
|
+
def clear(self) -> None:
|
|
229
|
+
self._values.clear()
|
|
230
|
+
self._compact()
|
|
231
|
+
|
|
232
|
+
def _compact(self) -> None:
|
|
233
|
+
if not self._iterators and len(self._order) > 2 * len(self._values):
|
|
234
|
+
self._order = list(self._values)
|
|
235
|
+
|
|
236
|
+
def __iter__(self) -> Iterator[tuple[int, T]]:
|
|
237
|
+
self._iterators += 1
|
|
238
|
+
try:
|
|
239
|
+
index = 0
|
|
240
|
+
while index < len(self._order):
|
|
241
|
+
token = self._order[index]
|
|
242
|
+
index += 1
|
|
243
|
+
if token in self._values:
|
|
244
|
+
yield token, self._values[token]
|
|
245
|
+
finally:
|
|
246
|
+
self._iterators -= 1
|
|
247
|
+
self._compact()
|
|
248
|
+
|
|
249
|
+
|
|
250
|
+
@dataclass
|
|
251
|
+
class _Single[A]:
|
|
252
|
+
message: A
|
|
253
|
+
resume: _Resume[bool, Never]
|
|
254
|
+
|
|
255
|
+
|
|
256
|
+
@dataclass
|
|
257
|
+
class _Batch[A]:
|
|
258
|
+
remaining: list[A]
|
|
259
|
+
resume: _Resume[list[A], Never]
|
|
260
|
+
offset: int = 0
|
|
261
|
+
|
|
262
|
+
|
|
263
|
+
@dataclass
|
|
264
|
+
class _Taker[E]:
|
|
265
|
+
ready: Callable[[], bool]
|
|
266
|
+
resume: _Resume[None, E]
|
|
267
|
+
|
|
268
|
+
|
|
269
|
+
@dataclass
|
|
270
|
+
class _Active[A, E]:
|
|
271
|
+
# None is Open; a stored terminal Failure is Closing. Done owns no registries.
|
|
272
|
+
terminal: Failure[E] | None = None
|
|
273
|
+
takers: _Registry[_Taker[E]] = field(default_factory=_Registry[_Taker[E]])
|
|
274
|
+
offers: _Registry[_Single[A] | _Batch[A]] = field(
|
|
275
|
+
default_factory=_Registry[_Single[A] | _Batch[A]]
|
|
276
|
+
)
|
|
277
|
+
awaiters: _Registry[_Resume[None, E]] = field(default_factory=_Registry[_Resume[None, E]])
|
|
278
|
+
|
|
279
|
+
|
|
280
|
+
@dataclass(frozen=True)
|
|
281
|
+
class _Done[E]:
|
|
282
|
+
terminal: Failure[E]
|
|
283
|
+
|
|
284
|
+
|
|
285
|
+
def _count(value: float) -> float:
|
|
286
|
+
return 0 if isnan(value) or value <= 0 else inf if value == inf else floor(value)
|
|
287
|
+
|
|
288
|
+
|
|
289
|
+
@final
|
|
290
|
+
class Queue[A, E = Never](Enqueue[A, E], Dequeue[A, E]):
|
|
291
|
+
"""Invariant FIFO owner. Capacity is raw, counts are normalized upstream."""
|
|
292
|
+
|
|
293
|
+
def __init__(
|
|
294
|
+
self, capacity: float, strategy: Strategy, dispatcher: SchedulerDispatcher
|
|
295
|
+
) -> None:
|
|
296
|
+
self.capacity = capacity
|
|
297
|
+
self.strategy = strategy
|
|
298
|
+
self._dispatcher = dispatcher
|
|
299
|
+
self._messages: deque[A] = deque()
|
|
300
|
+
self._state: _Active[A, E] | _Done[E] = _Active()
|
|
301
|
+
self._scheduled = False
|
|
302
|
+
|
|
303
|
+
@classmethod
|
|
304
|
+
def make(
|
|
305
|
+
cls, *, capacity: float = inf, strategy: Strategy = "suspend"
|
|
306
|
+
) -> Effect[Queue[A, E], Never, Never]:
|
|
307
|
+
return with_dispatcher(lambda dispatcher: succeed(cls(capacity, strategy, dispatcher)))
|
|
308
|
+
|
|
309
|
+
@classmethod
|
|
310
|
+
def bounded(cls, capacity: float) -> Effect[Queue[A, E], Never, Never]:
|
|
311
|
+
return cls.make(capacity=capacity)
|
|
312
|
+
|
|
313
|
+
@classmethod
|
|
314
|
+
def dropping(cls, capacity: float) -> Effect[Queue[A, E], Never, Never]:
|
|
315
|
+
return cls.make(capacity=capacity, strategy="dropping")
|
|
316
|
+
|
|
317
|
+
@classmethod
|
|
318
|
+
def sliding(cls, capacity: float) -> Effect[Queue[A, E], Never, Never]:
|
|
319
|
+
return cls.make(capacity=capacity, strategy="sliding")
|
|
320
|
+
|
|
321
|
+
@classmethod
|
|
322
|
+
def unbounded(cls) -> Effect[Queue[A, E], Never, Never]:
|
|
323
|
+
return cls.make()
|
|
324
|
+
|
|
325
|
+
def as_enqueue(self) -> Enqueue[A, E]:
|
|
326
|
+
return self
|
|
327
|
+
|
|
328
|
+
def as_dequeue(self) -> Dequeue[A, E]:
|
|
329
|
+
return self
|
|
330
|
+
|
|
331
|
+
def offer_unsafe(self, message: A) -> bool:
|
|
332
|
+
state = self._state
|
|
333
|
+
if isinstance(state, _Done) or state.terminal is not None:
|
|
334
|
+
return False
|
|
335
|
+
if len(self._messages) >= self.capacity:
|
|
336
|
+
if self.capacity <= 0 and len(state.takers) > (
|
|
337
|
+
0 if self.strategy == "sliding" else len(self._messages)
|
|
338
|
+
):
|
|
339
|
+
self._messages.append(message)
|
|
340
|
+
if self.strategy == "sliding":
|
|
341
|
+
self._trim(len(state.takers))
|
|
342
|
+
self.flush_unsafe()
|
|
343
|
+
return True
|
|
344
|
+
if self.strategy == "sliding":
|
|
345
|
+
if self.capacity > 0:
|
|
346
|
+
self._messages.popleft()
|
|
347
|
+
self._messages.append(message)
|
|
348
|
+
return True
|
|
349
|
+
return False
|
|
350
|
+
self._messages.append(message)
|
|
351
|
+
self._schedule_takers()
|
|
352
|
+
return True
|
|
353
|
+
|
|
354
|
+
def offer(self, message: A) -> Effect[bool, Never, Never]:
|
|
355
|
+
def attempt() -> Effect[bool, Never, Never]:
|
|
356
|
+
if self.offer_unsafe(message):
|
|
357
|
+
return Success(True)
|
|
358
|
+
state = self._state
|
|
359
|
+
if isinstance(state, _Done) or state.terminal is not None or self.strategy != "suspend":
|
|
360
|
+
return Success(False)
|
|
361
|
+
|
|
362
|
+
def register(resume: _Resume[bool, Never]) -> Effect[None, Never, Never] | None:
|
|
363
|
+
if self.offer_unsafe(message):
|
|
364
|
+
resume(Success(True))
|
|
365
|
+
return None
|
|
366
|
+
return self._wait_offer(_Single(message, resume))
|
|
367
|
+
|
|
368
|
+
return async_(register)
|
|
369
|
+
|
|
370
|
+
return suspend(attempt)
|
|
371
|
+
|
|
372
|
+
def _trim(self, capacity: float) -> None:
|
|
373
|
+
# MutableList.takeNVoid normalizes the removal count (MutableList.ts:516).
|
|
374
|
+
excess = _count(len(self._messages) - capacity)
|
|
375
|
+
while excess > 0 and self._messages:
|
|
376
|
+
self._messages.popleft()
|
|
377
|
+
excess -= 1
|
|
378
|
+
|
|
379
|
+
def offer_all_unsafe[B, F](self: Queue[B, F], messages: Iterable[B]) -> list[B]:
|
|
380
|
+
state = self._state
|
|
381
|
+
if isinstance(state, _Done) or state.terminal is not None:
|
|
382
|
+
return list(messages)
|
|
383
|
+
if self.capacity == inf or self.strategy == "sliding":
|
|
384
|
+
self._messages.extend(messages)
|
|
385
|
+
if self.strategy == "sliding":
|
|
386
|
+
self._trim(len(state.takers) if self.capacity <= 0 else self.capacity)
|
|
387
|
+
self._schedule_takers()
|
|
388
|
+
return []
|
|
389
|
+
free = (len(state.takers) if self.capacity <= 0 else self.capacity) - len(self._messages)
|
|
390
|
+
if free <= 0:
|
|
391
|
+
return list(messages)
|
|
392
|
+
remaining: list[B] = []
|
|
393
|
+
for index, message in enumerate(messages):
|
|
394
|
+
if index < free:
|
|
395
|
+
self._messages.append(message)
|
|
396
|
+
else:
|
|
397
|
+
remaining.append(message)
|
|
398
|
+
self._schedule_takers()
|
|
399
|
+
return remaining
|
|
400
|
+
|
|
401
|
+
def offer_all[B, F](self: Queue[B, F], messages: Iterable[B]) -> Effect[list[B], Never, Never]:
|
|
402
|
+
def register(resume: _Resume[list[B], Never]) -> Effect[None, Never, Never] | None:
|
|
403
|
+
remaining = self.offer_all_unsafe(messages)
|
|
404
|
+
if not remaining or self.strategy == "dropping":
|
|
405
|
+
resume(Success(remaining))
|
|
406
|
+
return None
|
|
407
|
+
return self._wait_offer(_Batch(remaining, resume))
|
|
408
|
+
|
|
409
|
+
return async_(register)
|
|
410
|
+
|
|
411
|
+
def _wait_offer(self, entry: _Single[A] | _Batch[A]) -> Effect[None, Never, Never] | None:
|
|
412
|
+
state = self._state
|
|
413
|
+
if isinstance(state, _Done) or state.terminal is not None:
|
|
414
|
+
self._reject(entry)
|
|
415
|
+
return None
|
|
416
|
+
token = state.offers.add(entry)
|
|
417
|
+
|
|
418
|
+
def cancel() -> None:
|
|
419
|
+
current = self._state
|
|
420
|
+
if isinstance(current, _Done):
|
|
421
|
+
return
|
|
422
|
+
state.offers.remove(token)
|
|
423
|
+
if current.terminal is not None and not state.offers and not self._messages:
|
|
424
|
+
self._finalize(current.terminal)
|
|
425
|
+
|
|
426
|
+
return sync(cancel)
|
|
427
|
+
|
|
428
|
+
@staticmethod
|
|
429
|
+
def _reject(entry: _Single[A] | _Batch[A]) -> None:
|
|
430
|
+
if isinstance(entry, _Single):
|
|
431
|
+
entry.resume(Success(False))
|
|
432
|
+
else:
|
|
433
|
+
entry.resume(Success(entry.remaining[entry.offset :]))
|
|
434
|
+
|
|
435
|
+
def fail_cause_unsafe(self, cause: Cause[E]) -> bool:
|
|
436
|
+
state = self._state
|
|
437
|
+
if isinstance(state, _Done) or state.terminal is not None:
|
|
438
|
+
return False
|
|
439
|
+
terminal = Failure(cause)
|
|
440
|
+
if not state.offers and not self._messages:
|
|
441
|
+
self._finalize(terminal)
|
|
442
|
+
else:
|
|
443
|
+
state.terminal = terminal
|
|
444
|
+
self._schedule_takers()
|
|
445
|
+
return True
|
|
446
|
+
|
|
447
|
+
def shutdown_unsafe(self) -> bool:
|
|
448
|
+
state = self._state
|
|
449
|
+
if isinstance(state, _Done):
|
|
450
|
+
return False
|
|
451
|
+
self._messages.clear()
|
|
452
|
+
self._finalize(state.terminal if state.terminal is not None else Failure(Cause.interrupt()))
|
|
453
|
+
for _, entry in state.offers:
|
|
454
|
+
self._reject(entry)
|
|
455
|
+
state.offers.clear()
|
|
456
|
+
return True
|
|
457
|
+
|
|
458
|
+
def _finalize(self, terminal: Failure[E]) -> None:
|
|
459
|
+
state = self._state
|
|
460
|
+
if isinstance(state, _Done):
|
|
461
|
+
return
|
|
462
|
+
self._state = _Done(terminal)
|
|
463
|
+
for _, taker in state.takers:
|
|
464
|
+
taker.resume(terminal)
|
|
465
|
+
state.takers.clear()
|
|
466
|
+
for _, resume in state.awaiters:
|
|
467
|
+
resume(terminal)
|
|
468
|
+
state.awaiters.clear()
|
|
469
|
+
|
|
470
|
+
def _schedule_takers(self) -> None:
|
|
471
|
+
state = self._state
|
|
472
|
+
if self._scheduled or isinstance(state, _Done) or not state.takers:
|
|
473
|
+
return
|
|
474
|
+
self._scheduled = True
|
|
475
|
+
|
|
476
|
+
def release() -> None:
|
|
477
|
+
self._scheduled = False
|
|
478
|
+
self.flush_unsafe()
|
|
479
|
+
|
|
480
|
+
self._dispatcher.schedule_task(release, 0)
|
|
481
|
+
|
|
482
|
+
def flush_unsafe(self) -> None:
|
|
483
|
+
state = self._state
|
|
484
|
+
if isinstance(state, _Done):
|
|
485
|
+
return
|
|
486
|
+
for token, taker in state.takers:
|
|
487
|
+
if not taker.ready():
|
|
488
|
+
continue
|
|
489
|
+
state.takers.remove(token)
|
|
490
|
+
taker.resume(Success(None))
|
|
491
|
+
if not self._messages:
|
|
492
|
+
break
|
|
493
|
+
|
|
494
|
+
def _await_take(self, ready: Callable[[], bool]) -> Effect[None, E, Never]:
|
|
495
|
+
def register(resume: _Resume[None, E]) -> Effect[None, Never, Never] | None:
|
|
496
|
+
state = self._state
|
|
497
|
+
if isinstance(state, _Done):
|
|
498
|
+
resume(state.terminal)
|
|
499
|
+
return None
|
|
500
|
+
if ready():
|
|
501
|
+
resume(Success(None))
|
|
502
|
+
return None
|
|
503
|
+
token = state.takers.add(_Taker(ready, resume))
|
|
504
|
+
return sync(lambda: state.takers.remove(token))
|
|
505
|
+
|
|
506
|
+
return async_(register)
|
|
507
|
+
|
|
508
|
+
def _can_take(self, minimum: float) -> bool:
|
|
509
|
+
state = self._state
|
|
510
|
+
if isinstance(state, _Done):
|
|
511
|
+
return False
|
|
512
|
+
# JS capacity || 1 treats NaN as false as well as zero.
|
|
513
|
+
capacity = self.capacity if self.capacity and not isnan(self.capacity) else 1
|
|
514
|
+
threshold = 1 if state.terminal is not None else min(minimum, capacity)
|
|
515
|
+
return len(self._messages) >= threshold or (self.capacity <= 0 and bool(state.offers))
|
|
516
|
+
|
|
517
|
+
def _take_offer(self, offers: _Registry[_Single[A] | _Batch[A]]) -> A:
|
|
518
|
+
token, entry = next(iter(offers))
|
|
519
|
+
if isinstance(entry, _Single):
|
|
520
|
+
message = entry.message
|
|
521
|
+
offers.remove(token)
|
|
522
|
+
entry.resume(Success(True))
|
|
523
|
+
return message
|
|
524
|
+
message = entry.remaining[entry.offset]
|
|
525
|
+
entry.offset += 1
|
|
526
|
+
if entry.offset == len(entry.remaining):
|
|
527
|
+
offers.remove(token)
|
|
528
|
+
entry.resume(Success([]))
|
|
529
|
+
return message
|
|
530
|
+
|
|
531
|
+
def _release_capacity(self) -> None:
|
|
532
|
+
"""Admit waiting offers into freed capacity, oldest first (releaseCapacity,
|
|
533
|
+
Queue.ts:2109). Each offer is reserved in the buffer and removed before its producer
|
|
534
|
+
resumes: resuming can synchronously take, offer or shut down this queue, so capacity
|
|
535
|
+
and state are read again for every offer."""
|
|
536
|
+
state = self._state
|
|
537
|
+
if isinstance(state, _Done):
|
|
538
|
+
return
|
|
539
|
+
if not state.offers:
|
|
540
|
+
if state.terminal is not None and not self._messages:
|
|
541
|
+
self._finalize(state.terminal)
|
|
542
|
+
return
|
|
543
|
+
for token, entry in state.offers:
|
|
544
|
+
free = self.capacity - len(self._messages)
|
|
545
|
+
if free <= 0 or not self._admit(entry, free):
|
|
546
|
+
return
|
|
547
|
+
state.offers.remove(token)
|
|
548
|
+
self._accept(entry)
|
|
549
|
+
if isinstance(self._state, _Done):
|
|
550
|
+
return
|
|
551
|
+
|
|
552
|
+
def _admit(self, entry: _Single[A] | _Batch[A], free: float) -> bool:
|
|
553
|
+
"""Buffer the offer's messages while `free` lasts; True when none are left to send.
|
|
554
|
+
A batch keeps its progress in `offset` and stays registered until then."""
|
|
555
|
+
if isinstance(entry, _Single):
|
|
556
|
+
self._messages.append(entry.message)
|
|
557
|
+
return True
|
|
558
|
+
while entry.offset < len(entry.remaining):
|
|
559
|
+
if free == 0: # upstream's `n === 0`: a fractional raw capacity never stops here
|
|
560
|
+
return False
|
|
561
|
+
self._messages.append(entry.remaining[entry.offset])
|
|
562
|
+
free -= 1
|
|
563
|
+
entry.offset += 1
|
|
564
|
+
return True
|
|
565
|
+
|
|
566
|
+
@staticmethod
|
|
567
|
+
def _accept(entry: _Single[A] | _Batch[A]) -> None:
|
|
568
|
+
if isinstance(entry, _Single):
|
|
569
|
+
entry.resume(Success(True))
|
|
570
|
+
else:
|
|
571
|
+
entry.resume(Success([]))
|
|
572
|
+
|
|
573
|
+
def take_unsafe(self) -> Exit[A, E] | None:
|
|
574
|
+
state = self._state
|
|
575
|
+
if isinstance(state, _Done):
|
|
576
|
+
return state.terminal
|
|
577
|
+
if self._messages:
|
|
578
|
+
message = self._messages.popleft()
|
|
579
|
+
elif self.capacity <= 0 and state.offers:
|
|
580
|
+
message = self._take_offer(state.offers)
|
|
581
|
+
else:
|
|
582
|
+
return None
|
|
583
|
+
self._release_capacity()
|
|
584
|
+
return Success(message)
|
|
585
|
+
|
|
586
|
+
def take_between(self, minimum: float, maximum: float) -> Effect[list[A], E, Never]:
|
|
587
|
+
minimum, maximum = _count(minimum), _count(maximum)
|
|
588
|
+
|
|
589
|
+
def attempt() -> Effect[list[A], E, Never]:
|
|
590
|
+
state = self._state
|
|
591
|
+
if isinstance(state, _Done):
|
|
592
|
+
return state.terminal
|
|
593
|
+
if maximum <= 0 or minimum <= 0:
|
|
594
|
+
return Success([])
|
|
595
|
+
if not self._can_take(minimum):
|
|
596
|
+
return self._await_take(lambda: self._can_take(minimum)).flat_map(
|
|
597
|
+
lambda _: suspend_exit(attempt)
|
|
598
|
+
)
|
|
599
|
+
messages: list[A] = []
|
|
600
|
+
if self._messages:
|
|
601
|
+
while self._messages and len(messages) < maximum:
|
|
602
|
+
messages.append(self._messages.popleft())
|
|
603
|
+
else:
|
|
604
|
+
messages.append(self._take_offer(state.offers))
|
|
605
|
+
self._release_capacity()
|
|
606
|
+
return Success(messages)
|
|
607
|
+
|
|
608
|
+
return suspend_exit(attempt)
|
|
609
|
+
|
|
610
|
+
def _clear_raw(self) -> Effect[list[A], E, Never]:
|
|
611
|
+
def attempt() -> Effect[list[A], E, Never]:
|
|
612
|
+
state = self._state
|
|
613
|
+
if isinstance(state, _Done):
|
|
614
|
+
return state.terminal
|
|
615
|
+
if self._messages:
|
|
616
|
+
messages = list(self._messages)
|
|
617
|
+
self._messages.clear()
|
|
618
|
+
self._release_capacity()
|
|
619
|
+
elif state.offers:
|
|
620
|
+
messages = [self._take_offer(state.offers)]
|
|
621
|
+
self._release_capacity()
|
|
622
|
+
else:
|
|
623
|
+
messages = []
|
|
624
|
+
self._release_capacity()
|
|
625
|
+
return Success(messages)
|
|
626
|
+
|
|
627
|
+
return suspend_exit(attempt)
|
|
628
|
+
|
|
629
|
+
def peek(self) -> Effect[A, E, Never]:
|
|
630
|
+
def attempt() -> Effect[A, E, Never]:
|
|
631
|
+
state = self._state
|
|
632
|
+
if isinstance(state, _Done):
|
|
633
|
+
return state.terminal
|
|
634
|
+
if self._messages:
|
|
635
|
+
return Success(self._messages[0])
|
|
636
|
+
return self._await_take(lambda: bool(self._messages)).flat_map(lambda _: self.peek())
|
|
637
|
+
|
|
638
|
+
return suspend(attempt)
|
|
639
|
+
|
|
640
|
+
def _await_raw(self) -> Effect[None, E, Never]:
|
|
641
|
+
def register(resume: _Resume[None, E]) -> Effect[None, Never, Never] | None:
|
|
642
|
+
state = self._state
|
|
643
|
+
if isinstance(state, _Done):
|
|
644
|
+
resume(state.terminal)
|
|
645
|
+
return None
|
|
646
|
+
token = state.awaiters.add(resume)
|
|
647
|
+
return sync(lambda: state.awaiters.remove(token))
|
|
648
|
+
|
|
649
|
+
return async_(register)
|
|
650
|
+
|
|
651
|
+
def size_unsafe(self) -> int:
|
|
652
|
+
return 0 if isinstance(self._state, _Done) else len(self._messages)
|
|
653
|
+
|
|
654
|
+
def is_full_unsafe(self) -> bool:
|
|
655
|
+
return self.size_unsafe() == self.capacity
|
|
656
|
+
|
|
657
|
+
|
|
658
|
+
def is_queue(value: object) -> TypeIs[Queue[object, object]]:
|
|
659
|
+
return isinstance(value, Queue)
|
|
660
|
+
|
|
661
|
+
|
|
662
|
+
def is_enqueue(value: object) -> TypeIs[Enqueue[object, object]]:
|
|
663
|
+
return isinstance(value, Enqueue)
|
|
664
|
+
|
|
665
|
+
|
|
666
|
+
def is_dequeue(value: object) -> TypeIs[Dequeue[object, object]]:
|
|
667
|
+
return isinstance(value, Dequeue)
|
|
668
|
+
|
|
669
|
+
|
|
670
|
+
__all__ = ["Dequeue", "Enqueue", "Queue", "is_dequeue", "is_enqueue", "is_queue"]
|