pythonioc 0.4.1

Global Registry

import pythonioc

# register your service with a default name (here: 'someService', see Notes On Names)
@pythonioc.Service
class SomeService(object):

    # called when the service is auto-instantiated.
    def postInit(self):
        pass

@pythonioc.NamedService('DifferentNameService')
class DifferentService(object):
    pass

# for classes which we cannot decorate:
pythonioc.registerService(ExternalService)

# when we don't even have the class (or don't care about lazy-initialization)
pythonioc.registerServiceInstance(SomeService())


class ServiceUser(object):
    # inject the dependency by class
    service = pythonioc.Inject(SomeService)

    # inject the dependency by name (for cyclic dependencies)
    service2 = pythonioc.Inject('DifferentNameService')


 myUser = ServiceUser()

 myUser.service # --> automatically created and injected service instance.

 # explicitly get a service
 pythonioc.getService(SomeService)
 pythonioc.getService('DifferentNameService')

Local Registry

class Service(object):

    # this will make the service registry inject a service named "someOtherService" which
    # comes from class SomeOtherService
    _someOtherService = None

    def __init__(self):
        pass

    # will be called after everything is injected
    def postInit(self):
        pass

    # will be called right before the object is destroyed (the registry's clean
    # method is called)
    def preDestroy(self):
        pass



class SomeOtherService(object):
    pass

# let's register our services
reg = ServiceRegistry()
reg.registerService(Service)
reg.registerService(SomeOtherService)

Once everything is registered, a service can be injected by

class WiredUser(object):

    _service=None

    def __init__(self, *args):
        pass

wiredUser = reg.createWired(WiredUser, 'arg1', 'arg2')

Wired objects are not automatically part of the service registry, only if added by calling reg.registerServiceInstance.

Wired objects can inject their own service registry, so they can create wired objects on the fly:

class WiredUser(object):
    _service=None


class UserCreator(object):
    _serviceRegistry=None

    def createUser(self):
        return self._serviceRegistry.createWired(WiredUser)

userCreator = reg.createWired(UserCreator)

# create some wired users
userA = userCreator.createUser()
userB = userCreator.createUser()