Metadata-Version: 1.0
Name: circuits
Version: 2.0.0
Summary: Asynchronous Component based Event Application Framework
Home-page: http://bitbucket.org/prologic/circuits/
Author: James Mills
Author-email: James Mills, prologic at shortcircuit dot net dot au
License: MIT
Download-URL: http://bitbucket.org/prologic/circuits/downloads/
Description: .. _Python Programming Language: http://www.python.org/
        .. _#circuits IRC Channel: http://webchat.freenode.net/?randomnick=1&channels=circuits&uio=d4
        .. _FreeNode IRC Network: http://freenode.net
        .. _Python Standard Library: http://docs.python.org/library/
        .. _Website: https://bitbucket.org/prologic/circuits/
        .. _PyPi Page: http://pypi.python.org/pypi/circuits
        .. _Read the Docs: http://readthedocs.org/docs/circuits/en/latest/
        .. _MIT License: http://www.opensource.org/licenses/mit-license.php
        .. _Create an Issue: https://bitbucket.org/prologic/circuits/issue/new
        .. _Mailing List: http://groups.google.com/group/circuits-users
        .. _Downloads page: https://bitbucket.org/prologic/circuits/downloads
        
        
        Overview
        --------
        
        circuits is a **Lightweight** **Event** driven and **Asynchronous**
        **Application Framework** for the `Python Programming Language`_
        with a strong **Component** Architecture.
        
        circuits also includes a lightweight, high performance and scalable
        HTTP/WSGI compliant web server as well as various I/O and Networking
        components.
        
        To take full advantage of circuits and its architecture, circuits
        requires that your application be designed in terms of components
        and their interactions (*events*) with each other. An application
        written using the circuits application framework is maintainable,
        scalable and easy to develop.
        
        circuits' **Loosely Coupled** **Component Architecture** allows for a
        high level of **Reuse** and **Scalability**. Components are **Componsable**
        and much of the component library that circuits ships with are implemented
        as composed components.
        
        - **Documentation**: http://packages.python.org/circuits or `Read the Docs`_.
        - **Project website**: https://bitbucket.org/prologic/circuits/
        - **PyPI page**: http://pypi.python.org/pypi/circuits
        
        
        Features
        --------
        
        - event driven
        - concurrency support
        - component archiecture
        - asynchronous I/O components
        - no required external dependencies
        - full featured web framework (circuits.web)
        - coroutine based synchronization primitives
        
        
        Requirements
        ------------
        
        - circuits has no dependencies beyond the `Python Standard Library`_.
        - Python: >= 2.6
        
        
        Installation
        ------------
        
        The simplest and recommended way to install circuits is with pip.
        You may install the latest stable release from PyPI with pip::
        
            > pip install circuits
        
        If you do not have pip, you may use easy_install::
        
            > easy_install circuits
        
        Alternatively, you may download the source package from the
        `PyPi Page`_ or the `Downloads page`_ on the
        `Website`_; extract it and install using::
        
            > python setup.py install
        
        
        License
        -------
        
        circuits is licensed under the `MIT License`_.
        
        
        Feedback
        --------
        
        Do you have suggestions for improvement? Then please `Create an Issue`_
        with details of what you would like to see. I'll take a look at it and
        work with you to either incorporate the idea or find a better solution.
        
        
        Community
        ---------
        
        There is also a small community of circuits enthusiasts that you may
        find on the `#circuits IRC Channel`_ on the `FreeNode IRC Network`
        and the `Mailing List`_.
        
        
        Release Notes - circuits-2.0.0 (cheetah)
        ----------------------------------------
        
        
        Component Initialization
        ........................
        
        Implemented ``Component.init()`` support whereby one can define an
        alternative ``init()`` without needing to remember to call ``super(...)``
        ``init()`` takes the same arguments as the normal ``__init__(...)`` constructor.
        
        Example:
        
        .. code:: python
           :number-lines:
        
           from circuits import Component
        
           class App(Component):
        
              def init(self, ...):
                 ...
        
        
        Component Singleton Support
        ...........................
        
        No. This isn't anything crazy bout restricting what you can do with components.
        This new feature allows you as a developer to restrict how many instances of
        any given component can be running in any given system.
        
        Say you defined a ``Logger`` Component but you only wanted and designed
        for only one instance ever running in a single system. This is how you do it:
        
        .. code:: python
           :number-lines:
        
           from circuits import Component
        
        
           class App(Component):
        
              singleton = True
        
        
        More Convenience for I/O Components
        ...................................
        
        
        All I/O Components now implement the ``value_changed`` Event Notification API
        allowing you to define ``read`` Event Handlers that simply return responses.
        
        Example:
        
        .. code:: python
           :number-lines:
        
           from circuits.net.sockets import TCPServer
        
        
           class EchoServer(TCPServer):
        
              def read(self, sock, data):
                 return data
        
        
           EchoServer(8000).run()
        
        
        Tick Functions are now decorators!
        ..................................
        
        
        In previous releases of circuits, a ``Component`` could only have a single
        ``__tick__`` (*Tick Function*). This restriction is now gone and we've made it
        much simpler to define new *Tick Functions* by simply using the new ``@tick``
        decorator.
        
        Example:
        
        .. code:: python
           :number-lines:
        
           from circuits import tick
        
           class MyComponent(Component):
              @tick
              def my_tick(self):
                 print 'time is passing'
        
        
        callEvent/waitEvent Enhancements
        ................................
        
        In circuits-1.6 we introduced two new primitives.
        
         - ``.callEvent(...)``
         - ``.waitEvent(...)``
        
        These two primitives introduced synchronous features to the circuits framework
        allowing you to pause the execution of an event handler and write almost
        synchronous-style code whilst remaining asynchronous in the background.
        
        Here are the list of improvements and an example to go with.
        
        - The ``.call(...)`` and ``.wait(...)`` synchronous primitives in this release
          are now implemented as co-routines using standard Python generators.
          (*Previously they were implemented using greenlets*).
        - The API are identical to that of ``fire(...)``
        - Added the ability to return values from ``callEvent``
        - Added the ability to yield from an event handler.
        
        .. code:: python
           :number-lines:
              
           class A(Component):
           
               channel = "a"
        
               def foo(self):
                   return "Hello"
           
           
           class B(Component):
           
               channel = "b"
           
               def foo(self):
                   return "World!"
           
           
           class App(Component):
           
               def hello(self):
                   a = yield self.call(Event.create("foo"), "a")
                   b = yield self.call(Event.create("foo"), "b")
                   yield "{0} {1}".format(a, b)
           
           m = Manager() + Debugger()
           A().register(m)
           B().register(m)
           App().register(m)
           m.start()
        
        
        For a full list of changes for this release see the `Change Log <http://packages.python.org/circuits/changes.html>`_.
        
Keywords: event framework distributed concurrent component asynchronous
Platform: POSIX
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Environment :: No Input/Output (Daemon)
Classifier: Environment :: Other Environment
Classifier: Environment :: Plugins
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Information Technology
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: System Administrators
Classifier: Intended Audience :: Telecommunications Industry
Classifier: License :: OSI Approved
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: Microsoft :: Windows :: Windows NT/2000
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.2
Classifier: Topic :: Adaptive Technologies
Classifier: Topic :: Communications :: Chat :: Internet Relay Chat
Classifier: Topic :: Communications :: Email :: Mail Transport Agents
Classifier: Topic :: Database
Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: System :: Clustering
Classifier: Topic :: System :: Distributed Computing
