montezuma.py

from kivy.app import App
from kivy.clock import Clock
from kivy.event import EventDispatcher
from kivy.properties import *
from kivy.uix.button import Button

def In(type):
  return None

def Out(type, *args):
	return type(*args)

class DictObject(dict):
	def __getattr__(self, name):
		return self[name]

	def __setattr__(self, name, value):
		self[name] = value

class Montezuma(App):
	def build(self):
		self.nodes = []
		self.renderable = []

		self.time = self.add(TimeNode())
		add = self.add(AddNode())
		add.wire(a=10, b=self.time.outs.value)
		clear = self.add(ClearNode())
		clear.wire(color=add.outs.output)

		Clock.schedule_once(self.tick, -1)

		return Button()

	def add(self, node):
		self.nodes.append(node)
		if node.renderable:
			self.renderable.append(node)
		return node

	def tick(self, x):
		self.time.value += 1

		for node in self.renderable:
			node.render()

		Clock.schedule_once(self.tick, -1)

class Node(EventDispatcher):
	enabled = BooleanProperty(True)
	renderable = False

	def __init__(self):
		self.outs = DictObject()

		for attr in dir(self.__class__):
			val = getattr(self.__class__, attr)
			if isinstance(val, Property):
				self.outs[attr] = (self, attr)

	def wire(self, **kwargs):
		def sub(port):
			def subupdate(_from, val):
				setattr(self, port, val)
				self.update()
			return subupdate

		for iport, oport in kwargs.items():
			if isinstance(oport, tuple):
				owner, oport = oport
				owner.bind(**{oport : sub(iport)})
			else:
				setattr(self, iport, oport)

	def update(self):
		pass

class ClearNode(Node):
	renderable = True
	color = In(NumericProperty)

	def render(self):
		print 'Clear', self.color

class CubeNode(Node):
	renderable = True

	def render(self):
		print 'Cube'

class AddNode(Node):
	a, b = In(NumericProperty), In(NumericProperty)
	output = Out(NumericProperty)

	def update(self):
		self.output = self.a + self.b

class TimeNode(Node):
	value = Out(NumericProperty, 0)

if __name__=='__main__':
	Montezuma().run()