Scope inference

[adriangb]

I wrote a dependency injection system with a "scopes" system inspired by pytest: https://www.adriangb.com/di/latest/scopes/

Recently I came up with what I think is a nifty idea: automatically inferring scopes from the dependency DAG.

Picture the following:

import pytest

class DBConnection:
    def __init__(self, dsn: str) -> None:
        pass

@pytest.fixture
def get_dsn() -> str:
    return "foo://localhost:1234"


@pytest.fixture(scope="session")
def get_db(get_dsn: str) -> DBConnection:
    return DBConnection(get_dsn)


def test_db(get_db: DBConnection) -> None:
    pass

If you run with with Pytest you get:

ScopeMismatch: You tried to access the function scoped fixture get_dsn with a session scoped request object

So you're forced to go and add scope="session" to get_dsn.
But in theory pytest could do this for you: it could see that no explicit scope was set for get_dsn() and then assign it the "session" scope because that's the only thing it can be anyway.

I imagine pytest wouldn't want to make this change and I'm not proposing it does, but I am curious what folks think of this idea, if there are any obvious issues with it, etc.

[RonnyPfannschmidt]

While in this trivial example it could work, what about fixtures that will return different values each time?

[BorjaEst]

One could say to splicitly write "function" but I suppose that is just a matter of taste.
The way that user gets notified ensures that the user does not go into unexpected behaviour.

Not my case (I hope), but I can see a lot of users might forget then to add the "function" scope an would complain their tests are not working, so I would leave as it is right now.

I rather preffer an error than a silent bug.

[adriangb]

The behavior would be the same as it is now, but yes you could end up with a bug because you meant to make it a function scoped fixture (which wouldn't work but would throw an error) but it ended up being a session scoped fixture. Like BorjaEst said I think that's just a preference/tradeoff.

There could be an explicit scope="auto" to turn this behavior on which would at least allow users to opt into it via fixture = partial(pytest.fixutre, scope="auto") or just by habit of always setting it to "auto".

Either way, this was just a suggestion for what I think is an interesting idea that matches my preferences on the boilerplate vs. explicitness balance. Yes there are cases where explicit boilerplate saves from user error.

[BorjaEst]

I like the auto idea, specially on those cases where I have to copy and paste code because the scope changes in different modules. However, I would still go for the "function" scope as default parameter.

[adriangb]

Ah yes I forgot that we often end up copy pasting the function or adding a level of indirection just to have it at different scopes. That’s a good use case for the “auto” option even if it doesn’t save boilerplate in the decorator itself.