Some ideas on implementation

[cjpit]

Hi there, Just some background on myself, I've been a c# guy for quite a few years, but have just started to move across to python the last couple of months.

I started on python 3, and am used to using other DI frameworks in c#, using constructor injection.

I have a library which does all of my business logic, and uses use_annotations, to inject. All works fine.
One of my objects I pass in is my Database object.
I now have a need to use the same library ,but for two different databases. Each database is for a different company, but I'll need to merge data from both.

I just can't seem to get my head around how I can achieve this. At this stage I'm using flask injector, and for example have the following setup:

def configure(binder):
    db = CLDB(db_username=app.config['QUANTUM_USERNAME'],
              dsn=app.config['QUANTUM_DSN'],
              db_password=app.config['QUANTUM_PASSWORD'],
              logger=app.logger,
              quantum_username=app.config['QUANTUM_MASQUERADE_USER'])

    # set it up as a singleton.
    binder.bind(CLDB,
                to=db,
                scope=singleton
                )

injector = Injector(auto_bind=True, 
                             modules=[configure], 
                             use_annotations=True)
FlaskInjector(app=app, 
                      injector=injector)

then I have a separate library that has classes like:

class MSCIssuer:

    def __init__(self,
                 db: CLDB,
                 emailer: Emailer,
                 logger: Logger):
        self._db = db
        self._emailer = emailer
        self.logger = logger

now say in my merged project I want to instantiate two instances of MSCIssuer.

One with CLDB object 1, and one with CLDB object 2, each with different configurations.

Since I haven't used guice before I'm kind of stuck :(

Thank you.

[alecthomas]

This is a bit tricky, but basically you need a custom scope. There's actually an example that is quite close to what you need, included in the tests, but here's a full example that should do what you want. Note that you will need to sprinkle some thread-local storage and locks around if you're likely to be using this scope across threads.

from contextlib import contextmanager

from injector import (Injector, InstanceProvider, Scope, ScopeDecorator,
    UnsatisfiedRequirement)


class CompanyScope(Scope):
    def configure(self):
        self.context = None
        self.companies = {}

    @contextmanager
    def __call__(self, company):
        assert self.context is None
        self.context = self.companies.setdefault(company, {})
        yield
        self.context = None

    def get(self, key, provider):
        if self.context is None:
            raise UnsatisfiedRequirement(None, key)
        try:
            return self.context[key]
        except KeyError:
            provider = InstanceProvider(provider.get(self.injector))
            self.context[key] = provider
            return provider


companyscoped = ScopeDecorator(CompanyScope)

@companyscoped
class DB(object):
    pass


class Issuer(object):
    def __init__(self, db:DB):
        print('issuer db', db)


def module(binder):
    binder.bind_scope(CompanyScope)
    company = binder.injector.get(CompanyScope)
    with company('IBM'):
        binder.bind(DB)
    with company('Microsoft'):
        binder.bind(DB)
    binder.bind(Issuer)


injector = Injector(module, use_annotations=True, auto_bind=False)
company = injector.get(CompanyScope)
print('IBM')
with company('IBM'):
    print(injector.get(DB))
    print(injector.get(Issuer))

print()
print('Microsoft')
with company('Microsoft'):
    print(injector.get(DB))
    print(injector.get(Issuer))
    print(injector.get(Issuer))

Which outputs:

IBM
<__main__.DB object at 0x105b18b38>
issuer db <__main__.DB object at 0x105b18b38>
<__main__.Issuer object at 0x105b18be0>

Microsoft
<__main__.DB object at 0x105b18be0>
issuer db <__main__.DB object at 0x105b18be0>
<__main__.Issuer object at 0x105b18cc0>
issuer db <__main__.DB object at 0x105b18be0>
<__main__.Issuer object at 0x105b18cc0>

All of the addresses are what you would expect.

Just decorate anything you want scoped to a specific company with @companyscoped, and bind them as in the example.

The nice thing about this approach is that if you forget to use the context manager, you'll get a nice exception.

[juharris]

In Guice I might make custom annotations for each company as there would be many things that I might associate with that company. Another quicker easier way would be to use named annotations so for this library that would be to use a Key for each company's DB object.

[alecthomas]

Annotations/keys don't achieve the requested goal of being able to inject an MCIssuer with different database instances.

[alecthomas]

Actually there is another option: a root injector with everything but the database bound. Then one child injector for each company with the company-specific database objects bound to them.

[alecthomas]

And here's that example. Note that when using child injectors, singleton scoped objects are singleton across all injectors.

from injector import Injector, Module, singleton


class DB(object):
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '<DB(%s) object at 0x%x>' % (repr(self.name), id(self))


class Issuer(object):
    def __init__(self, db:DB):
        print('issuer db', db)


def app_module(binder):
    binder.bind(Issuer)


class DbModule(Module):
    def __init__(self, name):
        self.name = name

    def configure(self, binder):
        binder.bind(DB, to=DB(self.name))


injector = Injector(app_module, auto_bind=False, use_annotations=True)


microsoft = injector.create_child_injector(DbModule("Microsoft"), auto_bind=False, use_annotations=True)
print(microsoft.get(Issuer))
print(microsoft.get(Issuer))
ibm = injector.create_child_injector(DbModule("IBM"), auto_bind=False, use_annotations=True)
print(ibm.get(Issuer))
print(ibm.get(Issuer))