Private classes

Author: blast-hardcheese

src/replit_river/v2/session.py

@@ -407,8 +407,7 @@ async def close(
         if (current_state or self._state) in TerminalStates:
             start = datetime.now()
             while (current_state or self._state) != SessionState.CLOSED:
-                elapsed = (datetime.now() - start).total_seconds()
-                if elapsed >= SESSION_CLOSE_TIMEOUT_SEC:
+                if (datetime.now() - start).total_seconds() >= SESSION_CLOSE_TIMEOUT_SEC:
                     logger.warning(
                         f"Session took longer than {SESSION_CLOSE_TIMEOUT_SEC} "
                         "seconds to close, leaking",
@@ -750,7 +749,7 @@ async def send_rpc[R, A](
             except Exception as e:
                 raise RiverException(ERROR_CODE_STREAM_CLOSED, str(e)) from e
             match raced:
-                case FinishedA(result):
+                case _FinishedA(result):
                     if "ok" not in result or not result["ok"]:
                         try:
                             error = error_deserializer(result["payload"])
@@ -761,7 +760,7 @@ async def send_rpc[R, A](
                         )
 
                     return response_deserializer(result["payload"])
-                case FinishedB(err):
+                case _FinishedB(err):
                     raise err
                 case other:
                     assert_never(other)
@@ -1423,24 +1422,27 @@ async def _recv_from_ws(
 
 
 @dataclass(frozen=True)
-class FinishedA[A]:
+class _FinishedA[A]:
     value: A
 
 
 @dataclass(frozen=True)
-class FinishedB[B]:
+class _FinishedB[B]:
     value: B
 
 
-async def _race2[A, B](a: Awaitable[A], b: Awaitable[B]) -> FinishedA[A] | FinishedB[B]:
+async def _race2[A, B](
+    a: Awaitable[A],
+    b: Awaitable[B],
+) -> _FinishedA[A] | _FinishedB[B]:
     _a = asyncio.ensure_future(a)
     _b = asyncio.ensure_future(b)
     await asyncio.wait([_a, _b], return_when=asyncio.FIRST_COMPLETED)
 
     if _a.done():
         if err := _a.exception():
             raise err
-        return FinishedA(_a.result())
+        return _FinishedA(_a.result())
     if err := _b.exception():
         raise err
-    return FinishedB(_b.result())
+    return _FinishedB(_b.result())