Add support for python 2.7

Author: arneboockmeyer

.idea/active-expressions-static-python.iml

@@ -43,7 +43,7 @@
     }
    ],
    "source": [
-    "class BankAccount:\n",
+    "class BankAccount(object):\n",
     "    def __init__(self):\n",
     "        self.balance = 0\n",
     "        \n",
@@ -92,12 +92,12 @@
     }
    ],
    "source": [
-    "class Point:\n",
+    "class Point(object):\n",
     "    def __init__(self, x, y):\n",
     "        self.x = x\n",
     "        self.y = y\n",
     "\n",
-    "class Rect:\n",
+    "class Rect(object):\n",
     "    def __init__(self, point1, point2):\n",
     "        self.point1 = point1\n",
     "        self.point2 = point2\n",
@@ -139,7 +139,7 @@
     }
    ],
    "source": [
-    "class Example:\n",
+    "class Example(object):\n",
     "    def __init__(self):\n",
     "        self.f = 5\n",
     "        self.g = 10\n",
@@ -225,7 +225,7 @@
     }
    ],
    "source": [
-    "class MoreExamples:\n",
+    "class MoreExamples(object):\n",
     "    def __init__(self):\n",
     "        self.f = 5\n",
     "        self.g = 6\n",

.idea/encodings.xml

@@ -4,10 +4,11 @@ Active Expression Implementation for Python using static-byte-code analysis.
 
 ## Installation
 
-To use Active Expression you need at least Python 3.4.
+To use Active Expression you need at least Python 2.7 (earlier version may be supported but not tested) or Python 3.4.
 To install the package, you can run the following command:
 
 ```
+pip install git+https://github.com/active-expressions/active-expressions-static-python
 pip3 install git+https://github.com/active-expressions/active-expressions-static-python
 ```
 
@@ -28,7 +29,7 @@ Afterwards you can use the method `aexpr` in your program.
 For the following example lets assume we have the following class:
 
 ```
-class Example:
+class Example(object):
     def __init__(self):
         self.f = 5
 ```
@@ -75,7 +76,7 @@ Dependencies of an expression are in this case all fields which are used in the
 **Example** (from the [presentation](https://github.com/active-expressions/active-expressions-static-python/blob/master/presentation/presentation.pdf)):
 
 ```
-class Example:
+class Example(object):
   def __init__(self):
     self.f = 5
     self.g = 10

.idea/misc.xml

@@ -1,6 +1,11 @@
 import dis
 from collections import deque
 import inspect
+import re
+import sys
+if sys.version_info < (3, .0):
+    from StringIO import StringIO
+
 
 class ExpressionReaction:
     """An Expression Reaction object will be called when a change is detected.
@@ -43,10 +48,19 @@ def is_placeholder(self):
     def is_build_in(self):
         return self.buildin
 
+def is_new_style(cls):
+    """Checks if a class is a new style class.
+    See: https://stackoverflow.com/questions/2654622/identifying-that-a-variable-is-a-new-style-class-in-python"""
+    return hasattr(cls, '__class__') and ('__dict__' in dir(cls) or hasattr(cls, '__slots__'))
+
+
 def placeaexpr(obj, attr_name, expression_reaction_object):
     """placeaexpr will be called by the byte-code analysis
     when an instrumentable attribute is found."""
 
+    if not is_new_style(obj):
+        raise ValueError('You have to use new style classes')
+
     if not hasattr(obj, '__listenon__'):
         if not hasattr(type(obj), "__aexprhandler__"):
             original = type(obj).__setattr__
@@ -201,7 +215,7 @@ def call_function_handler(inst, iq, os, vm):
                 for i in range(inst.argval, 0, -1):
                     localvars[params.args[i]] = func_args[i-1]
 
-                os.append(process_function(func.__code__, wrapper.base_obj, localvars))
+                os.append(process_function(func, wrapper.base_obj, localvars))
         else:
             os.append(ObjectWrapper(placeholder=True))
 
@@ -220,7 +234,7 @@ def get_obj_from_wrapper(wrapper, inst):
             print("Warning: Access to Placeholder isn't supported (Instruction: " + str(inst) + ")")
         return wrapper.obj
 
-    def process_function(function_code, self, localvars=None):
+    def process_function(function, self, localvars=None):
         instruction_queue = deque()
         object_stack = []
         variable_mapping = {}
@@ -233,7 +247,16 @@ def process_function(function_code, self, localvars=None):
         if "self" not in variable_mapping:
             variable_mapping["self"] = ObjectWrapper(obj=self)
 
-        instruction_queue.extend(dis.get_instructions(function_code))
+        if sys.version_info > (3, 0):
+            instruction_queue.extend(dis.get_instructions(function.__code__))
+        else:
+            old_stdout = sys.stdout
+            result = StringIO()
+            sys.stdout = result
+            dis.dis(function)
+            sys.stdout = old_stdout
+            result_string = result.getvalue()
+            instruction_queue.extend([Instruction.get_instruction_from_string(s) for s in result_string.splitlines()])
 
         while instruction_queue:
             inst = instruction_queue.popleft()
@@ -244,6 +267,26 @@ def process_function(function_code, self, localvars=None):
                 raise UnimplementedInstructionException("Unimplemented Instruction: " + str(inst))
         return object_stack.pop()
 
-    process_function(lambda_expression.__code__, None, localvars)
+    process_function(lambda_expression, None, localvars)
 
     return expression_reaction_object
+
+class Instruction:
+    def __init__(self, opcode, argval):
+        self.opcode = opcode
+        self.argval = argval
+
+    def __str__(self):
+        return str(self.opcode) + " " + str(self.argval)
+
+    @staticmethod
+    def get_instruction_from_string(line):
+        splits = line.strip().split("(")
+        value = ""
+        if len(splits) == 2:  # Has a value
+            value = splits[1].replace(")", "")
+        instruction = re.sub(r"\d", "", splits[0]).strip()
+        if instruction not in dis.opmap:
+            return None
+        opcode = dis.opmap[instruction]
+        return Instruction(opcode, value)