pyfect-dev 0.1.0__tar.gz → 0.1.1__tar.gz

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfect-dev
-Version: 0.1.0
+Version: 0.1.1
 Summary: Effect-TS for Python: typed effects, a real fiber runtime, structured concurrency, services and layers.
 Author: Tyler Gibbs
 Author-email: Tyler Gibbs <tylergibbs048@gmail.com>
@@ -63,6 +63,7 @@ Description-Content-Type: text/markdown
 </p>
 
 <p align="center">
+  <a href="https://pypi.org/project/pyfect-dev/"><img alt="PyPI" src="https://img.shields.io/pypi/v/pyfect-dev?color=0a0a0a&label=pypi"></a>
   <a href="https://pyfect.dev/docs"><img alt="Docs" src="https://img.shields.io/badge/docs-pyfect.dev-0a0a0a"></a>
   <img alt="Python 3.13+" src="https://img.shields.io/badge/python-3.13%2B-0a0a0a">
   <img alt="pyright strict" src="https://img.shields.io/badge/pyright-strict-0a0a0a">
@@ -179,9 +180,9 @@ layer, concurrency, retries and timeouts.
   and `repeat`. [Schedules →](https://pyfect.dev/docs/schedules)
 - **Streams.** Pull-based streams, sinks and channels with backpressure, plus NDJSON, JSON
   array and Server-Sent Events framers. [Streams →](https://pyfect.dev/docs/streams)
-- **Schema.** Decode and encode data with Effect's error messages, generate JSON Schema and
-  Hypothesis strategies, store schemas themselves as JSON documents, and plug into pydantic
-  or msgspec.
+- **Schema.** Decode and encode data with Effect's error messages, compile decoders at run
+  time or ahead of time, generate JSON Schema and Hypothesis strategies, store schemas
+  themselves as JSON documents, and plug into Standard Schema, pydantic or msgspec.
   [Schema →](https://pyfect.dev/docs/schema)
 - **Transactions.** Software transactional memory: `TxRef`, transactional queues, maps,
   locks and semaphores that commit atomically and retry without blocking a thread.
@@ -191,7 +192,8 @@ layer, concurrency, retries and timeouts.
   them as JSON. [Graphs →](https://pyfect.dev/docs/graph)
 - **Config.** Typed settings from the environment, `.env` files or dicts, with secrets kept
   out of logs. [Config →](https://pyfect.dev/docs/config)
-- **Observability.** Logging, spans, metrics and an OpenTelemetry bridge.
+- **Observability.** Logging, spans and metrics, exported through Effect's own OTLP exporters
+  or the OpenTelemetry SDK.
   [Observability →](https://pyfect.dev/docs/observability)
 - **Platform.** Files, child processes, an HTTP client (httpx), an HTTP server (standard library,
   uvicorn, hypercorn for HTTP/2, or any ASGI server), and TCP, TLS, WebSocket
@@ -243,11 +245,12 @@ layer, concurrency, retries and timeouts.
   retry takes no real time. [Testing →](https://pyfect.dev/docs/testing)
 
 pyfect follows Effect v4, does what Effect does wherever Python can express it, and runs
-Effect's own test cases as its spec: over 21,000 tests, with a test that fails on any Effect
-test title neither ported nor omitted with a reason, and about 94% of Effect's API so far. Every
+Effect's own test cases as its spec: over 22,000 tests, with a test that fails on any Effect
+test title neither ported nor omitted with a reason, and about 95% of Effect's API so far. Every
 export of the core modules is listed against Effect's in [`docs/coverage/`](docs/coverage), and
 [`docs/PARITY.md`](docs/PARITY.md) tracks what is done, what is open and what still differs. One
 difference to know: a bare number as a `Duration` is seconds here and milliseconds in Effect.
+0.2.0 will switch to milliseconds; write `"5 seconds"` or a `timedelta` to be unaffected.
 
 ## Installation
 
@@ -277,6 +280,7 @@ generators never use it. See [Installation](https://pyfect.dev/docs/installation
 
 - [Documentation](https://pyfect.dev/docs): guides for each part of the library.
 - [API reference](https://pyfect.dev/docs/reference): every public function and class.
+- [Changelog](CHANGELOG.md): what each release changed.
 - [Examples](examples/): a quickstart, batching, a FastAPI-style service, a stream pipeline
   and schema decoding, all checked by pyright.
 - [Effect's docs](https://effect.website/docs): the concepts carry over; pyfect uses

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/README.md

@@ -9,6 +9,7 @@
 </p>
 
 <p align="center">
+  <a href="https://pypi.org/project/pyfect-dev/"><img alt="PyPI" src="https://img.shields.io/pypi/v/pyfect-dev?color=0a0a0a&label=pypi"></a>
   <a href="https://pyfect.dev/docs"><img alt="Docs" src="https://img.shields.io/badge/docs-pyfect.dev-0a0a0a"></a>
   <img alt="Python 3.13+" src="https://img.shields.io/badge/python-3.13%2B-0a0a0a">
   <img alt="pyright strict" src="https://img.shields.io/badge/pyright-strict-0a0a0a">
@@ -125,9 +126,9 @@ layer, concurrency, retries and timeouts.
   and `repeat`. [Schedules →](https://pyfect.dev/docs/schedules)
 - **Streams.** Pull-based streams, sinks and channels with backpressure, plus NDJSON, JSON
   array and Server-Sent Events framers. [Streams →](https://pyfect.dev/docs/streams)
-- **Schema.** Decode and encode data with Effect's error messages, generate JSON Schema and
-  Hypothesis strategies, store schemas themselves as JSON documents, and plug into pydantic
-  or msgspec.
+- **Schema.** Decode and encode data with Effect's error messages, compile decoders at run
+  time or ahead of time, generate JSON Schema and Hypothesis strategies, store schemas
+  themselves as JSON documents, and plug into Standard Schema, pydantic or msgspec.
   [Schema →](https://pyfect.dev/docs/schema)
 - **Transactions.** Software transactional memory: `TxRef`, transactional queues, maps,
   locks and semaphores that commit atomically and retry without blocking a thread.
@@ -137,7 +138,8 @@ layer, concurrency, retries and timeouts.
   them as JSON. [Graphs →](https://pyfect.dev/docs/graph)
 - **Config.** Typed settings from the environment, `.env` files or dicts, with secrets kept
   out of logs. [Config →](https://pyfect.dev/docs/config)
-- **Observability.** Logging, spans, metrics and an OpenTelemetry bridge.
+- **Observability.** Logging, spans and metrics, exported through Effect's own OTLP exporters
+  or the OpenTelemetry SDK.
   [Observability →](https://pyfect.dev/docs/observability)
 - **Platform.** Files, child processes, an HTTP client (httpx), an HTTP server (standard library,
   uvicorn, hypercorn for HTTP/2, or any ASGI server), and TCP, TLS, WebSocket
@@ -189,11 +191,12 @@ layer, concurrency, retries and timeouts.
   retry takes no real time. [Testing →](https://pyfect.dev/docs/testing)
 
 pyfect follows Effect v4, does what Effect does wherever Python can express it, and runs
-Effect's own test cases as its spec: over 21,000 tests, with a test that fails on any Effect
-test title neither ported nor omitted with a reason, and about 94% of Effect's API so far. Every
+Effect's own test cases as its spec: over 22,000 tests, with a test that fails on any Effect
+test title neither ported nor omitted with a reason, and about 95% of Effect's API so far. Every
 export of the core modules is listed against Effect's in [`docs/coverage/`](docs/coverage), and
 [`docs/PARITY.md`](docs/PARITY.md) tracks what is done, what is open and what still differs. One
 difference to know: a bare number as a `Duration` is seconds here and milliseconds in Effect.
+0.2.0 will switch to milliseconds; write `"5 seconds"` or a `timedelta` to be unaffected.
 
 ## Installation
 
@@ -223,6 +226,7 @@ generators never use it. See [Installation](https://pyfect.dev/docs/installation
 
 - [Documentation](https://pyfect.dev/docs): guides for each part of the library.
 - [API reference](https://pyfect.dev/docs/reference): every public function and class.
+- [Changelog](CHANGELOG.md): what each release changed.
 - [Examples](examples/): a quickstart, batching, a FastAPI-style service, a stream pipeline
   and schema decoding, all checked by pyright.
 - [Effect's docs](https://effect.website/docs): the concepts carry over; pyfect uses

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyfect-dev"
-version = "0.1.0"
+version = "0.1.1"
 description = "Effect-TS for Python: typed effects, a real fiber runtime, structured concurrency, services and layers."
 readme = "README.md"
 license = "MIT"

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "pyfect-dev"
-version = "0.1.0"
+version = "0.1.1"
 description = "Effect-TS for Python: typed effects, a real fiber runtime, structured concurrency, services and layers."
 readme = "README.md"
 authors = [{ name = "Tyler Gibbs", email = "tylergibbs048@gmail.com" }]

pyfect_dev-0.1.1/src/pyfect/_version.py

@@ -0,0 +1,9 @@
+"""pyfect's version (Effect's ``Version.getCurrentVersion()``)."""
+
+from importlib.metadata import version
+from typing import Final
+
+from pyfect._extras import DISTRIBUTION
+
+VERSION: Final = version(DISTRIBUTION)
+"""The installed distribution's version."""

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/ai/_mcp/dispatch.py

@@ -78,6 +78,7 @@ from pyfect.ai.mcp_schema import (
 from pyfect.cause import Cause, Fail
 from pyfect.deferred import Deferred
 from pyfect.effect import (
+    die,
     fail,
     fail_cause,
     gen,
@@ -382,7 +383,14 @@ class Connection:
                 self._listening.add(id)
             return fiber
 
-        return served.fork_daemon().map(track)
+        def begin() -> Effect[Fiber[None, Never]]:
+            if id in self._inflight:
+                # As Effect's RpcServer: a request reusing an id still in
+                # flight is refused, unanswered, and the first keeps the id.
+                return _VOID.fork_daemon()
+            return served.fork_daemon().map(track)
+
+        return suspend(begin)
 
     def answer(
         self, id: RequestId, method: str, params: JsonObject, out: Send
@@ -390,7 +398,11 @@ class Connection:
         """The response to a request (``None`` when it was cancelled)."""
         version = requested_protocol_version(params)
         stateless = self.registry.find(version) if version is not None else None
-        if stateless is not None and stateless.is_stateless:
+        if self.closed:
+            # A batch read on after its session ended: as Effect's
+            # clientMiddleware, the request dies before it is served.
+            answered: Effect[Wire, McpError] = die(RuntimeError("Mcp-Session-Id does not exist"))
+        elif stateless is not None and stateless.is_stateless:
             answered = self._stateless(stateless, id, method, params, out)
         elif version is not None and stateless is None and _offers_stateless(self.registry):
             answered = fail(_unsupported_version(version, self.registry))
@@ -658,8 +670,12 @@ class Connection:
         return self._feature(protocol, self.identity, method, params, out)
 
     def _initialize(self, params: JsonObject) -> Effect[Wire, McpError]:
-        offered = params.get("protocolVersion")
-        protocol = self.registry.select_stateful(offered if isinstance(offered, str) else None)
+        # The first initialize chooses the protocol for the session's life; a
+        # later one, as in Effect, keeps it and replaces only the client.
+        protocol = self.protocol
+        if protocol is None:
+            offered = params.get("protocolVersion")
+            protocol = self.registry.select_stateful(offered if isinstance(offered, str) else None)
         if protocol is None:
             return fail(_method_not_found("initialize"))
 

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/cache/_cache.py

@@ -31,7 +31,7 @@ from pyfect.cache._expiry import (
 )
 from pyfect.cause import Cause
 from pyfect.context import Context
-from pyfect.duration import Seconds
+from pyfect.duration import ZERO, Seconds
 from pyfect.exit import Exit, Failure, Success
 from pyfect.option import Option, Some
 
@@ -252,7 +252,7 @@ class Cache[K: Hashable = Unsubscripted, A = Unsubscripted, E = Never, R = Never
             if _interrupted(ex):
                 self._remove(key, entry)
                 return
-            ttl = self._time_to_live(ex, key)
+            ttl = entry.time_to_live
             if ttl == 0:
                 skip = True
                 self._remove(key, entry)
@@ -281,7 +281,7 @@ class Cache[K: Hashable = Unsubscripted, A = Unsubscripted, E = Never, R = Never
             if _interrupted(ex):
                 self._remove(key, entry)
                 return
-            ttl = self._time_to_live(ex, key)
+            ttl = entry.time_to_live
             if ttl == 0:
                 if existing:
                     self._discard(key)
@@ -300,14 +300,25 @@ class Cache[K: Hashable = Unsubscripted, A = Unsubscripted, E = Never, R = Never
         """An entry whose lookup has run up to its first wait (Effect's
         immediate fork), on a root fiber with this cache's services
         overridden by the caller's. A raising ``lookup`` fails the caller
-        with a defect, as in Effect."""
+        with a defect, as in Effect.
+
+        The time to live is decided inside the lookup fiber, so the fiber's
+        observers call no user code: a raising ``time_to_live`` keeps
+        nothing and becomes the lookup's defect, which ends every caller.
+        (Effect calls it in an observer, where a raise hangs the callers.)"""
         lookup = self._lookup(key)
         lookup_fiber: Fiber[A, E] = new_root(
             fiber._run_scheduler, self._context.merge(fiber._context)
         )
         entry = _Entry[A, E](lookup_fiber)
         entry.release = lambda: self._remove(key, entry)
-        start_root(lookup_fiber, lookup)
+
+        def decide_time_to_live(ex: Exit[A, E]) -> Effect[None]:
+            if not _interrupted(ex):
+                entry.time_to_live = self._time_to_live(ex, key)
+            return _VOID
+
+        start_root(lookup_fiber, lookup.on_exit(decide_time_to_live))
         return entry
 
     def _find(self, fiber: Fiber[Any, Any], key: K, *, touch: bool) -> _Entry[A, E] | None:
@@ -351,12 +362,14 @@ class Cache[K: Hashable = Unsubscripted, A = Unsubscripted, E = Never, R = Never
 class _Entry[A, E]:
     """A lookup and the callers waiting on it."""
 
-    __slots__ = ("awaiters", "expires_at", "fiber", "release")
+    __slots__ = ("awaiters", "expires_at", "fiber", "release", "time_to_live")
 
     def __init__(self, fiber: Fiber[A, E]) -> None:
         self.fiber = fiber
         self.awaiters = 0
         self.expires_at: int | None = None
+        # Set as the lookup ends; stays zero if ``time_to_live`` raised.
+        self.time_to_live: Seconds = ZERO
         # Drops the entry from the cache when its waiters abandon it.
         self.release: Callable[[], None] | None = None
 

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/cause.py

@@ -264,24 +264,25 @@ class Cause(Generic[E_co]):
         )
         return errors if errors or not self.reasons else (_interrupted(self),)
 
-    def pretty(self) -> str:
-        """``pretty_errors`` rendered with their tracebacks and cause chains,
-        each followed by the span frames its reason records (Effect's
-        ``    at span (location)`` lines)."""
+    def pretty_stacks(self) -> tuple[str, ...]:
+        """Each of ``pretty_errors`` rendered with its traceback and cause
+        chain, followed by the span frames its reason records (Effect's
+        ``stack`` of each ``prettyErrors(cause, { includeCauseInStack })``
+        error)."""
         from pyfect._stack_frame import StackTrace, render
 
         errors = self.pretty_errors()
         reasons = [r for r in self.reasons if not isinstance(r, Interrupt)] or self.reasons[:1]
-        return "\n\n".join(
-            "\n".join(
-                [
-                    _render_error(e),
-                    *render(_frame(r.annotations, StackTrace)),
-                ]
-            )
+        return tuple(
+            "\n".join([_render_error(e), *render(_frame(r.annotations, StackTrace))])
             for e, r in zip(errors, reasons, strict=True)
         )
 
+    def pretty(self) -> str:
+        """``pretty_stacks`` joined by blank lines (Effect's ``    at span
+        (location)`` lines after each error)."""
+        return "\n\n".join(self.pretty_stacks())
+
 
 def _render_error(error: BaseException) -> str:
     """``error`` with its traceback and cause chain; a defect decoded from

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/encoding/schema_binary/_compile.py

@@ -14,7 +14,7 @@ from pyfect.encoding.schema_binary import _wire as W
 from pyfect.encoding.schema_binary._literals import literal_key, literal_kind_code, literal_text
 from pyfect.schema import ast
 from pyfect.schema._undefined import UNDEFINED_ID
-from pyfect.schema.ast._candidates import Sentinel, sentinels
+from pyfect.schema.ast._candidates import Sentinel, collect_sentinels
 from pyfect.schema.ast._check import FilterGroup
 
 FIELD_ID_KEY = "~effect/encoding/SchemaBinary/fieldId"
@@ -438,7 +438,7 @@ class _Compiler:
                     values.append(member.literal)
                 continue
             if isinstance(member, ast.Objects | ast.Arrays):
-                found = sentinels(member)
+                found = collect_sentinels(member)
                 if found:
                     variant_members.append((member, found))
                     continue

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/http/asgi/_mount.py

@@ -15,8 +15,9 @@ from urllib.parse import urlsplit
 
 from pyfect._core import Effect, _WithFiber
 from pyfect._fiber import Fiber
-from pyfect.effect import fail, from_async, try_async
+from pyfect.effect import fail, from_async, sync, try_async
 from pyfect.errors import TaggedError
+from pyfect.exit import Exit
 from pyfect.http._foreign_path import decode_path
 from pyfect.http.abort import AbortController
 from pyfect.http.asgi._types import AsgiApplication, Message
@@ -83,15 +84,26 @@ def _scope(request: ServerRequest, state: Mapping[str, Any] | None) -> dict[str,
 
 class _Exchange:
     """One call of the application: ``receive`` reads the request body,
-    ``send`` hands the response over."""
+    ``send`` hands the response over, and ``finish`` ends the call however
+    the response ended (read, dropped, bodyless, client gone)."""
 
-    def __init__(self, body: AsyncIterator[bytes] | None) -> None:
+    def __init__(
+        self, app: AsgiApplication, scope: dict[str, Any], body: AsyncIterator[bytes] | None
+    ) -> None:
         loop = asyncio.get_running_loop()
         self._body = body
         self._body_done = False
-        self.finished = asyncio.Event()
+        self._finished = asyncio.Event()
         self.started: asyncio.Future[tuple[int, list[tuple[str, str]]]] = loop.create_future()
         self.chunks: asyncio.Queue[bytes | None] = asyncio.Queue(_QUEUED_CHUNKS)
+        self.task = asyncio.ensure_future(app(scope, self.receive, self.send))
+
+    def finish(self) -> None:
+        """The response ended: the application sees a disconnect and is
+        cancelled if it still runs. Idempotent."""
+        self._finished.set()
+        if not self.task.done():
+            self.task.cancel()
 
     async def receive(self) -> Message:
         if not self._body_done:
@@ -104,7 +116,7 @@ class _Exchange:
                     return {"type": "http.request", "body": chunk, "more_body": True}
             self._body_done = True
             return {"type": "http.request", "body": b"", "more_body": False}
-        await self.finished.wait()
+        await self._finished.wait()
         return {"type": "http.disconnect"}
 
     async def send(self, message: Message) -> None:
@@ -116,16 +128,17 @@ class _Exchange:
                     [(name.decode("latin-1"), value.decode("latin-1")) for name, value in headers],
                 )
             )
-        elif message["type"] == "http.response.body" and not self.finished.is_set():
+        elif message["type"] == "http.response.body" and not self._finished.is_set():
             chunk: bytes = message.get("body", b"")
             if chunk:
                 await self.chunks.put(chunk)
             if not message.get("more_body", False):
-                self.finished.set()
+                self._finished.set()
                 await self.chunks.put(None)
 
 
-async def _body(exchange: _Exchange, task: asyncio.Task[None]) -> AsyncIterator[bytes]:
+async def _body(exchange: _Exchange) -> AsyncIterator[bytes]:
+    task = exchange.task
     try:
         while True:
             getting = asyncio.ensure_future(exchange.chunks.get())
@@ -140,27 +153,20 @@ async def _body(exchange: _Exchange, task: asyncio.Task[None]) -> AsyncIterator[
                 return
             yield chunk
     finally:
-        exchange.finished.set()
-        if not task.done():
-            task.cancel()
+        exchange.finish()
 
 
-async def _call(
-    app: AsgiApplication, scope: dict[str, Any], body: AsyncIterator[bytes] | None
-) -> WebResponse:
-    exchange = _Exchange(body)
-    task = asyncio.ensure_future(app(scope, exchange.receive, exchange.send))
+async def _call(exchange: _Exchange) -> WebResponse:
     try:
-        await asyncio.wait((exchange.started, task), return_when=asyncio.FIRST_COMPLETED)
+        await asyncio.wait((exchange.started, exchange.task), return_when=asyncio.FIRST_COMPLETED)
     except asyncio.CancelledError:
-        exchange.finished.set()
-        task.cancel()
+        exchange.finish()
         raise
     if not exchange.started.done():
-        task.result()
+        exchange.task.result()
         raise AsgiNoResponseError("the ASGI application returned without a response")
     status, headers = exchange.started.result()
-    return WebResponse(_body(exchange, task), status=status, headers=headers)
+    return WebResponse(_body(exchange), status=status, headers=headers)
 
 
 def from_asgi(
@@ -182,10 +188,13 @@ def from_asgi(
                 pass
         scope = _scope(request, state)
         body = None if web.body is None else web.chunks()
+        exchanges: list[_Exchange] = []
 
         async def call() -> WebResponse:
+            exchange = _Exchange(app, scope, body)
+            exchanges.append(exchange)
             try:
-                return await _call(app, scope, body)
+                return await _call(exchange)
             except asyncio.CancelledError:
                 controller.abort()
                 raise
@@ -193,7 +202,18 @@ def from_asgi(
         def on_error(cause: Exception) -> HttpServerError:
             return HttpServerError(InternalError(request, "HttpApp.fromAsgi: Error in app", cause))
 
-        return try_async(call, on_error).map(response_from_web)
+        called = try_async(call, on_error).map(response_from_web)
+        found, request_scope = fiber._context.lookup(Scope)
+        if not found:
+            return called
+
+        # The request's scope closes once the response ended, however it
+        # ended: its body read or dropped, never sent (HEAD, 204, 304), or
+        # the client gone.
+        def finish(_exit: Exit[Any, Any]) -> Effect[None]:
+            return sync(lambda: [exchange.finish() for exchange in exchanges]).as_void()
+
+        return request_scope.add_finalizer(finish).and_then(called)
 
     return _WithFiber(run)
 

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/http/asgi/_web_socket.py

@@ -56,6 +56,14 @@ _UPGRADED = empty(status=101)
 _LOST = (1005, 1006)
 """Disconnect codes of a connection that ended without a closing handshake."""
 
+_MOVES: dict[int, frozenset[int]] = {
+    CONNECTING: frozenset({OPEN, CLOSED}),
+    OPEN: frozenset({CLOSING, CLOSED}),
+    CLOSING: frozenset({CLOSED}),
+    CLOSED: frozenset(),
+}
+"""The ready states each state may move to: a closed socket never reopens."""
+
 
 class AsgiWebSocket:
     """A browser-style WebSocket over an ASGI ``websocket`` connection.
@@ -143,10 +151,19 @@ class AsgiWebSocket:
         if self._state != CONNECTING:
             raise ConnectionError("The socket closed before the upgrade")
         await self._send({"type": "websocket.accept", "subprotocol": subprotocol})
-        self._state = OPEN
+        if not self._move(OPEN):
+            raise ConnectionError("The socket closed during the upgrade")
         self._writer = self._loop.create_task(self._write())
         self._dispatch("open", WebSocketEvent(type="open"))
 
+    def _move(self, to: int) -> bool:
+        """The only place the ready state changes; ``False`` when ``to`` is not
+        a move from the current state."""
+        if to not in _MOVES[self._state]:
+            return False
+        self._state = to
+        return True
+
     def _dispatch(self, type: WebSocketEventType, event: WebSocketEvent) -> None:
         with self._lock:
             entries = self._listeners.get(type, [])
@@ -161,8 +178,7 @@ class AsgiWebSocket:
                 )
 
     def _close(self, code: int, reason: str) -> None:
-        if self._state == OPEN:
-            self._state = CLOSING
+        if self._move(CLOSING):
             close: Message = {"type": "websocket.close", "code": code, "reason": reason}
             self._outgoing.put_nowait((close, 0))
 
@@ -184,7 +200,7 @@ class AsgiWebSocket:
 
     def _disconnected(self, code: int, reason: str) -> None:
         opened = self._state != CONNECTING
-        self._state = CLOSED
+        self._move(CLOSED)
         if not self._closing and (code in _LOST or not opened):
             self.lost.set()
         self._outgoing.put_nowait(None)

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/http/incoming_message.py

@@ -22,11 +22,11 @@ from pyfect.schema import (
     to_codec_json,
 )
 from pyfect.schema._options import ParseOptions
+from pyfect.schema.getter._json_options import JsonReviver, revive
 from pyfect.stream import Stream
 
-type Reviver = Callable[[str, object], object]
-"""``JSON.parse``'s reviver: called with each key (``""`` for the root) and
-its parsed value, children first; what it returns replaces the value."""
+type Reviver = JsonReviver
+"""``JSON.parse``'s reviver (``getter.JsonReviver``)."""
 
 
 class HttpIncomingMessage[E](Protocol):
@@ -63,22 +63,6 @@ class MessageDecoder[T, RD](Protocol):
     def __call__[E](self, message: HttpIncomingMessage[E], /) -> Effect[T, E | SchemaError, RD]: ...
 
 
-def revive(value: object, reviver: Reviver) -> object:
-    """``value`` (parsed JSON) walked as ``JSON.parse`` walks it with
-    ``reviver``."""
-
-    def walk(key: str, node: object) -> object:
-        if isinstance(node, list):
-            items: list[object] = node  # pyright: ignore[reportUnknownVariableType]
-            node = [walk(str(i), item) for i, item in enumerate(items)]
-        elif isinstance(node, dict):
-            entries: dict[str, object] = node  # pyright: ignore[reportUnknownVariableType]
-            node = {k: walk(k, v) for k, v in entries.items()}
-        return reviver(key, node)
-
-    return walk("", value)
-
-
 _parse_json = decode_effect(from_json_string(Unknown))
 
 

{pyfect_dev-0.1.0 → pyfect_dev-0.1.1}/src/pyfect/http/live_server/_listener.py

@@ -166,7 +166,7 @@ class Listener:
             for conn in pending + idle:
                 conn.close(graceful=True)
 
-        drained = timeout_option(self.signal.wait_until(lambda: not self._serving), timeout)
+        drained = timeout_option(self.signal.wait(lambda: not self._serving), timeout)
         return sync(start).flat_map(lambda _: drained).as_void()