Merge remote-tracking branch 'bentley/master' into testing

bootstrap/bootstrap.py

@@ -99,6 +99,10 @@ def bootstrap():
             self.file_b = file_b
 
         def write(self, text, both=True):
+
+            if sys.version_info[0] > 2:
+                text = text.encode()
+
             self.file_a.write(text)
             if both:
                 self.file_b.write(text)
@@ -120,7 +124,7 @@ def bootstrap():
                     f.write("Dict (__hierarchy, \"%s\", %s)\n" % (primitive_class_name, primitive_class_name))
 
                     # Define all primitive functions
-                    for function, parameters in primitive_decls.iteritems():
+                    for function, parameters in list(primitive_decls.items()):
                         f.write("Node _func_signature_%s()\n" % function)
                         f.write("Node _func_params_%s()\n" % function)
                         f.write("Node _func_body_%s()\n" % function)

hybrid_server/classes/socket.xml

@@ -36,6 +36,9 @@
                         <parameter name="socket"/>
                         <parameter name="data"/>
                         <script>
+                            if sys.version_info[0] > 2:
+                                if isinstance(data, bytes):
+                                    data = data.decode()
                             self.received_data += data
                         </script>
                         <raise event="received_data"/>
@@ -128,9 +131,10 @@
                             # We support POST data only, so everything is in the data
                             try:
                                 params = dict([p.split('=') for p in data.split('&amp;')])
-                                data = {k: urllib.unquote_plus(v) for k, v in params.iteritems()}
-                            except:
-                                print("Problem receiving data in socket")
+                                data = {k: unquote_plus(v) for k, v in params.items()}
+                            except Exception as e:
+                                print("Problem receiving data in socket: ")
+                                print(str(e))
                                 data = {}
                         </script>
                         <raise event="HTTP_output" scope="narrow" target="'parent'">

hybrid_server/server.xml

@@ -8,6 +8,12 @@
         import time
         import os
         import urllib
+
+        try:
+            from urllib.parse import unquote_plus as unquote_plus
+        except Exception:
+            from urllib import unquote_plus as unquote_plus
+
         import sys
         import json
 

integration/utils.py

@@ -5,8 +5,17 @@ import os
 import sys
 import time
 import json
-import urllib
-import urllib2
+
+
+if sys.version_info[0] < 3:
+    from urllib2 import urlopen as urlopen
+    from urllib2 import Request as Request
+    from urllib import urlencode as urlencode
+else:
+    from urllib.request import urlopen as urlopen
+    from urllib.request import Request as Request
+    from urllib.parse import urlencode as urlencode
+
 import subprocess
 import signal
 import random
@@ -72,7 +81,7 @@ def kill(process):
 
 def flush_data(address, data):
     if data:
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname})), timeout=INIT_TIMEOUT).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname})), timeout=INIT_TIMEOUT).read()
     return []
 
 def start_mvc():

interface/CBD/main.py

@@ -4,12 +4,25 @@ from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 from matplotlib.figure import Figure
 
 
-from Tkinter import *
+try:
+    from Tkinter import *
+    import tkSimpleDialog
+except ImportError:
+    from tkinter import *
+    import tkinter.simpledialog as tkSimpleDialog
+
 from PIL import Image, ImageTk
-import tkSimpleDialog
 
-import urllib
-import urllib2
+
+if sys.version_info[0] < 3:
+    from urllib2 import urlopen as urlopen
+    from urllib2 import Request as Request
+    from urllib import urlencode as urlencode
+else:
+    from urllib.request import urlopen as urlopen
+    from urllib.request import Request as Request
+    from urllib.parse import urlencode as urlencode
+    
 import json
 
 import time
@@ -72,7 +85,7 @@ def poll(address):
     working_simulation = None
 
     while 1:
-        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read())
+        returnvalue = json.loads(urlopen(Request(address, urlencode({"op": "get_output", "taskname": taskname}))).read())
         print("Process " + str(returnvalue))
         if (returnvalue.startswith("AVAILABLE_ATTR_VALUE")):
             working_available_attrs.append([json.loads(returnvalue.split(" ", 1)[1]), None])
@@ -110,58 +123,58 @@ class MvLayer():
         import threading
 
         self.address = address
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
         thrd = threading.Thread(target=poll, args=[address])
         thrd.daemon = True
         thrd.start()
 
     def read_available_attributes(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"read_available_attributes"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
 
         while not available_attrs:
             time.sleep(0.1)
         return available_attrs.pop(0)
 
     def read_attribute(self, name, attr):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"read_attribute"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
 
         while not attribute:
             time.sleep(0.1)
         return attribute.pop(0)
 
     def set_attribute(self, name, attr, value):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"set_attribute"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": json.dumps(value), "taskname": taskname}))).read()
 
     def instantiate_block(self, name, block_type):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"instantiate_node"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % (block_type), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def instantiate_link(self, name, link_type, source, target):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"instantiate_association"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % (link_type), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % (source), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % (target), "taskname": taskname}))).read()
 
     def simulate(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"simulate"', "taskname": taskname}))).read()
 
     def step(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"step"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"step"', "taskname": taskname}))).read()
 
     def pause(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"pause"', "taskname": taskname}))).read()
 
     def delete(self, block):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "taskname": taskname}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"delete_element"', "taskname": taskname}))).read()
+        urlopen(Request(address, urlencode({"op": "set_input", "value": '"%s"' % (block), "taskname": taskname}))).read()
 
 def lower(value):
     return value / JUMP * JUMP

interface/HUTN/hutn_compiler/bootstrap_visitor.py

@@ -1,5 +1,5 @@
 import string
-from primitives_visitor import PrimitivesVisitor, Action
+from hutn_compiler.primitives_visitor import PrimitivesVisitor, Action
 
 class BootstrapVisitor(PrimitivesVisitor):
     def __init__(self, args):

interface/HUTN/hutn_compiler/compiler.py

@@ -1,12 +1,17 @@
-import cPickle as pickle
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle as pickle
+
 import os
 import sys
 import time
 
-from grammar_compiler_visitor import GrammarCompilerVisitor
-from hutnparser import Parser, Tree
-from meta_grammar import Grammar
-from cached_exception import CachedException
+from hutn_compiler.grammar_compiler_visitor import GrammarCompilerVisitor
+from hutn_compiler.hutnparser import Parser, Tree
+from hutn_compiler.meta_grammar import Grammar
+from hutn_compiler.cached_exception import CachedException
 import hashlib
 
 global parsers
@@ -20,6 +25,13 @@ def read(filename):
 
 def md5digest(data):
     hasher = hashlib.md5()
+    try:
+        data = data.encode('utf-8')
+    except UnicodeDecodeError:
+        pass
+    except AttributeError:
+        pass
+
     hasher.update(data)
     return hasher.hexdigest()
 
@@ -52,8 +64,8 @@ def do_parse(inputfile, grammarfile):
         if grammar is None:
             result = parser = Parser(Grammar(), hide_implicit = True).parse(read(grammarfile))
             if result['status'] != Parser.Constants.Success:
-                print 'not a valid grammar!'
-                print result
+                print('not a valid grammar!')
+                print(result)
 
             tree = result['tree']
             visitor = GrammarCompilerVisitor()
@@ -169,13 +181,13 @@ def do_compile(inputfile, grammarfile, visitors=[], include_paths = [], mode="")
         return result
 
 def main(input_file, grammar_file, mode, args=[]):
-    from prettyprint_visitor import PrettyPrintVisitor
-    from prettyprint_visitor import PrintVisitor
-    from semantics_visitor import SemanticsVisitor
-    from bootstrap_visitor import BootstrapVisitor
-    from constructors_visitor import ConstructorsVisitor
-    from model_visitor import ModelVisitor
-    from model_bootstrap_visitor import ModelBootstrapVisitor
+    from hutn_compiler.prettyprint_visitor import PrettyPrintVisitor
+    from hutn_compiler.prettyprint_visitor import PrintVisitor
+    from hutn_compiler.semantics_visitor import SemanticsVisitor
+    from hutn_compiler.bootstrap_visitor import BootstrapVisitor
+    from hutn_compiler.constructors_visitor import ConstructorsVisitor
+    from hutn_compiler.model_visitor import ModelVisitor
+    from hutn_compiler.model_bootstrap_visitor import ModelBootstrapVisitor
 
     modes = {
         "N" : [],

interface/HUTN/hutn_compiler/constructors_visitor.py

@@ -1,5 +1,10 @@
-import cPickle as pickle
-from visitor import Visitor
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle as pickle
+
+from hutn_compiler.visitor import Visitor
 
 class ConstructorsVisitor(Visitor):
     def __init__(self, args):

interface/HUTN/hutn_compiler/declare_functions_visitor.py

@@ -1,6 +1,6 @@
-import symbol_table as st
-import types_mv
-from visitor import Visitor
+import hutn_compiler.symbol_table as st
+import hutn_compiler.types_mv as types_mv
+from hutn_compiler.visitor import Visitor
 
 
 # Declare the function but do not visit its body

interface/HUTN/hutn_compiler/grammar_compiler_visitor.py

@@ -5,7 +5,7 @@ Date October 2014
 A visitor that takes a tree returned by the parser parsing a grammar
 and returns a structure that the parser can use to parse files written in that grammar
 """
-from hutnparser import * #we  import the parser for constant, and the Tree Class
+from hutn_compiler.hutnparser import * #we  import the parser for constant, and the Tree Class
 from time import time
 
 def dicToStr(dic):
@@ -79,8 +79,12 @@ class Visitor(object):
     def isToken(self,item):
         ret = False
         if isinstance(item, Tree):
-            if len(item.tail) == 1 and isinstance(item.tail[0], basestring):
-                ret = True
+            try:
+                if len(item.tail) == 1 and isinstance(item.tail[0], basestring):
+                    ret = True
+            except NameError:
+                if len(item.tail) == 1 and isinstance(item.tail[0], str):
+                    ret = True
         return ret
 
     def getTokenValue(self, item):
@@ -128,7 +132,7 @@ class GrammarCompilerVisitor(Visitor):
                     elif rule == TOKEN_COLLECTION: #part of th grammar where tokens are defined as a def or collection
                         self.visitTokens(child)
                     else:
-                        print 'Encountered unexpected rule type in grammar rule. type: ', rule
+                        print('Encountered unexpected rule type in grammar rule. type: ' + str(rule))
 
     def visitRule(self,tree):
         if self.isTree(tree):
@@ -152,7 +156,7 @@ class GrammarCompilerVisitor(Visitor):
                     elif rule == REMOVE:
                         rm = True
                     else:
-                        print 'Encountered unexpected rule type in rule definition. type: ', rule
+                        print('Encountered unexpected rule type in rule definition. type: ' + str(rule))
 
             if name and body:
                 mesg = msg
@@ -224,7 +228,7 @@ class GrammarCompilerVisitor(Visitor):
                     else:
                         rhs.append(r)
                 else:
-                    print 'Encountered unexpected rule type in tree RHS with head: ', item.head
+                    print('Encountered unexpected rule type in tree RHS with head: ' + str(item.head))
             elif self.isToken(item):
                 #print "TOKEN INNER in rule:",  tree.head, "with name", item.head, " value", self.getTokenValue(item)
                 head = item.head
@@ -239,7 +243,7 @@ class GrammarCompilerVisitor(Visitor):
                 elif head == RPAR:
                     pass #the case is here because it is legal but doesn't require any other action than LPAR
                 else:
-                    print 'Encountered unexpected Token in RHS of kind: ', head
+                    print('Encountered unexpected Token in RHS of kind: ' + str(head))
 
         if operator == '.' or operator == '|':
             rhs = [operator] + rhs
@@ -258,7 +262,7 @@ class GrammarCompilerVisitor(Visitor):
         return rhs , allowUnpack
 
     def addImplicit(self):
-        if self.implicit and self.rules.has_key('start'):
+        if self.implicit and 'start' in self.rules:
 
             t = str(time())
             t = t.replace('.','')[:-5]

interface/HUTN/hutn_compiler/hutnparser.py

@@ -26,7 +26,7 @@ import re
 
 from copy import deepcopy 
 
-from position import Position
+from hutn_compiler.position import Position
 
 line_cache = {}
 
@@ -219,7 +219,7 @@ class Parser(object):
                     if l:
                         name = elem[1:]
                         if name in l:
-                            if not l[name].has_key('hidden'):
+                            if not 'hidden' in l[name]:
                                 #this method will not override anything the user has explicitly specified in the structure
                                 #if there is already a hidden value there it will be kept even if it is not the same one
                                 #an examples use case is whitespaces vs comments:
@@ -249,7 +249,7 @@ class Parser(object):
                         rulename = item [1:]
                         if rulename in self.rules:
                             rule = self.rules[rulename]
-                            if not rule.has_key('visited') or rule['visited'] == False:
+                            if not 'visited' in rule or rule['visited'] == False:
                                 self.interleave(rule, inter)
                         else:
                             raise Exception(rulename + ' rule not found in grammar rules.')
@@ -300,7 +300,7 @@ class Parser(object):
         results = self.applyrule('@start', 0)
         if len(results) > 1:
             # Handle ambiguity
-            from prettyprint_visitor import PrettyPrintVisitor
+            from hutn_compiler.prettyprint_visitor import PrettyPrintVisitor
             for p in results:
                 print("===================================")
                 print("VISIT RESULT")
@@ -927,7 +927,7 @@ class Parser(object):
         def visit(self, tree):
             self.inner_visit(tree)
             if (self.output == 'console'):
-                print self.outputStream
+                print(self.outputStream)
 
     class PrettyPrinter(object):
         def __init__(self, output='console'):
@@ -958,7 +958,7 @@ class Parser(object):
         def visit(self, tree):
             self.inner_visit(tree)
             if (self.output == 'console'):
-                print self.outputStream
+                print(self.outputStream)
 
 class IgnorePostProcessor(object):
     def __init__(self, rules, tokens):

interface/HUTN/hutn_compiler/model_bootstrap_visitor.py

@@ -1,5 +1,5 @@
-from visitor import Visitor
-from compiler import main as do_compile
+from hutn_compiler.visitor import Visitor
+from hutn_compiler.compiler import main as do_compile
 import os
 import uuid
 
@@ -147,11 +147,11 @@ class ModelBootstrapVisitor(Visitor):
     def visit_model_attr_instance(self, tree):
         def constructors_compile(code):
             code_fragments = code.split("\n")
-	    code_fragments = [i for i in code_fragments if i.strip() != ""]
-	    code_fragments = [i.replace("    ", "\t") for i in code_fragments]
-	    initial_tabs = min([len(i) - len(i.lstrip("\t")) for i in code_fragments])
-	    code_fragments = self.includes + [i[initial_tabs:] for i in code_fragments]
-	    code = "\n".join(code_fragments)
+            code_fragments = [i for i in code_fragments if i.strip() != ""]
+            code_fragments = [i.replace("    ", "\t") for i in code_fragments]
+            initial_tabs = min([len(i) - len(i.lstrip("\t")) for i in code_fragments])
+            code_fragments = self.includes + [i[initial_tabs:] for i in code_fragments]
+            code = "\n".join(code_fragments)
             code += "\n"
 
             with open(".code.alc", 'w') as f:

interface/HUTN/hutn_compiler/model_visitor.py

@@ -1,5 +1,5 @@
-from visitor import Visitor
-from compiler import main as do_compile
+from hutn_compiler.visitor import Visitor
+from hutn_compiler.compiler import main as do_compile
 import os
 
 def empty(s):
@@ -115,11 +115,11 @@ class ModelVisitor(Visitor):
     def visit_model_attr_instance(self, tree):
         def constructors_compile(code):
             code_fragments = code.split("\n")
-	    code_fragments = [i for i in code_fragments if i.strip() != ""]
-	    code_fragments = [i.replace("    ", "\t") for i in code_fragments]
-	    initial_tabs = min([len(i) - len(i.lstrip("\t")) for i in code_fragments])
-	    code_fragments = self.includes + [i[initial_tabs:] for i in code_fragments]
-	    code = "\n".join(code_fragments)
+            code_fragments = [i for i in code_fragments if i.strip() != ""]
+            code_fragments = [i.replace("    ", "\t") for i in code_fragments]
+            initial_tabs = min([len(i) - len(i.lstrip("\t")) for i in code_fragments])
+            code_fragments = self.includes + [i[initial_tabs:] for i in code_fragments]
+            code = "\n".join(code_fragments)
             code += "\n"
 
             with open(".code.alc", 'w') as f:

interface/HUTN/hutn_compiler/prettyprint_visitor.py

@@ -1,5 +1,5 @@
-from hutnparser import Tree
-from visitor import Visitor
+from hutn_compiler.hutnparser import Tree
+from hutn_compiler.visitor import Visitor
 
 class PrintVisitor(Visitor):
     def __init__(self, args):

interface/HUTN/hutn_compiler/primitives_visitor.py

@@ -1,5 +1,5 @@
 import string
-from visitor import Visitor
+from hutn_compiler.visitor import Visitor
 import json
 
 class Action():

interface/HUTN/hutn_compiler/semantics_visitor.py

@@ -1,9 +1,9 @@
-import hutnparser as hp
-import symbol_table as st
+import hutn_compiler.hutnparser as hp
+import hutn_compiler.symbol_table as st
 import sys
-import types_mv
-from declare_functions_visitor import DeclareFunctionsVisitor
-from visitor import Visitor
+import hutn_compiler.types_mv as types_mv
+from hutn_compiler.declare_functions_visitor import DeclareFunctionsVisitor
+from hutn_compiler.visitor import Visitor
 
 
 class SemanticsVisitor(Visitor):

interface/HUTN/hutn_compiler/symbol_table.py

@@ -1,4 +1,4 @@
-import types_mv
+import hutn_compiler.types_mv as types_mv
 
 
 class Symbol(object):

interface/HUTN/hutn_compiler/visitor.py

@@ -1,4 +1,4 @@
-import symbol_table as st
+import hutn_compiler.symbol_table as st
 
 
 class Visitor(object):
@@ -33,10 +33,10 @@ class Visitor(object):
 
     @staticmethod
     def print_tree(tree):
-        from prettyprint_visitor import PrintVisitor
+        from hutn_compiler.prettyprint_visitor import PrintVisitor
         pv = PrintVisitor()
         pv.visit(tree)
-        print pv.dump()
+        print(pv.dump())
 
     # a visit_* method for each non-terminal in the grammar
     def visit_start(self, tree):

interface/HUTN/test/constructor_compilation_action_language/test_compile.py

@@ -1,5 +1,9 @@
 import unittest
-import util
+
+try:
+    import util  # needed for Python2
+except ImportError:
+    import test.constructor_compilation_action_language.util as util
 
 from hutn_compiler.compiler import main
 import json

interface/HUTN/test/grammar_action_language/test_invalids.py

@@ -1,5 +1,9 @@
 import unittest
-import util
+
+try:
+    import util  # needed for Python2
+except ImportError:
+    import test.grammar_action_language.util as util
 
 from hutn_compiler.compiler import main
 

interface/HUTN/test/grammar_action_language/test_valids.py

@@ -1,5 +1,9 @@
 import unittest
-import util
+
+try:
+    import util  # needed for Python2
+except ImportError:
+    import test.grammar_action_language.util as util
 
 from hutn_compiler.compiler import main
 

interface/HUTN/test/modelling_language/test_compile.py

@@ -1,5 +1,8 @@
 import unittest
-import util
+try:
+    import util #needed for Python2
+except ImportError:
+    import test.modelling_language.util as util
 
 from hutn_compiler.compiler import main
 import json

kernel/modelverse_jit/bytecode_interpreter.py

@@ -290,7 +290,7 @@ def interpret_bytecode_function(function_name, body_bytecode, local_arguments, k
     gc_root_node, = yield [("CN", [])]
     gc_root_edge, = yield [("CE", [task_root, gc_root_node])]
     interpreter = InterpreterState(gc_root_node, keyword_arguments)
-    for param_id, arg_node in local_arguments.items():
+    for param_id, arg_node in list(local_arguments.items()):
         yield [("CALL_ARGS", [interpreter.import_local, (param_id, arg_node)])]
 
     def __handle_return(exception):

kernel/modelverse_jit/bytecode_to_cfg.py

@@ -68,7 +68,7 @@ class AnalysisState(object):
                     has_value=False))
 
         self.root_node = self.current_block.append_definition(cfg_ir.AllocateRootNode())
-        for node_id, name in param_dict.items():
+        for node_id, name in list(param_dict.items()):
             variable = bytecode_ir.VariableNode(node_id, name)
             self.current_block.append_definition(cfg_ir.DeclareLocal(variable, self.root_node))
             param_i = self.current_block.append_definition(cfg_ir.ResolveLocal(variable))

kernel/modelverse_jit/cfg_optimization.py

@@ -69,7 +69,7 @@ def merge_blocks(entry_point):
             source.append_definition(target_def)
 
         source.flow = target.flow
-        for preds in predecessor_map.values():
+        for preds in list(predecessor_map.values()):
             if target in preds:
                 preds[preds.index(target)] = source
                 # preds.remove(target)
@@ -511,7 +511,7 @@ def elide_gc_protects(entry_point):
                         ineligible_defs.add(definition)
 
     # Elide all GC protections for definitions which are not in the `ineligible_defs` set.
-    for protected, protections in def_protections.items():
+    for protected, protections in list(def_protections.items()):
         if protected not in ineligible_defs:
             for protect_def in protections:
                 protect_def.redefine(cfg_ir.Literal(None))

kernel/modelverse_jit/cfg_ssa_construction.py

@@ -195,7 +195,7 @@ class SSAConstructionState(object):
         if self.has_sealed(block):
             return
 
-        for node_id, phi_def in self.incomplete_phis[block].items():
+        for node_id, phi_def in list(self.incomplete_phis[block].items()):
             self.add_phi_operands(node_id, phi_def)
 
         self.sealed_blocks.add(block)
@@ -251,7 +251,7 @@ class SSAConstructionState(object):
             # Find all pairs phis which are defined in the branch target block.
             applicable_pairs = [
                 (phi_def, operand_def)
-                for phi_def, operand_def in self.extra_phi_operands[block].items()
+                for phi_def, operand_def in list(self.extra_phi_operands[block].items())
                 if phi_def.block == branch.block]
 
             if len(applicable_pairs) == 0:
@@ -261,7 +261,7 @@ class SSAConstructionState(object):
             # Sort the pairs by block parameter index.
             sorted_pairs = sorted(
                 applicable_pairs,
-                key=lambda (phi_def, _): phi_def.block.parameters.index(phi_def))
+                key=lambda phi_def: phi_def[0].block.parameters.index(phi_def[0]))
 
             # Append arguments to the branch.
             for _, arg in sorted_pairs:

kernel/modelverse_jit/cfg_to_tree.py

@@ -236,16 +236,16 @@ def to_relooper_multiple_or_loop(graph_component):
         return to_relooper_loop(graph_component)
 
     next_entries = set(graph_component.entry_blocks)
-    for block_set in exclusive_entries.values():
+    for block_set in list(exclusive_entries.values()):
         for elem in block_set:
             directly_reachable = graph_component.get_directly_reachable_blocks(elem)
             directly_reachable.remove(elem)
             next_entries.update(directly_reachable)
 
-    next_entries.difference_update(exclusive_entries.keys())
+    next_entries.difference_update(list(exclusive_entries.keys()))
 
     result = MultipleLoopBlock({}, None)
-    for entry, exclusive_blocks in exclusive_entries.items():
+    for entry, exclusive_blocks in list(exclusive_entries.items()):
         other_blocks = set(graph_component.blocks)
         other_blocks.difference_update(exclusive_blocks)
         result.handled_blocks[entry] = reloop(
@@ -295,7 +295,7 @@ def find_inlinable_definitions(entry_point):
 
     # Find all definitions which are eligible for inlining.
     eligible_defs = set()
-    for definition, users in def_users.items():
+    for definition, users in list(def_users.items()):
         if len(users) == 1:
             single_user = next(iter(users))
             if def_blocks[single_user] == def_blocks[definition]:
@@ -543,7 +543,7 @@ class DependencyDefinitionScheduler(object):
         if len(self.dependency_graph) == 0:
             return None
 
-        for node in self.dependency_graph.keys():
+        for node in list(self.dependency_graph.keys()):
             if not self.has_dependents(node):
                 return node
 

kernel/modelverse_jit/intrinsics.py

@@ -486,15 +486,15 @@ def register_time_intrinsic(target_jit):
 
 def register_intrinsics(target_jit):
     """Registers all intrinsics in the module with the given JIT."""
-    for (key, value) in BINARY_INTRINSICS.items():
+    for (key, value) in list(BINARY_INTRINSICS.items()):
         target_jit.register_binary_intrinsic(key, value)
-    for (key, value) in UNARY_INTRINSICS.items():
+    for (key, value) in list(UNARY_INTRINSICS.items()):
         target_jit.register_unary_intrinsic(key, value)
-    for (key, value) in CAST_INTRINSICS.items():
+    for (key, value) in list(CAST_INTRINSICS.items()):
         target_jit.register_cast_intrinsic(key, value)
-    for (key, value) in MISC_INTRINSICS.items():
+    for (key, value) in list(MISC_INTRINSICS.items()):
         target_jit.register_intrinsic(key, value)
-    for (key, value) in MISC_CFG_INTRINSICS.items():
+    for (key, value) in list(MISC_CFG_INTRINSICS.items()):
         target_jit.register_cfg_intrinsic(key, value)
 
     register_time_intrinsic(target_jit)

kernel/modelverse_jit/jit.py

@@ -86,7 +86,7 @@ def create_function(
                 tree_ir.LoadLocalInstruction(jit_runtime.KWARGS_PARAMETER_NAME),
                 tree_ir.LiteralInstruction('task_root')),
             jit_runtime.LOCALS_EDGE_NAME))
-    for (key, val) in param_dict.items():
+    for (key, val) in list(param_dict.items()):
         arg_ptr = tree_ir.create_new_local_node(
             body_param_dict[key],
             tree_ir.LoadLocalInstruction(jit_runtime.LOCALS_NODE_NAME))
@@ -506,7 +506,7 @@ class ModelverseJit(object):
                     del self.jitted_entry_points[dep]
 
             failure_message = "%s (function '%s' at %d)" % (
-                exception.message, function_name, body_id)
+                str(exception), function_name, body_id)
             if self.jit_success_log_function is not None:
                 self.jit_success_log_function('JIT compilation failed: %s' % failure_message)
             raise JitCompilationFailedException(failure_message)
@@ -727,7 +727,7 @@ def compile_function_body_interpret(jit, function_name, body_id, task_root, head
     """Create a function that invokes the interpreter on the given function."""
     (parameter_ids, parameter_list, _), = yield [
         ("CALL_ARGS", [jit.jit_signature, (body_id,)])]
-    param_dict = dict(zip(parameter_ids, parameter_list))
+    param_dict = dict(list(zip(parameter_ids, parameter_list)))
     body_bytecode, = yield [("CALL_ARGS", [jit.jit_parse_bytecode, (body_id,)])]
     def __interpret_function(**kwargs):
         if header is not None:
@@ -737,7 +737,7 @@ def compile_function_body_interpret(jit, function_name, body_id, task_root, head
 
         local_args = {}
         inner_kwargs = dict(kwargs)
-        for param_id, name in param_dict.items():
+        for param_id, name in list(param_dict.items()):
             local_args[param_id] = inner_kwargs[name]
             del inner_kwargs[name]
 
@@ -754,8 +754,8 @@ def compile_function_body_baseline(
     """Have the baseline JIT compile the function with the given name and body id."""
     (parameter_ids, parameter_list, _), = yield [
         ("CALL_ARGS", [jit.jit_signature, (body_id,)])]
-    param_dict = dict(zip(parameter_ids, parameter_list))
-    body_param_dict = dict(zip(parameter_ids, [p + "_ptr" for p in parameter_list]))
+    param_dict = dict(list(zip(parameter_ids, parameter_list)))
+    body_param_dict = dict(list(zip(parameter_ids, [p + "_ptr" for p in parameter_list])))
     body_bytecode, = yield [("CALL_ARGS", [jit.jit_parse_bytecode, (body_id,)])]
     state = bytecode_to_tree.AnalysisState(
         jit, body_id, task_root, body_param_dict,
@@ -782,7 +782,7 @@ def compile_function_body_fast(jit, function_name, body_id, _):
     """Have the fast JIT compile the function with the given name and body id."""
     (parameter_ids, parameter_list, _), = yield [
         ("CALL_ARGS", [jit.jit_signature, (body_id,)])]
-    param_dict = dict(zip(parameter_ids, parameter_list))
+    param_dict = dict(list(zip(parameter_ids, parameter_list)))
     body_bytecode, = yield [("CALL_ARGS", [jit.jit_parse_bytecode, (body_id,)])]
     bytecode_analyzer = bytecode_to_cfg.AnalysisState(jit, function_name, param_dict)
     bytecode_analyzer.analyze(body_bytecode)

kernel/modelverse_jit/runtime.py

@@ -146,9 +146,9 @@ def interpret_function_body(body_id, named_arguments, **kwargs):
     # Put the parameters in the new stack frame's symbol table.
     (parameter_vars, parameter_names, _), = yield [
         ("CALL_ARGS", [kernel.jit.jit_signature, (body_id,)])]
-    parameter_dict = dict(zip(parameter_names, parameter_vars))
+    parameter_dict = dict(list(zip(parameter_names, parameter_vars)))
 
-    for (key, value) in named_arguments.items():
+    for (key, value) in list(named_arguments.items()):
         param_var = parameter_dict[key]
         variable, = yield [("CN", [])]
         yield [("CD", [variable, "value", value])]

kernel/modelverse_jit/source_map.py

@@ -20,7 +20,7 @@ class SourceMap(object):
     def __str__(self):
         return '\n'.join(
             ['%d: %s' % pair
-             for pair in sorted(self.lines.items(), key=lambda (key, _): key)])
+             for pair in sorted(list(self.lines.items()), key=lambda key: key[0])])
 
 class SourceMapBuilder(object):
     """A type of object that makes it easy to build source maps for hierarchical instructions."""

kernel/modelverse_jit/tree_ir.py

@@ -29,6 +29,7 @@
 # pylint: disable=I0011,W0141
 
 import modelverse_jit.source_map as source_map
+import sys
 
 PROFILING = False
 
@@ -172,7 +173,7 @@ class PythonGenerator(object):
         """Appends the given string to this code generator."""
         self.flush_state_definitions()
         self.code.append(text)
-        for _ in xrange(text.count('\n')):
+        for _ in range(text.count('\n')):
             self.source_map_builder.append_line()
 
     def append_indentation(self):
@@ -396,7 +397,7 @@ class SwitchInstruction(VoidInstruction):
     def create(self, new_children):
         """Creates a new instruction of this type from the given sequence of child instructions."""
         new_pairs = []
-        for i in xrange(len(self.conditions_and_clauses)):
+        for i in range(len(self.conditions_and_clauses)):
             new_pairs.append((new_children[2 * i], new_children[2 * i + 1]))
         return SwitchInstruction(new_pairs)
 
@@ -882,7 +883,7 @@ class DictionaryLiteralInstruction(Instruction):
     def create(self, new_children):
         """Creates a new instruction of this type from the given sequence of child instructions."""
         new_kv_pairs = []
-        for i in xrange(len(self.key_value_pairs)):
+        for i in range(len(self.key_value_pairs)):
             new_kv_pairs.append((new_children[2 * i], new_children[2 * i + 1]))
         return DictionaryLiteralInstruction(new_kv_pairs)
 
@@ -1096,10 +1097,18 @@ class VariableInstruction(Instruction):
     """A base class for instructions that access variables."""
     def __init__(self, name):
         Instruction.__init__(self)
-        if isinstance(name, str) or isinstance(name, unicode) or name is None:
-            self.name = VariableName(name)
+
+        if sys.version_info[0] < 3:
+            if isinstance(name, unicode) or isinstance(name, str) or name is None:
+                self.name = VariableName(name)
+            else:
+                self.name = name
         else:
-            self.name = name
+            if isinstance(name, str) or name is None:
+                self.name = VariableName(name)
+            else:
+                self.name = name
+
 
     def get_children(self):
         """Gets this instruction's sequence of child instructions."""
@@ -1182,10 +1191,16 @@ class TupleStoreLocalInstruction(VoidInstruction):
         tuple_lhs = []
         tuple_rhs = []
         for name, value in self.name_value_pairs:
-            if isinstance(name, str) or isinstance(name, unicode) or name is None:
-                variable = VariableName(name)
+            if sys.version_info[0] < 3:
+                if isinstance(name, unicode) or isinstance(name, str) or name is None:
+                    variable = VariableName(name)
+                else:
+                    variable = name
             else:
-                variable = name
+                if isinstance(name, str) or name is None:
+                    variable = VariableName(name)
+                else:
+                    variable = name
 
             # Retrieve the result name for the variable.
             var_result_name = code_generator.get_result_name(variable)

kernel/modelverse_kernel/compiled.py

@@ -1,5 +1,5 @@
 from modelverse_kernel.primitives import PrimitiveFinished
-import modelverse_jit.runtime as jit_runtime 
+import modelverse_jit.runtime as jit_runtime
 import time
 
 def get_superclasses(a, b, **remainder):
@@ -115,13 +115,13 @@ def dict_eq(a, b, **remainder):
     key_values = yield [("RV", [i]) for i in key_nodes]
     values = yield [("RD", [a, i]) for i in key_values]
     values = yield [("RV", [i]) for i in values]
-    a_dict = dict(zip(key_values, values))
+    a_dict = dict(list(zip(key_values, values)))
 
     key_nodes, = yield [("RDK", [b])]
     key_values = yield [("RV", [i]) for i in key_nodes]
     values = yield [("RD", [b, i]) for i in key_values]
     values = yield [("RV", [i]) for i in values]
-    b_dict = dict(zip(key_values, values))
+    b_dict = dict(list(zip(key_values, values)))
 
     result, = yield [("CNV", [a_dict == b_dict])]
     raise PrimitiveFinished(result)

kernel/modelverse_kernel/generated.py

@@ -27,7 +27,7 @@ class ModelverseKernel(object):
 			if reply is not None:
 				return self.generators[taskname][operation].send(reply)
 			else:
-				return self.generators[taskname][operation].next()
+				return next(self.generators[taskname][operation])
 		except StopIteration:
 			# Done, so remove the generator
 			del self.generators[taskname][operation]
@@ -1225,7 +1225,7 @@ class ModelverseKernel(object):
 				formals_1 =	 yield [('RE', [v[0]]) for v in outgoings]
 				dict_keys_ref = yield [('RD', [v[1], 'name']) for v in formals_1]
 				dict_keys =	 yield [('RV', [v]) for v in dict_keys_ref]
-				parameters = dict(zip(dict_keys, dict_values))
+				parameters = dict(list(zip(dict_keys, dict_values)))
 				parameters['root'] = root
 				parameters['task_root'] = task_root
 				parameters['taskname'] = taskname

kernel/modelverse_kernel/legacy.py

@@ -37,7 +37,7 @@ class ModelverseKernel(object):
             if reply is not None:
                 return self.generators[taskname][operation].send(reply)
             else:
-                return self.generators[taskname][operation].next()
+                return next(self.generators[taskname][operation])
         except StopIteration:
             # Done, so remove the generator
             del self.generators[taskname][operation]
@@ -119,7 +119,7 @@ class ModelverseKernel(object):
         formals_1 =     yield [("RE", [v[0]]) for v in outgoings]
         dict_keys_ref = yield [("RD", [v[1], "name"]) for v in formals_1]
         dict_keys =     yield [("RV", [v]) for v in dict_keys_ref]
-        parameters = dict(zip(dict_keys, dict_values))
+        parameters = dict(list(zip(dict_keys, dict_values)))
 
         parameters["root"] = self.root
         parameters["task_root"] = task_root

kernel/modelverse_kernel/main.py

@@ -196,7 +196,7 @@ class ModelverseKernel(object):
         dict_values_elem = yield [("RDN", [symbols, i]) for i in dict_keys_ref]
         dict_values = yield [("RD", [i, "value"]) for i in dict_values_elem]
 
-        parameters = dict(zip(dict_keys, dict_values))
+        parameters = dict(list(zip(dict_keys, dict_values)))
 
         parameters["root"] = self.root
         parameters["task_root"] = task_root
@@ -1093,7 +1093,8 @@ class ModelverseKernel(object):
         else:
             # No input yet, so just wait and don't advance IP or phase
             self.input_value = None
-            raise primitive_functions.SleepKernel(0.1, True)
+            ex = primitive_functions.SleepKernel(0.1, True)
+            raise ex
 
     def output_init(self, task_root):
         task_frame, =   yield [("RD", [task_root, "frame"])]

kernel/modelverse_kernel/primitives.py

@@ -1,5 +1,6 @@
 import time as python_time
 import json
+import sys
 
 class PrimitiveFinished(Exception):
     """Exception to indicate the result value of a primitive, as a return cannot be used."""
@@ -57,7 +58,7 @@ def integer_multiplication(a, b, **remainder):
 
 def integer_division(a, b, **remainder):
     a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
-    result, = yield [("CNV", [int(a_value) / b_value])]
+    result, = yield [("CNV", [int(a_value) // b_value])]
     raise PrimitiveFinished(result)
 
 def integer_lt(a, b, **remainder):
@@ -180,8 +181,14 @@ def list_insert(a, b, c, **remainder):
     a_outgoing, c_value = yield [("RO", [a]), ("RV", [c])]
     links = yield [("RD", [a, i]) for i in range(c_value, len(a_outgoing))] + \
                   [("RDE", [a, i]) for i in range(c_value, len(a_outgoing))]
-    values = links[:len(links)/2]
-    edges = links[len(links)/2:]
+
+    if sys.version_info[0] < 3:
+        values = links[:len(links)/2]
+        edges = links[len(links)/2:]
+    else:
+        values = links[:len(links) // 2]
+        edges = links[len(links) // 2:]
+
     yield [("CD", [a, c_value, b])] + \
           [("CD", [a, c_value + 1 + index, value]) for index, value in enumerate(values)] + \
           [("DE", [i]) for i in edges]
@@ -192,8 +199,14 @@ def list_delete(a, b, **remainder):
     a_outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
     links = yield [("RD", [a, i]) for i in range(b_value, len(a_outgoing))] + \
                   [("RDE", [a, i]) for i in range(b_value, len(a_outgoing))]
-    values = links[:len(links)/2]
-    edges = links[len(links)/2:]
+
+    if sys.version_info[0] < 3:
+        values = links[:len(links) / 2]
+        edges = links[len(links) / 2:]
+    else:
+        values = links[:len(links) // 2]
+        edges = links[len(links) // 2:]
+
     yield [("CD", [a, b_value + index, value]) for index, value in enumerate(values[1:])] + \
           [("DE", [i]) for i in edges]
     raise PrimitiveFinished(a)
@@ -257,12 +270,20 @@ def dict_keys(a, **remainder):
 
 def is_physical_int(a, **remainder):
     t, = yield [("RV", [a])]
-    result, = yield [("CNV", [isinstance(t, int) or isinstance(t, long)])]
+    try:
+        result, = yield [("CNV", [isinstance(t, int) or isinstance(t, long)])]
+    except NameError:
+        result, = yield [("CNV", [isinstance(t, int)])]
+
     raise PrimitiveFinished(result)
 
 def is_physical_string(a, **remainder):
     t, = yield [("RV", [a])]
-    result, = yield [("CNV", [isinstance(t, str) or isinstance(t, unicode)])]
+    try:
+        result, = yield [("CNV", [isinstance(t, str) or isinstance(t, unicode)])]
+    except NameError:
+        result, = yield [("CNV", [isinstance(t, str)])]
+
     raise PrimitiveFinished(result)
 
 def is_physical_float(a, **remainder):
@@ -359,7 +380,10 @@ def time(**remainder):
 def hash(a, **remainder):
     a_value, = yield [("RV", [a])]
     import hashlib
-    b_value = hashlib.sha512(a_value).hexdigest()
+    try:
+        b_value = hashlib.sha512(a_value).hexdigest()
+    except TypeError:
+        b_value = hashlib.sha512(a_value.encode()).hexdigest()
     b, = yield [("CNV", [b_value])]
     raise PrimitiveFinished(b)
 

kernel/mvk_server/python_runtime/event_queue.py

@@ -1,4 +1,4 @@
-from infinity import INFINITY
+from kernel.mvk_server.python_runtime.infinity import INFINITY
 
 class EventQueue(object):
     class EventQueueEntry(object):        

kernel/mvk_server/python_runtime/libs/drawing.py

@@ -7,7 +7,7 @@
  Date: 2014/08/21
 """
 
-from utils import utils
+from kernel.mvk_server.python_runtime.libs.utils import utils
 
 
 class drawing:

kernel/mvk_server/python_runtime/libs/ui.py

@@ -7,10 +7,14 @@
  Date: 2014/08/21
 """
 
-import Tkinter as tk
-from python_runtime.statecharts_core import Event
-from drawing import drawing
-from utils import utils
+try:
+	import Tkinter as tk
+except ImportError:
+	import tkinter as tk
+
+from kernel.mvk_server.python_runtime.statecharts_core import Event
+from kernel.mvk_server.python_runtime.libs.drawing import drawing
+from kernel.mvk_server.python_runtime.libs.utils import utils
 
 
 class ui:

kernel/mvk_server/python_runtime/libs/utils.py

@@ -15,5 +15,5 @@ class utils:
 			after:  d['a'] = d.a
 	"""
 	class _bunch:
-  		def __init__(self, **kwds):
- 			self.__dict__.update(kwds)
+		def __init__(self, **kwds):
+			self.__dict__.update(kwds)

kernel/mvk_server/python_runtime/statecharts_core.py

@@ -1,13 +1,17 @@
 import abc
 import re
-from accurate_time import time
+from kernel.mvk_server.python_runtime.accurate_time import time
 import threading
 import traceback
 import math
-from nextafter import nextafter
-from infinity import INFINITY
-from event_queue import EventQueue
-from Queue import Queue, Empty
+from kernel.mvk_server.python_runtime.nextafter import nextafter
+from kernel.mvk_server.python_runtime.infinity import INFINITY
+from kernel.mvk_server.python_runtime.event_queue import EventQueue
+
+try:
+	from Queue import Queue, Empty
+except ImportError:
+	from queue import Queue, Empty
 
 class RuntimeException(Exception):
 	def __init__(self, message):
@@ -504,7 +508,7 @@ class EventLoop:
 		if now - self.last_print > 1.0:
 			behind_schedule = now - simulated_now
 			if behind_schedule > 0.1:
-				print "Warning: running %.f ms behind schedule" % (behind_schedule*1000.0)
+				print("Warning: running %.f ms behind schedule" % (behind_schedule*1000.0))
 				self.last_print = now
 		if self.last_time:
 			delta = simulated_now - self.last_time
@@ -639,12 +643,12 @@ class ThreadsControllerBase(ControllerBase):
 
 	def addInput(self, input_event, time_offset = 0.0):
 		with self.input_condition:
-		    super(ThreadsControllerBase, self).addInput(input_event, time_offset)
-		    self.input_condition.notifyAll()
+			super(ThreadsControllerBase, self).addInput(input_event, time_offset)
+			self.input_condition.notifyAll()
 
 	def addEventList(self, event_list):
 		with self.input_condition:
-		    super(ThreadsControllerBase, self).addEventList(event_list)
+			super(ThreadsControllerBase, self).addEventList(event_list)
 
 class StatechartSemantics:
 	# Big Step Maximality
@@ -722,7 +726,7 @@ class RuntimeClassBase(object):
 		if not self.is_stable:
 			return 0.0
 		if self.timers:
-			return min(self.events.getEarliestTime(), min(self.timers.itervalues()))
+			return min(self.events.getEarliestTime(), min(self.timers.values()))
 		return self.events.getEarliestTime()
 
 	def processBigStepOutput(self):
@@ -740,7 +744,7 @@ class RuntimeClassBase(object):
 
 		# decrease timers time
 		next_timers = {}
-		for (key,value) in self.timers.iteritems() :
+		for (key,value) in list(self.timers.items()):
 			time = value - delta
 			if time <= 0.0 :
 				self.addEvent( Event("_" + str(key) + "after"), time)
@@ -758,7 +762,7 @@ class RuntimeClassBase(object):
 			self.processBigStepOutput()
 
 	def inState(self, nodes):
-		for c in self.current_state.itervalues():
+		for c in list(self.current_state.values()):
 			new_nodes = []
 			for n in nodes:
 				if not (n in c):

kernel/mvk_server/python_runtime/tkinter_eventloop.py

@@ -1,4 +1,4 @@
-from statecharts_core import EventLoop
+from kernel.mvk_server.python_runtime.statecharts_core import EventLoop
 import math
 
 class TkEventLoop(EventLoop):

kernel/mvk_server/python_sccd_compiler/generic_generator.py

@@ -7,12 +7,12 @@
 import traceback
 
 import time
-from utils import Enum, Logger
+from kernel.mvk_server.python_sccd_compiler.utils import Enum, Logger
 
-from visitor import Visitor
-from sccd_constructs import FormalParameter
-from stateful_writer import StatefulWriter
-import generic_language_constructs as GLC
+from kernel.mvk_server.python_sccd_compiler.visitor import Visitor
+from kernel.mvk_server.python_sccd_compiler.sccd_constructs import FormalParameter
+from kernel.mvk_server.python_sccd_compiler.stateful_writer import StatefulWriter
+import kernel.mvk_server.python_sccd_compiler.generic_language_constructs as GLC
 
 Platforms = Enum("Threads","GameLoop","EventLoop") 
 

kernel/mvk_server/python_sccd_compiler/generic_language_constructs.py

@@ -720,9 +720,15 @@ class NoneExpression(SimpleExpression):
 # helpers
 
 def MakeExpression(expr):
+
+	try:
+		bs = basestring
+	except NameError:
+		bs = str
+
 	if isinstance(expr, Expression):
 		return expr
-	elif isinstance(expr, basestring):
+	elif isinstance(expr, bs):
 		return Literal(expr)
 	elif expr is None:
 		return None
@@ -739,7 +745,7 @@ def MakeExpressionList(l):
 def MakeExpressionMap(m):
 	if not isinstance(m, dict):
 		raise Exception("Expected argument of type 'dict'.")
-	for key in m.keys():
+	for key in list(m.keys()):
 		m[key] = MakeExpression(m[key])
 	return m
 

kernel/mvk_server/python_sccd_compiler/javascript_writer.py

@@ -1,5 +1,5 @@
-from visitor import Visitor
-from generic_language_constructs import *
+from kernel.mvk_server.python_sccd_compiler.visitor import Visitor
+from kernel.mvk_server.python_sccd_compiler.generic_language_constructs import *
 
 class JavascriptWriter(CLikeWriterBase):
 	def __init__(self, outputter):
@@ -155,7 +155,7 @@ class JavascriptWriter(CLikeWriterBase):
 			self.out.extendWrite("new Object()")
 		else:
 			self.out.extendWrite("{")
-			keys = elements.keys()
+			keys = list(elements.keys())
 			for i in range(len(keys)):
 				if i != 0:
 					self.out.extendWrite(", ")			

kernel/mvk_server/python_sccd_compiler/lexer.py

@@ -1,4 +1,4 @@
-from utils import Enum
+from kernel.mvk_server.python_sccd_compiler.utils import Enum
 
 TokenType = Enum("SLASH",
 				 "LBRACKET",

kernel/mvk_server/python_sccd_compiler/path_calculator.py

@@ -1,5 +1,5 @@
-from compiler_exceptions import *
-from visitor import Visitor
+from kernel.mvk_server.python_sccd_compiler.compiler_exceptions import *
+from kernel.mvk_server.python_sccd_compiler.visitor import Visitor
 
 class PathCalculator(Visitor):
 	""" Computes the states that must be exited and entered for a specific transition if the system is to make

kernel/mvk_server/python_sccd_compiler/python_writer.py

@@ -1,4 +1,4 @@
-from generic_language_constructs import *
+from kernel.mvk_server.python_sccd_compiler.generic_language_constructs import *
 
 class PythonWriter(GenericWriterBase):
 	def __init__(self, outputter):
@@ -201,7 +201,7 @@ class PythonWriter(GenericWriterBase):
 	def visit_MapExpression(self, m):
 		elements = m.getElements()
 		self.out.extendWrite("{")
-		keys = elements.keys()
+		keys = list(elements.keys())
 		for i in range(len(keys)):
 			if i != 0:
 				self.out.extendWrite(", ")			

kernel/mvk_server/python_sccd_compiler/sccd_constructs.py

@@ -2,10 +2,10 @@ import abc
 import re
 import xml.etree.ElementTree as ET
 import os.path
-from utils import Logger
-from visitor import Visitable
-from compiler_exceptions import CompilerException, TransitionException, UnprocessedException
-from lexer import Lexer, Token, TokenType
+from kernel.mvk_server.python_sccd_compiler.utils import Logger
+from kernel.mvk_server.python_sccd_compiler.visitor import Visitable
+from kernel.mvk_server.python_sccd_compiler.compiler_exceptions import CompilerException, TransitionException, UnprocessedException
+from kernel.mvk_server.python_sccd_compiler.lexer import Lexer, Token, TokenType
 
 # http://docs.python.org/2/library/xml.etree.elementtree.html
 
@@ -847,7 +847,11 @@ class Class(Visitable):
 		for i in inheritances :
 			self.super_classes.append((i.get("class",""),i.get("priority",1)))
 
-		self.super_classes.sort(lambda a, b: cmp(b[1], a[1])) # sort from high priority to low priority
+		try:
+			self.super_classes.sort(lambda a, b: cmp(b[1], a[1]))  # sort from high priority to low priority
+		except TypeError:
+			self.super_classes = sorted(self.super_classes, key = lambda x: x[1], reverse = True)
+
 		priorityChecker = {}
 		for super_class, priority in self.super_classes:
 			if priority in priorityChecker:
@@ -857,7 +861,7 @@ class Class(Visitable):
 			if super_class not in checkIt:
 				checkIt.append(super_class)
 			priorityChecker[priority] = checkIt
-		for priority, checkIt in priorityChecker.iteritems():
+		for priority, checkIt in list(priorityChecker.items()):
 			if len(checkIt) > 1:
 				Logger.showWarning("Class <" + self.name + "> inherits from classes <" + ", ".join(checkIt) + "> with same priority <" + str(priority) + ">. Document inheritance order is used.")
 

kernel/mvk_server/python_sccd_compiler/sccdc.py

@@ -1,17 +1,17 @@
 import argparse
 import os
 import sys
-from generic_generator import GenericGenerator, Platforms
-from utils import Enum, Logger, FileWriter
-from super_class_linker import SuperClassLinker
-from state_linker import StateLinker
-from path_calculator import PathCalculator
-from sccd_constructs import ClassDiagram
-from generic_language_constructs import GenericConstruct
-from compiler_exceptions import CompilerException
+from kernel.mvk_server.python_sccd_compiler.generic_generator import GenericGenerator, Platforms
+from kernel.mvk_server.python_sccd_compiler.utils import Enum, Logger, FileWriter
+from kernel.mvk_server.python_sccd_compiler.super_class_linker import SuperClassLinker
+from kernel.mvk_server.python_sccd_compiler.state_linker import StateLinker
+from kernel.mvk_server.python_sccd_compiler.path_calculator import PathCalculator
+from kernel.mvk_server.python_sccd_compiler.sccd_constructs import ClassDiagram
+from kernel.mvk_server.python_sccd_compiler.generic_language_constructs import GenericConstruct
+from kernel.mvk_server.python_sccd_compiler.compiler_exceptions import CompilerException
 
-from javascript_writer import JavascriptWriter
-from python_writer import PythonWriter
+from kernel.mvk_server.python_sccd_compiler.javascript_writer import JavascriptWriter
+from kernel.mvk_server.python_sccd_compiler.python_writer import PythonWriter
 
 def generate(input_file, output_file, target_language, platform):
 	sccd = xmlToSccd(input_file)

kernel/mvk_server/python_sccd_compiler/state_linker.py

@@ -1,7 +1,7 @@
-from visitor import Visitor
-from sccd_constructs import INSTATE_SEQ
-from compiler_exceptions import CompilerException
-from lexer import Lexer, Token, TokenType
+from kernel.mvk_server.python_sccd_compiler.visitor import Visitor
+from kernel.mvk_server.python_sccd_compiler.sccd_constructs import INSTATE_SEQ
+from kernel.mvk_server.python_sccd_compiler.compiler_exceptions import CompilerException
+from kernel.mvk_server.python_sccd_compiler.lexer import Lexer, Token, TokenType
 
 class StateReferenceException(CompilerException):
 	pass

kernel/mvk_server/python_sccd_compiler/stateful_writer.py

@@ -1,7 +1,7 @@
 # Used by generic_generator to create an AST of generic language constructs
 # while visiting an AST of SCCD constructs
 
-from generic_language_constructs import *
+from kernel.mvk_server.python_sccd_compiler.generic_language_constructs import *
 
 class ExpressionWrapper(SimpleExpression, AbstractList):
 	def __init__(self, expr = None):

kernel/mvk_server/python_sccd_compiler/super_class_linker.py

@@ -1,6 +1,6 @@
-from compiler_exceptions import *
-from utils import Logger
-from visitor import Visitor
+from kernel.mvk_server.python_sccd_compiler.compiler_exceptions import *
+from kernel.mvk_server.python_sccd_compiler.utils import Logger
+from kernel.mvk_server.python_sccd_compiler.visitor import Visitor
 
 class SuperClassLinker(Visitor):
 	""" Computes the states that must be exited and entered for a specific transition if the system is to make
@@ -27,7 +27,7 @@ class SuperClassLinker(Visitor):
 		c.abstract_method_names = getClassAbstractMethodNames(c)
 
 		# check if <super> tags exist for all inherited classes
-		for name,obj in c.super_class_objs.iteritems():
+		for name,obj in list(c.super_class_objs.items()):
 			if obj:
 				if name not in c.constructors[0].super_class_parameters:
 					num_params = len(obj.constructors[0].parameters)

kernel/mvk_server/python_sccd_compiler/utils.py

@@ -1,4 +1,4 @@
-from compiler_exceptions import CodeBlockException
+from kernel.mvk_server.python_sccd_compiler.compiler_exceptions import CodeBlockException
 from sys import stdout
 
 class Logger(object):
@@ -10,17 +10,17 @@ class Logger(object):
 	@staticmethod   
 	def showError(error):
 		if(Logger.verbose > -1) :
-			print "ERROR : " + error
+			print("ERROR : " + error)
 				
 	@staticmethod
 	def showWarning(warning):
 		if(Logger.verbose > 0) :
-			print "WARNING : " + warning
+			print("WARNING : " + warning)
 			
 	@staticmethod	
 	def showInfo(info):
 		if(Logger.verbose > 1) :
-			print "INFO : " + info
+			print("INFO : " + info)
 
 #######################
 

kernel/test/instructions/test_instruction_access.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref
+from test.instructions.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref
 
 class Testaccess(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_assign.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref, get_inst_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref, get_inst_ref
 
 class TestAssign(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_break.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
 
 class TestBreak(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_call.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref
 
 class Testcall(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_continue.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
 
 class Testcontinue(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_declare.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
 
 class TestDeclare(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_if.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
 
 class Testif(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_input.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue_ref
 
 class TestInput(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_output.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue_ref
 
 class TestOutput(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_resolve.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref, get_inst_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref, get_inst_ref
 
 class Testresolve(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_return.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
 
 class Testreturn(unittest.TestCase):
     def setUp(self):

kernel/test/instructions/test_instruction_while.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue
 
 class Testwhile(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_action.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
 
 class TestAction(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_bool.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
 
 class TestBool(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_cast.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
 
 class TestCast(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_create.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestCreate(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_delete.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestDelete(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_dict.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestDict(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_dict_special.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestDictSpecials(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_edge.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestEdge(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_element.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
 
 class TestType(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_float.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
 
 class TestInteger(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_integer.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces
 
 class TestInteger(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_list.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestList(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_read.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestRead(unittest.TestCase):
     def setUp(self):

kernel/test/primitives/test_string.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
+from test.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_returnvalue_ref
 
 class TestString(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_access.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testaccess(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_assign.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class TestAssign(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_break.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testbreak(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_call.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testcall(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_constant.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testconstant(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_continue.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testcontinue(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_helper.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class TestHelper(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_if.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testif(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_input.py

@@ -1,7 +1,7 @@
 import unittest
 from modelverse_kernel.primitives import SleepKernel
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class TestInput(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_output.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class TestOutput(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_resolve.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testresolve(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_return.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testreturn(unittest.TestCase):
     def setUp(self):

kernel/test/rules/test_rules_while.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper
+from test.utils import execute_until_finished, MvSWrapper
 
 class Testwhile(unittest.TestCase):
     def setUp(self):

kernel/test_generated/instructions/test_instruction_access.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.generated import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref
+from test_generated.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref
 
 class Testaccess(unittest.TestCase):
     def setUp(self):

kernel/test_generated/instructions/test_instruction_assign.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.generated import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref, get_inst_ref
+from test_generated.utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_returnvalue_ref, get_inst_ref
 
 class TestAssign(unittest.TestCase):
     def setUp(self):