Support non-async-functions too, closes #15

README.md

@@ -44,14 +44,16 @@ registry = Registry(example, simonwillison, both)
 combined = await registry.resolve(both)
 print(combined)
 ```
-If you run this in `ipython` (which supports top-level await) you will see output that combines HTML from both of those pages.
+If you run this in `ipython` or `python -m asyncio` (to enable top-level await in the console) you will see output that combines HTML from both of those pages.
 
 The HTTP requests to `www.example.com` and `simonwillison.net` will be performed in parallel.
 
 The library notices that `both()` takes two arguments which are the names of other registered `async def` functions, and will construct an execution plan that executes those two functions in parallel, then passes their results to the `both()` method.
 
 ### Registering additional functions
 
+Functions that are registered can be regular functions or `async def` functions.
+
 In addition to registering functions by passing them to the constructor, you can also add them to a registry using the `.register()` method:
 
 ```python

asyncinject/__init__.py

@@ -86,9 +86,20 @@ def _plan(self, names, results=None):
         return ts
 
     def _get_awaitable(self, name, results):
-        aw = self._registry[name](
-            **{k: v for k, v in results.items() if k in self.graph[name]},
-        )
+        fn = self._registry[name]
+        kwargs = {k: v for k, v in results.items() if k in self.graph[name]}
+
+        awaitable_fn = fn
+
+        if not asyncio.iscoroutinefunction(fn):
+
+            async def _awaitable(*args, **kwargs):
+                return fn(*args, **kwargs)
+
+            _awaitable.__name__ = fn.__name__
+            awaitable_fn = _awaitable
+
+        aw = awaitable_fn(**kwargs)
         if self.timer:
             aw = self._make_time_logger(aw)
         return aw

tests/test_asyncinject.py

@@ -187,7 +187,8 @@ def three_not_async(one, two):
 async def test_register():
     registry = Registry()
 
-    async def one():
+    # Mix in a non-async function too:
+    def one():
         return "one"
 
     async def two_():
@@ -207,3 +208,26 @@ async def three(one, two):
     result = await registry.resolve(three)
 
     assert result == "onetwo"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("parallel", (True, False))
+async def test_just_sync_functions(parallel):
+    def one():
+        return 1
+
+    def two():
+        return 2
+
+    def three(one, two):
+        return one + two
+
+    timed = []
+
+    registry = Registry(
+        one, two, three, parallel=parallel, timer=lambda *args: timed.append(args)
+    )
+    result = await registry.resolve(three)
+    assert result == 3
+
+    assert {t[0] for t in timed} == {"two", "one", "three"}