Rewrite internal run_sync (#222)

* Rewrite internal run_sync

Author: tarsil

docs/en/docs/release-notes.md

@@ -5,6 +5,18 @@ hide:
 
 # Release Notes
 
+## 0.17.1
+
+### Changed
+
+* **Dual‑mode support in run_sync:** Now accepts either an async function with args or a standalone coroutine object.
+* **Input normalization:** Uses `inspect` to detect and wrap calls into a zero‑argument coroutine factory.
+* **Seamless execution:** Drives work on the main thread via `anyio.run`,
+with a clean fallback to `ThreadPoolExecutor` if an event loop is active.
+* **Error clarity:** Raises a precise `TypeError` when the argument is neither a coroutine function nor object.
+* **Simplified API:** Eliminates nested lambdas by centralizing logic into a single `wrapper_fn`
+passed to `anyio.run`.
+
 ## 0.17.0
 
 ### Added

lilya/__init__.py

@@ -1 +1 @@
-__version__ = "0.17.0"
+__version__ = "0.17.1"

lilya/compat.py

@@ -3,7 +3,7 @@
 import functools
 import hashlib
 import inspect
-from collections.abc import Awaitable, Generator
+from collections.abc import Awaitable, Callable, Generator
 from concurrent import futures
 from typing import Any, Generic, Protocol, TypeVar
 
@@ -47,17 +47,31 @@ def is_async_callable(obj: Any) -> bool:
     )
 
 
-def run_sync(async_function: Awaitable, *args: Any, **kwargs: Any) -> Any:
+def run_sync(fn: Callable[..., Any] | Awaitable, *args: Any, **kwargs: Any) -> Any:
     """
-    Runs the queries in sync mode
+    Run an async function or coroutine object in sync code.
+
+    - If you pass a coroutine function + args, e.g. run_sync(fetch_data, 42),
+      it will call `anyio.run(fetch_data, 42)`.
+    - If you pass a coroutine object, e.g. run_sync(fetch_data(42)), it will
+      call `anyio.run(lambda: fetch_data(42))`.
+
+    Falls back to a ThreadPoolExecutor if we detect an existing running loop.
     """
+    if inspect.iscoroutine(fn):
+        wrapper_fn: Callable[[], Awaitable[Any]] = lambda: fn  # noqa: E731
+    elif inspect.iscoroutinefunction(fn):
+        wrapper_fn = lambda: fn(*args, **kwargs)  # noqa: E731
+    else:
+        raise TypeError(
+            f"run_sync() expects an async function or coroutine object; got {type(fn)}"
+        )
     try:
-        return anyio.run(async_function, *args, **kwargs)
+        return anyio.run(wrapper_fn)
     except RuntimeError:
         with futures.ThreadPoolExecutor(max_workers=1) as executor:
-            return executor.submit(
-                lambda: anyio.run(lambda: async_function, *args, **kwargs)
-            ).result()
+            future: futures.Future = executor.submit(anyio.run, wrapper_fn)
+            return future.result()
 
 
 class AsyncResourceHandler(Generic[SupportsAsyncCloseType]):

tests/dependencies/resolve/test_resolve.py

@@ -44,7 +44,7 @@ def test_use_requires_in_function_dependencies_using_provide(test_client_factory
                     "current_user": Provide(get_current_user),
                 },
             ),
-        ]
+        ],
     ) as client:
         response = client.get("/requires")