Simple Reactive Demo | Python Fiddle

"""
This is a minimalistic reactive programming model using Python.
Author: Kenny Goh Kar Hong
"""

import random
import pprint
import time

# TODO: Dependency graph for executing the expressions eg. D = A , A = B + C => { ( A = B + C ), ( A = D ) }
# TODO: Parser for the expressions eg. ( A = B + C ) => 
# TODO: A variable should not have more than one dependency eg. A = B, A = C
# TODO: Error management 
# TODO: Proper Python Idioms

# Figure a way to convert ( (= D C), (= C (+ A B ) ) ) to (= D (= C (+ A B) ) )
#
#
#

class Calculator(object):    
    """ A simple calculator that update rows of data based on the 
        defined formulas.
    """
    def __init__(self, rows, debug=False):
        self._rows = rows
        self._exprs = []
        self._debug = debug
        
    def add_expr(self,expr):
		self._exprs.append(expr)  
    
    def sort_dependencies(self):
        """ 
        """
        for each in self._exprs:
            pass
        
    def solve(self):
        """
        """
        start = time.clock()
        for e in self._exprs:
            for r in self._rows:
                e.eval(r)
        elapsed = time.clock() - start
        if self._debug:
            print("Calculator.Solve() elapsed time:", elapsed)

class DependencyGraph(object):
    """ (= D (= C (+ A B) ) )
    """
    def __init__(self):
        self.left = None
        self.right = None
        self.data = None
                  
class Node(object):
    """ Represents an atomic part of an expression. 
    """
    def __init__(self):
        pass  
    
    def eval(self,row):
        pass    
    
class GetCellNode(Node):  
    """ Represents a get cell operation
    """
    def __init__(self,column):
    	self._column = column   
        
    def eval(self,row):
    	return row[self._column] 
    
    def __repr__(self):
        return self._column
    
class SetCellNode(Node):
    """ Represents a set cell operation
    """
    def __init__(self,target,value):
    	self._target = target
        self._value = value
        
    def eval(self,row):
        row[self._target] = self._value.eval(row)   
        return row[self._target]
    
    def __repr__(self):
        return self._target + '=' + repr(self._value)
        
    
class AddNode(Node):
    """ Represents an addition operation
    """
    def __init__(self,a,b):
        self._a = a
        self._b = b
        
    def eval(self,row):
        return self._a.eval(row) + self._b.eval(row)
    
    def __repr__(self):
        return repr(self._a) + '+' + repr(self._b) 
    
    
    
rows = []

c = Calculator(rows, debug=True)

c.add_expr( SetCellNode('D', GetCellNode('C') ) )  
c.add_expr( SetCellNode('C', AddNode( GetCellNode('A'), GetCellNode('B'))))

print c._exprs
        
for i in range(0,100):
	rows.append( { 'A':random.randint(1, 1000), 
                   'B':random.randint(1, 1000), 
                   'C':0,
                   'D':0,} )  
    
c.solve()

pp = pprint.PrettyPrinter(indent=4)
pp.pprint(rows)

Python Fiddle

Python Cloud IDE