Metadata-Version: 2.1
Name: wired
Version: 0.2.2
Summary: An inversion-of-control (IoC) container for building decoupled, configurable, pluggable applications.
Home-page: https://wired.readthedocs.io
Author: Michael Merickel
Author-email: pylons-discuss@googlegroups.com
License: UNKNOWN
Description: =====
        wired
        =====
        
        .. image:: https://img.shields.io/pypi/v/wired.svg
            :target: https://pypi.org/pypi/wired
        
        .. image:: https://github.com/mmerickel/wired/workflows/Build/test%20on%20Linux/badge.svg
            :target: https://github.com/mmerickel/wired/actions?query=workflow%3A%22Build%2Ftest+on+Linux%22
        
        .. image:: https://github.com/mmerickel/wired/workflows/Build/test%20on%20MacOS/badge.svg
            :target: https://github.com/mmerickel/wired/actions?query=workflow%3A%22Build%2Ftest+on+MacOS%22
        
        .. image:: https://github.com/mmerickel/wired/workflows/Build/test%20on%20Windows/badge.svg
            :target: https://github.com/mmerickel/wired/actions?query=workflow%3A%22Build%2Ftest+on+Windows%22
        
        .. image:: https://readthedocs.org/projects/wired/badge/?version=latest
            :target: https://readthedocs.org/projects/wired/?badge=latest
            :alt: Documentation Status
        
        Have a large application where you want to *decrease coupling* between components?
        Need to *supply configuration* to your application's various services? Want to
        make a *pluggable application* where others can supply services?
        
        `Inversion of Control <https://en.wikipedia.org/wiki/Inversion_of_control>`_ and
        `Dependency Injection <https://en.wikipedia.org/wiki/Dependency_injection>`_ are
        two patterns commonly used for these goals.
        
        ``wired`` is an implementation of an inversion-of-control (IoC) container and
        may be used as the core of a dependency injection (DI) framework or simply as
        a way to separate config-time from runtime for services in an application. It
        also provides caching such that a container maintains a local copy of each
        service as they are instantiated.
        
        `wired` aims to scale down to the simplest cases and up to very large, custom
        systems. It has one dependency and that dependency has one dependency.
        
        See https://wired.readthedocs.io or
        ``docs/index.rst`` in this distribution for detailed documentation.
        
        
        Unreleased
        ==========
        
        - Added a ``name`` argument to ``wired.dataclasses.register_dataclass``
          to support registering services by name.
          See https://github.com/mmerickel/wired/pull/32
        
        - Removed the "how to write an injector" tutorial, then flatten a lot of the
          docs into no more than two levels (to please the RTD theme.)
          See https://github.com/mmerickel/wired/pull/32
        
        0.2.1 (2019-08-12)
        ==================
        
        - Added ``wired.dataclasses`` optional package with support for automatically
          generating service factories for Python 3.7's typed-dataclasses.
          Thanks Paul!
          See https://github.com/mmerickel/wired/pull/19
        
        - Added a new tutorial on writing a DI framework around Python 3.7's
          typed-dataclasses. Thanks again Paul!
          See https://github.com/mmerickel/wired/pull/16
        
        0.2 (2019-04-22)
        ================
        
        Backward Incompatibilities
        --------------------------
        
        - ``wired.ServiceContainer.set`` has been redefined to set a service instance
          for a specific context object instead of for a type-of-context. The new
          method ``wired.ServiceContainer.register_singleton`` is a direct replacement
          for the old behavior.
        
        Features
        --------
        
        - Add ``wired.ServiceContainer.register_factory`` and
          ``wired.ServiceContainer.register_singleton`` which are per-container
          analogues to their per-registry variants on ``wired.ServiceRegistry``.
        
        - Edit docs to (a) improve sales pitch, (b) split into a couple of sub-pages,
          and (c) provide a tutorial. Update README and ``setup.py`` description a
          bit as well.
          See https://github.com/mmerickel/wired/pull/6
        
        0.1.2 (2019-03-23)
        ==================
        
        - Add support for Python 3.7.
        
        - Fix an issue where two different service classes with the same name would
          be treated as the same service, defeating the type-based lookup.
        
        0.1.1 (2018-08-04)
        ==================
        
        - Improve memory management slightly in cases where many short-lived context
          objects are used by tracking and cleaning up their weakrefs.
        
        0.1 (2018-08-01)
        ================
        
        - Initial release.
        
Keywords: ioc container,inversion of control,dependency injection,service locator,singleton,service factory
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Requires-Python: >=3.5
Description-Content-Type: text/x-rst
Provides-Extra: docs
Provides-Extra: testing
