asynkit 0.19.1__tar.gz → 0.19.2__tar.gz

{asynkit-0.19.1/src/asynkit.egg-info → asynkit-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asynkit
-Version: 0.19.1
+Version: 0.19.2
 Summary: A toolkit for Python coroutines
 Author-email: Kristján Valur Jónsson <sweskman@gmail.com>
 License: MIT
@@ -460,6 +460,17 @@ so that it is executed using `await_sync()`:
 >>>
 ```
 
+For methods, use `syncmethod()` when creating a class-body alias. It behaves
+like `syncfunction()` at runtime, but exposes descriptor typing so type checkers
+can distinguish bound and unbound method access:
+
+```python
+class Runner:
+    async def arun(self, *, yield_every: int | None = None) -> None: ...
+
+    run = asynkit.syncmethod(arun)
+```
+
 the `asyncfunction()` utility can be used when passing synchronous callbacks to async
 code, to make them async. This, along with `syncfunction()` and `await_sync()`,
 can be used to integrate synchronous code with async middleware:

{asynkit-0.19.1 → asynkit-0.19.2}/README.md

@@ -432,6 +432,17 @@ so that it is executed using `await_sync()`:
 >>>
 ```
 
+For methods, use `syncmethod()` when creating a class-body alias. It behaves
+like `syncfunction()` at runtime, but exposes descriptor typing so type checkers
+can distinguish bound and unbound method access:
+
+```python
+class Runner:
+    async def arun(self, *, yield_every: int | None = None) -> None: ...
+
+    run = asynkit.syncmethod(arun)
+```
+
 the `asyncfunction()` utility can be used when passing synchronous callbacks to async
 code, to make them async. This, along with `syncfunction()` and `await_sync()`,
 can be used to integrate synchronous code with async middleware:

{asynkit-0.19.1 → asynkit-0.19.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "asynkit"
-version = "0.19.1"
+version = "0.19.2"
 description = "A toolkit for Python coroutines"
 authors = [
     {name = "Kristján Valur Jónsson", email = "sweskman@gmail.com"}
@@ -141,10 +141,8 @@ ignore = [
 python-version = "3.10"
 
 [tool.ty.src]
-include = ["src/asynkit"]
+include = ["src/asynkit", "tests/typing"]
 exclude = [
-    "tests",
-    "examples",
     "build",
     "src/asynkit.egg-info",
 ]

{asynkit-0.19.1 → asynkit-0.19.2}/src/asynkit/coroutine.py

@@ -22,6 +22,7 @@ from types import FrameType
 from typing import (
     TYPE_CHECKING,
     Any,
+    Concatenate,
     Generic,
     TypeVar,
     cast,
@@ -133,6 +134,8 @@ __all__ = [
     "SynchronousAbort",
     "asyncfunction",
     "syncfunction",
+    "syncmethod",
+    "SyncMethod",
 ]
 
 
@@ -150,6 +153,7 @@ def get_current_context() -> Context:
 
 T = TypeVar("T")
 S = TypeVar("S")
+SelfT = TypeVar("SelfT")
 P = ParamSpec("P")
 T_co = TypeVar("T_co", covariant=True)
 Suspendable = (
@@ -1168,6 +1172,59 @@ def syncfunction(func: Callable[P, Coroutine[Any, Any, T]]) -> Callable[P, T]:
     return helper
 
 
+class SyncMethod(Generic[SelfT, P, T]):
+    """Descriptor which makes an async method synchronous.
+
+    Unlike `syncfunction()`, this preserves method binding semantics when used
+    for class-body aliases such as `run = syncmethod(arun)`.
+    """
+
+    def __init__(
+        self,
+        func: Callable[Concatenate[SelfT, P], Coroutine[Any, Any, T]],
+    ) -> None:
+        self._func = func
+        functools.update_wrapper(self, func)
+
+    @overload
+    def __get__(
+        self,
+        instance: None,
+        owner: type[SelfT],
+    ) -> Callable[Concatenate[SelfT, P], T]: ...
+
+    @overload
+    def __get__(
+        self,
+        instance: SelfT,
+        owner: type[SelfT] | None = None,
+    ) -> Callable[P, T]: ...
+
+    def __get__(
+        self,
+        instance: SelfT | None,
+        owner: type[SelfT] | None = None,
+    ) -> Callable[..., T]:
+        if instance is None:
+            return self
+
+        @functools.wraps(self._func)
+        def helper(*args: P.args, **kwargs: P.kwargs) -> T:
+            return self(instance, *args, **kwargs)
+
+        return helper
+
+    def __call__(self, instance: SelfT, *args: P.args, **kwargs: P.kwargs) -> T:
+        return await_sync(self._func(instance, *args, **kwargs))
+
+
+def syncmethod(
+    func: Callable[Concatenate[SelfT, P], Coroutine[Any, Any, T]],
+) -> SyncMethod[SelfT, P, T]:
+    """Make an async method synchronous while preserving descriptor typing."""
+    return SyncMethod(func)
+
+
 def asyncfunction(func: Callable[P, T]) -> Callable[P, Coroutine[Any, Any, T]]:
     """Make a regular function async, so that its result needs to be awaited.
     Useful when providing synchronous callbacks to async code.

{asynkit-0.19.1 → asynkit-0.19.2/src/asynkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asynkit
-Version: 0.19.1
+Version: 0.19.2
 Summary: A toolkit for Python coroutines
 Author-email: Kristján Valur Jónsson <sweskman@gmail.com>
 License: MIT
@@ -460,6 +460,17 @@ so that it is executed using `await_sync()`:
 >>>
 ```
 
+For methods, use `syncmethod()` when creating a class-body alias. It behaves
+like `syncfunction()` at runtime, but exposes descriptor typing so type checkers
+can distinguish bound and unbound method access:
+
+```python
+class Runner:
+    async def arun(self, *, yield_every: int | None = None) -> None: ...
+
+    run = asynkit.syncmethod(arun)
+```
+
 the `asyncfunction()` utility can be used when passing synchronous callbacks to async
 code, to make them async. This, along with `syncfunction()` and `await_sync()`,
 can be used to integrate synchronous code with async middleware:

{asynkit-0.19.1 → asynkit-0.19.2}/tests/test_coro.py

@@ -826,6 +826,9 @@ class TestCoroRun:
         await self.sleep(0)
         return "nullsleep"
 
+    async def blocks(self):
+        await drive_yield("blocked")
+
     @asynkit.syncfunction
     async def sync_simple(self):
         return await self.simple()
@@ -838,6 +841,9 @@ class TestCoroRun:
     async def sync_genexit(self):
         return await self.genexit()
 
+    method_simple = asynkit.syncmethod(simple)
+    method_blocks = asynkit.syncmethod(blocks)
+
     def test_simple(self):
         assert asynkit.await_sync(self.simple()) == "simple"
 
@@ -852,6 +858,23 @@ class TestCoroRun:
     def test_sync_simple(self):
         assert self.sync_simple() == "simple"
 
+    def test_syncmethod_bound(self):
+        assert self.method_simple() == "simple"
+
+    def test_syncmethod_unbound(self):
+        assert type(self).method_simple(self) == "simple"
+
+    def test_syncmethod_descriptor(self):
+        descriptor = type(self).__dict__["method_simple"]
+        assert isinstance(descriptor, asynkit.SyncMethod)
+        assert type(self).method_simple.__name__ == "simple"
+        assert self.method_simple.__name__ == "simple"
+
+    def test_syncmethod_blocks(self):
+        with pytest.raises(asynkit.SynchronousError) as err:
+            self.method_blocks()
+        assert err.match("failed to complete synchronously")
+
     def test_cleanup(self):
         assert self.sync_cleanup() is None
 

{asynkit-0.19.1 → asynkit-0.19.2}/tests/test_namespace.py

@@ -20,6 +20,8 @@ def test_package_star_exports_public_api_only():
     assert exports == set(asynkit.__all__)
     assert "coro_start" in exports
     assert "coro_drive" in exports
+    assert "syncmethod" in exports
+    assert "SyncMethod" in exports
     assert "cancelling" in exports
     assert "coroutine" not in exports
     assert "loop" not in exports