Async-to-sync bridging

When code needs to run async functions in a sync context, correctness and extensibility both matter. First, detect coroutine functions reliably: unwrap bound methods and functools.partial wrappers before checking, and prefer inspect.iscoroutinefunction over asyncio.iscoroutinefunction since the latter also matches deprecated @asyncio.coroutine generators that aren’t relevant when only async def is supported. For example:

def iscoroutinefunction(func):
    while inspect.ismethod(func):
        func = func.__func__
    while isinstance(func, functools.partial):
        func = func.func
    return inspect.iscoroutinefunction(func)

Second, isolate the actual sync-conversion call (e.g. async_to_sync(func)) into its own small, overridable method rather than burying it inside a larger dispatch method like ensure_sync. This lets subclasses or integrations (e.g. alternative event-loop runners) customize only the conversion strategy without duplicating the coroutine-detection boilerplate:

def ensure_sync(self, func):
    if iscoroutinefunction(func):
        return self.async_to_sync(func)
    return func

def async_to_sync(self, func):
    return async_to_sync_runner(func)

Keep detection logic and conversion logic separate, test both paths across supported Python versions, and avoid assuming a single wrapping style (plain function, method, or partial) when identifying async callables.