circuits 2.0.0

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:

1 from circuits import Component
2 
3 class App(Component):
4 
5    def init(self, ...):
6       ...

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:

1 from circuits import Component
2 
3 
4 class App(Component):
5 
6    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:

 1 from circuits.net.sockets import TCPServer
 2 
 3 
 4 class EchoServer(TCPServer):
 5 
 6    def read(self, sock, data):
 7       return data
 8 
 9 
10 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:

1 from circuits import tick
2 
3 class MyComponent(Component):
4    @tick
5    def my_tick(self):
6       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.

 1 class A(Component):
 2 
 3     channel = "a"
 4 
 5     def foo(self):
 6         return "Hello"
 7 
 8 
 9 class B(Component):
10 
11     channel = "b"
12 
13     def foo(self):
14         return "World!"
15 
16 
17 class App(Component):
18 
19     def hello(self):
20         a = yield self.call(Event.create("foo"), "a")
21         b = yield self.call(Event.create("foo"), "b")
22         yield "{0} {1}".format(a, b)
23 
24 m = Manager() + Debugger()
25 A().register(m)
26 B().register(m)
27 App().register(m)
28 m.start()

For a full list of changes for this release see the Change Log.