Multiple depedencies of the same type

[trendels]

First of all, thanks for svcs, especially the great documentation that outlines the related concepts so clearly!

My question is, what is the best way to handle multiple dependencies that have the same type? Say, you needhttpx.Client instances configured for different services (configured w/ different base_url/headers for example) or two database connections (one for writing to the primary, one for reading from the secondary)?

The only way to do this right now as far as I can see is to create empty subclasses of the service in order to distinguish between them:

import sqlalchemy as sa

class PrimaryConnection(sa.Connection):
    pass

class SecondaryConnection(sa.Connection):
    pass

registry.register_factory(PrimaryConnection, get_conn_for_primary)
registry.register_factory(SecondaryConnection, get_conn_for_secondary)

Now this works fine, except for the fact that what you get back from the container when asking for PrimaryConnection or SecondaryConnection is actually an sa.Connection. So you must remember to never put any additional attributes or methods on these subclasses, because they will not be available at runtime. Also, type checkers can't know about this and cannot help you avoid this mistake.

One idea that I had is that svcs could support registering services with a key of tuple[type, str] in addition to type, where the string is a key to discriminate between different registrations of the same type¹:

registry.register_factory((sa.Connection, "primary"), get_conn_for_primary)
registry.register_factory((sa.Connection, "secondary"), get_conn_for_secondary)

# later ...
primary, secondary = container.get((sa.Connection, "primary"), (sa.Connection, "secondary"))

This also works already, because I guess the types you pass at registration are just used as dictionary keys. It does not typecheck of course, but it could be made to do so with additional overloads of Container.get (unfortunately, it would need quite a lot of those).

It's entirely possible that I missed something and there is already a better way to do this. If so I think this would be a good addition to the documentation.

Footnotes

1. Actually, it wouldn't have to be a string. In practice you'd probably use an Enum to avoid typos. ↩

[trendels]

It just occurred to me that there's a third way, using typing.Annotated:

from typing import Annotated, TypeAlias

PrimaryConnection: TypeAlias = Annotated[sa.Connection, "primary"]
SecondaryConnection: TypeAlias = Annotated[sa.Connection, "secondary"]

This checks all the boxes: no unnecessary subclasses, type-safe, no changes to svcs required.

[hynek]

Ohhh that’s interesting! I was gonna say the obvious way would you introduce something like a context that would become a second element in the lookup tuple, but your annotated solution is so much more Modern-Typing-Pythonic! I, too, keep forgetting about it – this needs to be documented! :)

[hynek]

Tracking in #41

[trendels]

Great! Yeah, typing.Annotated is pretty cool.