text: import sys, inspect
  from types import FunctionType
  
  def magic():
      """
      Returns a string which represents Python code that copies instance 
      variables to their local counterparts. I.e:
          var = self.var
          var2 = self.var2
      """
      s = ""
      for var, value in inspect.getmembers(sys._getframe(1).f_locals["self"]):
          if not (var.startswith("__") and var.endswith("__")):
              s += var + " = self." + var + "\n"
      return s
      
  def outdent_lines(lines):
      """
      Removes the outer indentation on the method's source code. The extra
      indentation comes from the fact that the method is defined within a
      class and therefore has an extra level of indentation around itself.
      """
      outer_ws_count = 0
      for ch in lines[0]:
          if not ch.isspace():
              break
          outer_ws_count += 1
      return [line[outer_ws_count:] for line in lines]
          
  def insert_self_in_header(header):
      return header[0:header.find("(") + 1] + "self, " + \
          header[header.find("(") + 1:]
              
  def get_indent_string(srcline):
      """
      Determines and returns how the line passed in is indented. That 
      information is used by rework() so that it can determine how much
      indentation to use to insert lines into the source. 
      """
      indent = ""
      for ch in srcline:
          if not ch.isspace():
              break
          indent += ch
      return indent
          
  def rework(func):
      """
      rework() modifies the functions source code by first adding self 
      as the first argument in the parameter list and then adding
      'exec(magic())' as the first line of the function body. It does this
      by reading the functions source code and then creating a new modified
      function definition with exec() and then returns the new function.
      """
      srclines, line_num = inspect.getsourcelines(func)
      srclines = outdent_lines(srclines)
      dst = insert_self_in_header(srclines[0])
      if len(srclines) > 1:
          dst += get_indent_string(srclines[1]) + "exec(magic())\n"
          for line in srclines[1:]:
              dst += line
      dst += "new_func = eval(func.__name__)\n"
      exec(dst)
      return new_func
      
  class LocalVarsMC(type):
      """
      A metaclass that transform all instance methods by applying rework()
      on them all. Some of the implementation is borrowed from
      http://www.xs4all.nl/~thomas/python/conveniencytypes.py.
      """
      def __init__(self, name, bases, attrs):
          super(LocalVarsMC, self).__init__(name, bases, attrs)
          ## Creates an unbound super object
          supername = "_%s__super" % name
          if hasattr(self, supername):
              raise TypeError, "Conflicting classname " + supername
          setattr(self, supername, super(self))
          try:
              for attr, value in attrs.items():
                  if isinstance(value, FunctionType):
                      setattr(self, attr, rework(value))
          except IOError:
              print "Couldn't read source code - it wont work."
              sys.exit()
              
  class LocalsFromInstanceVars(object):
      """
      Inherit from this class to make it work.
      """
      __metaclass__ = LocalVarsMC
      
  import math
  
  ## ------- testcode ---------
      
  class Vector3d(LocalsFromInstanceVars):
      def __init__(x, y, z):
          self.x, self.y, self.z = x, y, z
          
      def length():
          return math.sqrt(x*x + y*y + z*z)
          
      def dummy(): 
          pass
          
          
  if __name__ == "__main__":    
      print "-"*20
      v = Vector3d(5, 4, 3)
      print v.length()
      v.x = 10
      print v.length()
      print v.dummy()
  