#!/usr/bin/env python2.4

import code

class ManagedVariable:
  def get(self):
    return None

  def set(self, value):
    pass

  def delete(self):
    # Return false to stop the delete.
    return True


class ManagedEnvironment(dict):
 def managing(self, key):
   if not self.has_key(key):
     return False
   return isinstance \
     (dict.__getitem__(self, key), 
      ManagedVariable)

 def __setitem__(self, key, value):
   if self.managing(key):
     dict.__getitem__(self, key).set(value)
     return
   dict.__setitem__(self, key, value)

 def __getitem__(self, key):
   if self.managing(key):
     return dict.__getitem__(self, key).get()
   return dict.__getitem__(self, key)

 def __delitem__(self, key):
   if self.managing(key):
     if not dict.__getitem__(self, key).delete():
       return
   dict.__delitem__(self, key)


class RangedInt(ManagedVariable):
  def __init__(self, value, (low, high)):
    self.value = value
    self.low = low
    self.high = high

  def get(self):
    return self.value

  def set(self, value):
    if value < self.low:
      value = self.low
    if value > self.high:
      value = self.high
    self.value = value


class FunctionValue(ManagedVariable):
  def __init__(self, get_func = None,
               set_func = None, del_func = None):
    self.get_func = get_func
    self.set_func = set_func
    self.del_func = del_func

  def get(self):
    if self.get_func:
      return self.get_func()
    return None

  def set(self, value):
    if self.set_func:
      self.set_func(value)

  def delete(self):
    if self.del_func:
      return self.del_func()
    return True


class Constant(ManagedVariable):
  def __init__(self, value):
    self.value = value

  def get(self):
    return self.value

  def delete(self):
    return False

def dynamic(str):
  return FunctionValue(eval('lambda:' + str))

d = ManagedEnvironment()
d['RangedInt'] = RangedInt
d['FunctionValue'] = FunctionValue
d['Constant'] = Constant
d['dynamic'] = dynamic
d['ranged'] = RangedInt(1, (0, 100))
import time
d['time'] = FunctionValue(lambda: time.time())
d['constant'] = Constant(42)

code.interact(local=d)