It looks like concurrency / parallelism is not being maximized due to the grouping of dependencies into node groups. Here's a simple example:

import asyncio
from time import time
from typing import Annotated

async def a():
    await asyncio.sleep(1)

async def b():
    await asyncio.sleep(2)

async def c(a):
    await asyncio.sleep(1)

async def d(b, c):
    pass

async def main_asyncinjector():
    reg = Registry(a, b, c, d)
    start = time()
    await reg.resolve(d)
    print(time()-start)

asyncio.run(main_asyncinjector())

This should take 2 seconds to run (start a and b, once a finishes start c, b and c finish at the same time and you're done) but takes 3 seconds (start a and b, wait for both to finish then start c).

This happens because graphlib.TopologicalSorter is not used online and instead it is being used to statically compute groups of dependencies.

I don't think it would be too hard to address this, but I'm not sure how much you'd want to change to accommodate this. I work on a similar project (https://github.com/adriangb/di) and there I found it very useful to break out the concept of an "executor" out of the container/registry concept, which means that instead of a parallel option you'd have pluggable executors that could choose to use concurrency, limit concurrency, use threads instead, etc. FWIW here's what that looks like with this example:

import asyncio
from time import time
from typing import Annotated

from asyncinject import Registry
from di.dependant import Marker, Dependant
from di.container import Container
from di.executors import ConcurrentAsyncExecutor


async def a():
    await asyncio.sleep(1)

async def b():
    await asyncio.sleep(2)

async def c(a: Annotated[None, Marker(a)]):
    await asyncio.sleep(1)

async def d(b: Annotated[None, Marker(b)], c: Annotated[None, Marker(c)]):
    pass

async def main_asyncinjector():
    reg = Registry(a, b, c, d)
    start = time()
    await reg.resolve(d)
    print(time()-start)


async def main_di():
    container = Container()
    solved = container.solve(Dependant(d), scopes=[None])
    executor = ConcurrentAsyncExecutor()
    async with container.enter_scope(None) as state:
        start = time()
        await container.execute_async(solved, executor, state=state)
        print(time()-start)

asyncio.run(main_asyncinjector())  # 3 seconds
asyncio.run(main_di())  # 2 seconds

I'm thinking about using this with Datasette plugins, which aren't well suited to the current class-based mechanism because plugins may want to register their own additional dependency injection functions.

Add a mechanism which shows exactly how the class is executing, including which methods are running in parallel. Maybe even with a very basic ASCII visualization? Then use it to help illustrate the examples in the README, refs #4.

Would be neat if you could toggle the parallel execution on and off, to better demonstrate the performance difference that it implements.

Would happen in this code that calls gather(): https://github.com/simonw/asyncinject/blob/47348978242880bd72a444158bbecc64566b0c55/asyncinject/init.py#L114-L123

I'd like to be able to do the following:

async def one():
    return 1

async def two():
    return 2

registry = Registry(one, two)

async def three(one, two):
    return one + two

result = await registry.resolve(three)

Note that three has not been registered with the registry - but it still has its parameters inspected and used to resolve the dependencies.

This would be useful for Datasette, where I want plugins to be able to interact with predefined registries without needing to worry about picking a name for their function that doesn't clash with a name that has been registered by another plugin.

https://twitter.com/dabeaz/status/1466731368956809219 - David Beazley says:

I think 95% of the problems once solved by a metaclass can be solved by __init_subclass__ instead

The examples in the README are boring, and don't show how the library can resolve a dependency tree into the most efficient possible mechanism.

Need to come up with a realistic example that demonstrates that.