support Python 3.10 (do not merge)

Author: catwell

finegrain/pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
     "pyjwt[crypto]>=2.10.1",
 ]
 readme = "README.md"
-requires-python = ">= 3.12, <3.13"
+requires-python = ">= 3.10"
 
 [dependency-groups]
 # pytest-asyncio > 0.21 changes event loop management
@@ -35,7 +35,7 @@ packages = ["src/finegrain"]
 
 [tool.ruff]
 line-length = 120
-target-version = "py312"
+target-version = "py310"
 
 [tool.ruff.lint]
 select = [

finegrain/src/finegrain/__init__.py

@@ -6,7 +6,7 @@
 import re
 from collections import defaultdict
 from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
-from typing import IO, Any, Literal, NewType, cast, get_args
+from typing import IO, Any, Generic, Literal, NewType, TypeVar, cast, get_args
 
 import httpx
 import httpx_sse
@@ -52,7 +52,14 @@ def default_message(self) -> str:
         return f"SSE loop stopped (first error: {self.first_error}, last error: {self.last_error})"
 
 
-class Futures[Tk, Tv]:
+Tk = TypeVar("Tk")
+Tv = TypeVar("Tv")
+Tok = TypeVar("Tok", bound="OKResult")
+Tko = TypeVar("Tko", bound="ErrorResult")
+TokWithImage = TypeVar("TokWithImage", bound="OKResultWithImage")
+
+
+class Futures(Generic[Tk, Tv]):
     _event_loop: asyncio.AbstractEventLoop | None
 
     @property
@@ -140,7 +147,10 @@ def success(self) -> None:
         self.failures = 0
 
 
-class TimeoutableAsyncIterator[T](AsyncIterator[T]):
+T = TypeVar("T")
+
+
+class TimeoutableAsyncIterator(AsyncIterator[T], Generic[T]):
     def __init__(self, iterator: AsyncIterator[T], timeout: float) -> None:
         self.iterator = iterator
         self.timeout = timeout
@@ -187,7 +197,7 @@ def reset(self) -> None:
         self.active = asyncio.get_running_loop().create_future()
 
     @staticmethod
-    def async_return[T](x: T) -> Callable[[], Awaitable[T]]:
+    def async_return(x: T) -> Callable[[], Awaitable[T]]:
         async def f() -> T:
             return x
 
@@ -613,11 +623,11 @@ async def get_image(
         response = await self.request("GET", f"state/image/{state_id}", params=params)
         return response.content
 
-    async def _run_one[Tin, Tout](
+    async def _run_one(
         self,
-        co: Callable[["EditorAPIContext", Tin], Awaitable[Tout]],
-        params: Tin,
-    ) -> Tout:
+        co: Callable[["EditorAPIContext", Any], Awaitable[Any]],
+        params: Any,
+    ) -> Any:
         # This wraps the coroutine in the SSE loop.
         # This is mostly useful if you use synchronous Python,
         # otherwise you can call the functions directly.
@@ -630,11 +640,11 @@ async def _run_one[Tin, Tout](
         finally:
             await self.sse_stop()
 
-    def run_one_sync[Tin, Tout](
+    def run_one_sync(
         self,
-        co: Callable[["EditorAPIContext", Tin], Awaitable[Tout]],
-        params: Tin,
-    ) -> Tout:
+        co: Callable[["EditorAPIContext", Any], Awaitable[Any]],
+        params: Any,
+    ) -> Any:
         try:
             loop = asyncio.get_event_loop()
         except RuntimeError:
@@ -1032,7 +1042,7 @@ async def _create_state(
         status = await self.ctx.sse_await(state_id, timeout=timeout)
         return state_id, status
 
-    async def _response[Tok: OKResult, Tko: ErrorResult](
+    async def _response(
         self,
         st: StateID,
         ok: bool,
@@ -1047,22 +1057,21 @@ async def _response[Tok: OKResult, Tko: ErrorResult](
             assert meta["status"] == "ko"
             return t_ko(state_id=st, meta=meta)
 
-    async def _response_with_image[Tok: OKResultWithImage, Tko: ErrorResult](
+    async def _response_with_image(
         self,
         st: StateID,
         ok: bool,
-        t_ok: type[Tok] = OKResultWithImage,
+        t_ok: type[TokWithImage] = OKResultWithImage,
         t_ko: type[Tko] = ErrorResult,
         params: ImageOutParams | None = None,
-    ) -> Tok | Tko:
+    ) -> TokWithImage | Tko:
         if ok:
             if params is None:
                 params = ImageOutParams()
-            async with asyncio.TaskGroup() as tg:
-                meta_f = tg.create_task(self.ctx.get_meta(st))
-                image_f = tg.create_task(self.ctx.get_image(st, params.image_format, params.resolution))
-            meta = meta_f.result()
-            image = image_f.result()
+            meta, image = await asyncio.gather(
+                self.ctx.get_meta(st),
+                self.ctx.get_image(st, params.image_format, params.resolution),
+            )
             assert meta["status"] == "ok"
             return t_ok(state_id=st, meta=meta, image=image)
         else:

finegrain/tests/test_move.py

@@ -16,11 +16,10 @@ async def test_move(
     segment_r = await fgctx.call_async.segment(st_input, bbox=bbox_r.bbox)
     assert isinstance(segment_r, OKResult)
 
-    async with asyncio.TaskGroup() as tg:
-        erase_task = tg.create_task(fgctx.call_async.erase(st_input, segment_r.state_id))
-        cutout_task = tg.create_task(fgctx.call_async.cutout(st_input, segment_r.state_id))
-
-    erase_r, cutout_r = erase_task.result(), cutout_task.result()
+    erase_r, cutout_r = await asyncio.gather(
+        fgctx.call_async.erase(st_input, segment_r.state_id),
+        fgctx.call_async.cutout(st_input, segment_r.state_id),
+    )
     assert isinstance(erase_r, OKResult)
     assert isinstance(cutout_r, OKResult)
 

finegrain/tests/test_recolor.py

@@ -17,10 +17,7 @@ async def test_recolor(
         (1210, 629, 1298, 733),
     ]
 
-    async with asyncio.TaskGroup() as tg:
-        tasks = [tg.create_task(fgctx.call_async.segment(st_input, bbox)) for bbox in bboxes]
-
-    segment_results = [t.result() for t in tasks]
+    segment_results = await asyncio.gather(*[fgctx.call_async.segment(st_input, bbox) for bbox in bboxes])
     for r in segment_results:
         assert isinstance(r, OKResult)
     segment_state_ids = [r.state_id for r in segment_results]