Metadata-Version: 1.1
Name: dic
Version: 1.3.0b1
Summary: Dependency Injection Container Micro-framework for implementing IoC
Home-page: https://github.com/zsims/dic
Author: Zachary Sims
Author-email: zsims@users.noreply.github.com
License: LICENSE.txt
Description: dic
        ===
        
        Dependency Injection Container for Python 3+ influenced partially by Autofac_. dic aims to be a tiny framework to help
        you manage dependencies.
        
        dic uses Python 3 annotations to provide hints for the components that should be injected.
        
        Install
        =======
        dic is available via pip:
         ::
        
            pip install dic
        
        Features
        ========
        Currently, dic supports:
        
        1. Constructor injection for classes
        2. Factory and Lazy relationships
        3. Registration via:
            1. Constructor matching for a registered class
            2. Custom callback
        4. Lifetime scopes:
            1. Instance per dependency
            2. Single instance
        
        Quick Example
        =============
        A quick example on how to use dic:
         ::
        
            import dic
        
            class SimpleThing(object):
                def say(self, message):
                    print(message)
        
            class RequiresThing(object):
                def __init__(self, thing: SimpleThing):
                    self.thing = thing
        
                def say(self, message):
                    self.thing.say(message)
        
            # build the container
            builder = dic.container.ContainerBuilder()
        
            builder.register_class(SimpleThing)
            builder.register_class(RequiresThing, component_scope=dic.scope.SingleInstance)
        
            container = builder.build()
        
            # use the container
        
            # Note there'll only be one of these due to SingleInstance scoping during build
            x = container.resolve(RequiresThing)
            x.say("my message")
        
        Relationships
        =============
        dic supports basic relationships:
        
        1. `dic.rel.Lazy` - don't create the dependency until it's first used
        2. `dic.rel.Factory` - the component wants to create other components. Lifetime scopes are respected. Supports custom arguments.
        
        Using a factory:
         ::
        
            import dic
        
            class SimpleThing(object):
                def __init__(self, special_argument):
                    self.special_argument = special_argument
        
            class BuildsThings(object):
                def __init__(self, thing_factory: dic.rel.Factory(SimpleThing)):
                    self.thing_factory = thing_factory
        
                def build_me_a_thing(self):
                    # builds a new thing using the injected factory
                    # Note that custom arguments can be provided here
                    self.thing_factory(special_argument="My super special argument")
        
            # build the container
            builder = dic.container.ContainerBuilder()
        
            builder.register_class(SimpleThing)
            builder.register_class(BuildsThing)
        
            container = builder.build()
        
            # use the container
        
            x = container.resolve(BuildsThing)
        
            # use it
            thing = x.build_me_a_thing()
            # ...
        
        
        FAQ
        ===
        
        1. Is dic thread-safe?
        
         Yes. `dic.rel.Lazy` and `dic.container.Container.resolve()` are thread-safe. As a result, do not store the component_context given to `register_callback` callbacks,
         as this is how thread-safety is enforced.
        
        2. Can I define my own scopes?
        
         Yes. Derive a scope from `dic.scope.Scope`. Scopes can be used to provide lifetime for a calling thread, for example
        
        3. Will you support feature "X"?
        
         The philosophy of dic is to remain small, but extensible -- e.g. remain "out of the way." So likely not.
        
        .. _Autofac: http://autofac.org/
        
Keywords: development design ioc di
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
