summaryrefslogtreecommitdiff
path: root/dynamic
diff options
context:
space:
mode:
Diffstat (limited to 'dynamic')
-rw-r--r--dynamic/__init__.py100
-rw-r--r--dynamic/pg_encoder.py377
-rw-r--r--dynamic/pg_logger.py1591
3 files changed, 2068 insertions, 0 deletions
diff --git a/dynamic/__init__.py b/dynamic/__init__.py
new file mode 100644
index 0000000..54ae03c
--- /dev/null
+++ b/dynamic/__init__.py
@@ -0,0 +1,100 @@
+""" This file contains functions for extraction dynamical patterns from
+Python code. """
+
+import collections
+from collections import defaultdict
+import json
+
+from .pg_logger import exec_script_str_local
+
+def extract_vars(state):
+ """ Extract active variables from a state. """
+ if 'globals' not in state:
+ return {}
+ variables = state['globals'].copy()
+ for stack in state['stack_to_render']:
+ for name, value in stack['encoded_locals'].items():
+ variables["{}({})".format(name, stack['func_name'])] = value
+ return variables
+
+def finalizer(input_code, output_trace):
+ """ Creates time series from extracted traces. """
+ active_vars = {}
+ var_counter = defaultdict(int)
+ var_vals = defaultdict(list)
+
+ for state_i, state in enumerate(output_trace):
+ line = state.get('line', -1)
+ trace_vars = extract_vars(state)
+
+ # remove inactive vars
+ active_vars = {k:v for k, v in active_vars.items() if k in trace_vars}
+
+ # add new vars to active vars
+ for var in (trace_vars.keys() - active_vars.keys()):
+ var_counter[var] += 1
+ active_vars[var] = "{}_{}".format(var, var_counter[var])
+
+ # add new values to value lists
+ for cur_name, global_name in active_vars.items():
+ # get value (from heap if reference is given)
+ value = trace_vars[cur_name]
+ if value and isinstance(value, list) and value[0] == "REF":
+ value = state["heap"][value[1]]
+ # add to list if new value
+ if global_name not in var_vals or var_vals[global_name][-1][2] != value:
+ var_vals[global_name].append((state_i, line, value))
+
+ # remove variables that had only one value
+ for key in set(var_vals.keys()):
+ if len(var_vals[key]) <= 1:
+ del var_vals[key]
+ return dict(code=input_code, trace=output_trace, series=var_vals)
+
+def following_pairs_patterns(trace_data):
+ series = trace_data['series']
+ for se, val in series.items():
+ for v1, v2 in zip(val, val[1:]):
+ yield "[{}]:[{}]".format(v1[2], v2[2])
+
+def get_trace_data(code, call=None, inputs=None):
+ if call:
+ code += '\n\n' + call
+ if inputs:
+ inputs = json.dumps(inputs)
+ return exec_script_str_local(code, inputs, False, False, finalizer)
+
+def get_attributes(programs, call, inputs):
+ patterns = collections.defaultdict(list)
+ for program in programs:
+ print(program)
+ trace = get_trace_data(program, call, inputs)
+ for pat in following_pairs_patterns(trace):
+ patterns[pat] += [program]
+
+ attrs = collections.OrderedDict()
+ for pat, progs in sorted(patterns.items(), key=lambda x: len(x[1]), reverse=True):
+ if len(progs) < 5:
+ break
+ attrs['dynamic-{}'.format(len(attrs))] = {'desc': pat, 'programs': progs}
+
+ return attrs
+
+if __name__ == '__main__':
+ script = """
+def add(a, b):
+ m = a * b
+ m += a / b
+ m -= a % b
+ return m
+
+s = 0
+for i in range(1, 10):
+ for j in range(1, 10):
+ s += add(i, j)
+print(s)
+"""
+ trace_data = get_trace_data(script)
+ for p in following_pairs_patterns(trace_data):
+ print(p)
+
diff --git a/dynamic/pg_encoder.py b/dynamic/pg_encoder.py
new file mode 100644
index 0000000..7cf0c8e
--- /dev/null
+++ b/dynamic/pg_encoder.py
@@ -0,0 +1,377 @@
+# Online Python Tutor
+# https://github.com/pgbovine/OnlinePythonTutor/
+#
+# Copyright (C) Philip J. Guo (philip@pgbovine.net)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Thanks to John DeNero for making the encoder work on both Python 2 and 3
+
+
+# Given an arbitrary piece of Python data, encode it in such a manner
+# that it can be later encoded into JSON.
+# http://json.org/
+#
+# We use this function to encode run-time traces of data structures
+# to send to the front-end.
+#
+# Format:
+# Primitives:
+# * None, int, long, float, str, bool - unchanged
+# (json.dumps encodes these fine verbatim, except for inf, -inf, and nan)
+#
+# exceptions: float('inf') -> ['SPECIAL_FLOAT', 'Infinity']
+# float('-inf') -> ['SPECIAL_FLOAT', '-Infinity']
+# float('nan') -> ['SPECIAL_FLOAT', 'NaN']
+# x == int(x) -> ['SPECIAL_FLOAT', '%.1f' % x]
+# (this way, 3.0 prints as '3.0' and not as 3, which looks like an int)
+#
+# If render_heap_primitives is True, then primitive values are rendered
+# on the heap as ['HEAP_PRIMITIVE', <type name>, <value>]
+#
+# (for SPECIAL_FLOAT values, <value> is a list like ['SPECIAL_FLOAT', 'Infinity'])
+#
+# Compound objects:
+# * list - ['LIST', elt1, elt2, elt3, ..., eltN]
+# * tuple - ['TUPLE', elt1, elt2, elt3, ..., eltN]
+# * set - ['SET', elt1, elt2, elt3, ..., eltN]
+# * dict - ['DICT', [key1, value1], [key2, value2], ..., [keyN, valueN]]
+# * instance - ['INSTANCE', class name, [attr1, value1], [attr2, value2], ..., [attrN, valueN]]
+# * instance with __str__ defined - ['INSTANCE_PPRINT', class name, <__str__ value>]
+# * class - ['CLASS', class name, [list of superclass names], [attr1, value1], [attr2, value2], ..., [attrN, valueN]]
+# * function - ['FUNCTION', function name, parent frame ID (for nested functions)]
+# * module - ['module', module name]
+# * other - [<type name>, string representation of object]
+# * compound object reference - ['REF', target object's unique_id]
+#
+# the unique_id is derived from id(), which allows us to capture aliasing
+
+
+# number of significant digits for floats
+FLOAT_PRECISION = 4
+
+
+from collections import defaultdict
+import re, types
+import sys
+import math
+typeRE = re.compile("<type '(.*)'>")
+classRE = re.compile("<class '(.*)'>")
+
+import inspect
+
+# TODO: maybe use the 'six' library to smooth over Py2 and Py3 incompatibilities?
+is_python3 = (sys.version_info[0] == 3)
+if is_python3:
+ # avoid name errors (GROSS!)
+ long = int
+ unicode = str
+
+
+def is_class(dat):
+ """Return whether dat is a class."""
+ if is_python3:
+ return isinstance(dat, type)
+ else:
+ return type(dat) in (types.ClassType, types.TypeType)
+
+
+def is_instance(dat):
+ """Return whether dat is an instance of a class."""
+ if is_python3:
+ return type(dat) not in PRIMITIVE_TYPES and \
+ isinstance(type(dat), type) and \
+ not isinstance(dat, type)
+ else:
+ # ugh, classRE match is a bit of a hack :(
+ return type(dat) == types.InstanceType or classRE.match(str(type(dat)))
+
+
+def get_name(obj):
+ """Return the name of an object."""
+ return obj.__name__ if hasattr(obj, '__name__') else get_name(type(obj))
+
+
+PRIMITIVE_TYPES = (int, long, float, str, unicode, bool, type(None))
+
+def encode_primitive(dat):
+ t = type(dat)
+ if t is float:
+ if math.isinf(dat):
+ if dat > 0:
+ return ['SPECIAL_FLOAT', 'Infinity']
+ else:
+ return ['SPECIAL_FLOAT', '-Infinity']
+ elif math.isnan(dat):
+ return ['SPECIAL_FLOAT', 'NaN']
+ else:
+ # render floats like 3.0 as '3.0' and not as 3
+ if dat == int(dat):
+ return ['SPECIAL_FLOAT', '%.1f' % dat]
+ else:
+ return round(dat, FLOAT_PRECISION)
+ elif t is str and (not is_python3):
+ # hack only for Python 2 strings ... always turn into unicode
+ # and display '?' when it's not valid unicode
+ return dat.decode('utf-8', 'replace')
+ else:
+ # return all other primitives verbatim
+ return dat
+
+
+# grab a line number like ' <line 2>' or ' <line 2b>'
+def create_lambda_line_number(codeobj, line_to_lambda_code):
+ try:
+ lambda_lineno = codeobj.co_firstlineno
+ lst = line_to_lambda_code[lambda_lineno]
+ ind = lst.index(codeobj)
+ # add a suffix for all subsequent lambdas on a line beyond the first
+ # (nix this for now because order isn't guaranteed when you have
+ # multiple lambdas on the same line)
+ '''
+ if ind > 0:
+ lineno_str = str(lambda_lineno) + chr(ord('a') + ind)
+ else:
+ lineno_str = str(lambda_lineno)
+ '''
+ lineno_str = str(lambda_lineno)
+ return ' <line ' + lineno_str + '>'
+ except:
+ return ''
+
+
+# Note that this might BLOAT MEMORY CONSUMPTION since we're holding on
+# to every reference ever created by the program without ever releasing
+# anything!
+class ObjectEncoder:
+ def __init__(self, render_heap_primitives):
+ # Key: canonicalized small ID
+ # Value: encoded (compound) heap object
+ self.encoded_heap_objects = {}
+
+ self.render_heap_primitives = render_heap_primitives
+
+ self.id_to_small_IDs = {}
+ self.cur_small_ID = 1
+
+ # wow, creating unique identifiers for lambdas is quite annoying,
+ # especially if we want to properly differentiate:
+ # 1.) multiple lambdas defined on the same line, and
+ # 2.) the same lambda code defined multiple times on different lines
+ #
+ # However, it gets confused when there are multiple identical
+ # lambdas on the same line, like:
+ # f(lambda x:x*x, lambda y:y*y, lambda x:x*x)
+
+ # (assumes everything is in one file)
+ # Key: line number
+ # Value: list of the code objects of lambdas defined
+ # on that line in the order they were defined
+ self.line_to_lambda_code = defaultdict(list)
+
+
+ def get_heap(self):
+ return self.encoded_heap_objects
+
+
+ def reset_heap(self):
+ # VERY IMPORTANT to reassign to an empty dict rather than just
+ # clearing the existing dict, since get_heap() could have been
+ # called earlier to return a reference to a previous heap state
+ self.encoded_heap_objects = {}
+
+ def set_function_parent_frame_ID(self, ref_obj, enclosing_frame_id):
+ assert ref_obj[0] == 'REF'
+ func_obj = self.encoded_heap_objects[ref_obj[1]]
+ assert func_obj[0] == 'FUNCTION'
+ func_obj[-1] = enclosing_frame_id
+
+
+ # return either a primitive object or an object reference;
+ # and as a side effect, update encoded_heap_objects
+ def encode(self, dat, get_parent):
+ """Encode a data value DAT using the GET_PARENT function for parent ids."""
+ # primitive type
+ if not self.render_heap_primitives and type(dat) in PRIMITIVE_TYPES:
+ return encode_primitive(dat)
+ # compound type - return an object reference and update encoded_heap_objects
+ else:
+ my_id = id(dat)
+
+ try:
+ my_small_id = self.id_to_small_IDs[my_id]
+ except KeyError:
+ my_small_id = self.cur_small_ID
+ self.id_to_small_IDs[my_id] = self.cur_small_ID
+ self.cur_small_ID += 1
+
+ del my_id # to prevent bugs later in this function
+
+ ret = ['REF', my_small_id]
+
+ # punt early if you've already encoded this object
+ if my_small_id in self.encoded_heap_objects:
+ return ret
+
+
+ # major side-effect!
+ new_obj = []
+ self.encoded_heap_objects[my_small_id] = new_obj
+
+ typ = type(dat)
+
+ if typ == list:
+ new_obj.append('LIST')
+ for e in dat:
+ new_obj.append(self.encode(e, get_parent))
+ elif typ == tuple:
+ new_obj.append('TUPLE')
+ for e in dat:
+ new_obj.append(self.encode(e, get_parent))
+ elif typ == set:
+ new_obj.append('SET')
+ for e in dat:
+ new_obj.append(self.encode(e, get_parent))
+ elif typ == dict:
+ new_obj.append('DICT')
+ for (k, v) in dat.items():
+ # don't display some built-in locals ...
+ if k not in ('__module__', '__return__', '__locals__'):
+ new_obj.append([self.encode(k, get_parent), self.encode(v, get_parent)])
+ elif typ in (types.FunctionType, types.MethodType):
+ if is_python3:
+ argspec = inspect.getfullargspec(dat)
+ else:
+ argspec = inspect.getargspec(dat)
+
+ printed_args = [e for e in argspec.args]
+ if argspec.varargs:
+ printed_args.append('*' + argspec.varargs)
+
+ if is_python3:
+ if argspec.varkw:
+ printed_args.append('**' + argspec.varkw)
+ if argspec.kwonlyargs:
+ printed_args.extend(argspec.kwonlyargs)
+ else:
+ if argspec.keywords:
+ printed_args.append('**' + argspec.keywords)
+
+ func_name = get_name(dat)
+
+ pretty_name = func_name
+
+ # sometimes might fail for, say, <genexpr>, so just ignore
+ # failures for now ...
+ try:
+ pretty_name += '(' + ', '.join(printed_args) + ')'
+ except TypeError:
+ pass
+
+ # put a line number suffix on lambdas to more uniquely identify
+ # them, since they don't have names
+ if func_name == '<lambda>':
+ cod = (dat.__code__ if is_python3 else dat.func_code) # ugh!
+ lst = self.line_to_lambda_code[cod.co_firstlineno]
+ if cod not in lst:
+ lst.append(cod)
+ pretty_name += create_lambda_line_number(cod,
+ self.line_to_lambda_code)
+
+ encoded_val = ['FUNCTION', pretty_name, None]
+ if get_parent:
+ enclosing_frame_id = get_parent(dat)
+ encoded_val[2] = enclosing_frame_id
+ new_obj.extend(encoded_val)
+ elif typ is types.BuiltinFunctionType:
+ pretty_name = get_name(dat) + '(...)'
+ new_obj.extend(['FUNCTION', pretty_name, None])
+ elif is_class(dat) or is_instance(dat):
+ self.encode_class_or_instance(dat, new_obj)
+ elif typ is types.ModuleType:
+ new_obj.extend(['module', dat.__name__])
+ elif typ in PRIMITIVE_TYPES:
+ assert self.render_heap_primitives
+ new_obj.extend(['HEAP_PRIMITIVE', type(dat).__name__, encode_primitive(dat)])
+ else:
+ typeStr = str(typ)
+ m = typeRE.match(typeStr)
+
+ if not m:
+ m = classRE.match(typeStr)
+
+ assert m, typ
+
+ if is_python3:
+ encoded_dat = str(dat)
+ else:
+ # ugh, for bytearray() in Python 2, str() returns
+ # non-JSON-serializable characters, so need to decode:
+ encoded_dat = str(dat).decode('utf-8', 'replace')
+ new_obj.extend([m.group(1), encoded_dat])
+
+ return ret
+
+
+ def encode_class_or_instance(self, dat, new_obj):
+ """Encode dat as a class or instance."""
+ if is_instance(dat):
+ if hasattr(dat, '__class__'):
+ # common case ...
+ class_name = get_name(dat.__class__)
+ else:
+ # super special case for something like
+ # "from datetime import datetime_CAPI" in Python 3.2,
+ # which is some weird 'PyCapsule' type ...
+ # http://docs.python.org/release/3.1.5/c-api/capsule.html
+ class_name = get_name(type(dat))
+
+ if hasattr(dat, '__str__') and \
+ (not dat.__class__.__str__ is object.__str__): # make sure it's not the lame default __str__
+ # N.B.: when objects are being constructed, this call
+ # might fail since not all fields have yet been populated
+ try:
+ pprint_str = str(dat)
+ except:
+ pprint_str = '<incomplete object>'
+
+ new_obj.extend(['INSTANCE_PPRINT', class_name, pprint_str])
+ return # bail early
+ else:
+ new_obj.extend(['INSTANCE', class_name])
+ # don't traverse inside modules, or else risk EXPLODING the visualization
+ if class_name == 'module':
+ return
+ else:
+ superclass_names = [e.__name__ for e in dat.__bases__ if e is not object]
+ new_obj.extend(['CLASS', get_name(dat), superclass_names])
+
+ # traverse inside of its __dict__ to grab attributes
+ # (filter out useless-seeming ones, based on anecdotal observation):
+ hidden = ('__doc__', '__module__', '__return__', '__dict__',
+ '__locals__', '__weakref__', '__qualname__')
+ if hasattr(dat, '__dict__'):
+ user_attrs = sorted([e for e in dat.__dict__ if e not in hidden])
+ else:
+ user_attrs = []
+
+ for attr in user_attrs:
+ new_obj.append([self.encode(attr, None), self.encode(dat.__dict__[attr], None)])
+
diff --git a/dynamic/pg_logger.py b/dynamic/pg_logger.py
new file mode 100644
index 0000000..07289e3
--- /dev/null
+++ b/dynamic/pg_logger.py
@@ -0,0 +1,1591 @@
+# Online Python Tutor
+# https://github.com/pgbovine/OnlinePythonTutor/
+#
+# Copyright (C) Philip J. Guo (philip@pgbovine.net)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+# This is the meat of the Online Python Tutor back-end. It implements a
+# full logger for Python program execution (based on pdb, the standard
+# Python debugger imported via the bdb module), printing out the values
+# of all in-scope data structures after each executed instruction.
+
+
+import imp
+import sys
+import bdb # the KEY import here!
+import re
+import traceback
+import types
+
+# TODO: use the 'six' package to smooth out Py2 and Py3 differences
+is_python3 = (sys.version_info[0] == 3)
+
+# NB: don't use cStringIO since it doesn't support unicode!!!
+if is_python3:
+ import io as StringIO
+ import io # expose regular io for Python3 users too
+else:
+ import StringIO
+from . import pg_encoder
+
+
+# TODO: not threadsafe:
+
+# upper-bound on the number of executed lines, in order to guard against
+# infinite loops
+#MAX_EXECUTED_LINES = 300
+MAX_EXECUTED_LINES = 10000 # on 2016-05-01, I increased the limit from 300 to 1000 for Python due to popular user demand! and I also improved the warning message
+
+#DEBUG = False
+DEBUG = True
+
+BREAKPOINT_STR = '#break'
+
+CLASS_RE = re.compile('class\s+')
+
+
+# simple sandboxing scheme:
+#
+# - use resource.setrlimit to deprive this process of ANY file descriptors
+# (which will cause file read/write and subprocess shell launches to fail)
+# - restrict user builtins and module imports
+# (beware that this is NOT foolproof at all ... there are known flaws!)
+#
+# ALWAYS use defense-in-depth and don't just rely on these simple mechanisms
+try:
+ import resource
+ resource_module_loaded = True
+except ImportError:
+ # Google App Engine doesn't seem to have the 'resource' module
+ resource_module_loaded = False
+
+
+# From http://coreygoldberg.blogspot.com/2009/05/python-redirect-or-turn-off-stdout-and.html
+class NullDevice():
+ def write(self, s):
+ pass
+
+
+# These could lead to XSS or other code injection attacks, so be careful:
+# these are now deprecated as of 2016-06-28
+__html__ = None
+def setHTML(htmlStr):
+ global __html__
+ __html__ = htmlStr
+
+__css__ = None
+def setCSS(cssStr):
+ global __css__
+ __css__ = cssStr
+
+__js__ = None
+def setJS(jsStr):
+ global __js__
+ __js__ = jsStr
+
+
+# ugh, I can't figure out why in Python 2, __builtins__ seems to
+# be a dict, but in Python 3, __builtins__ seems to be a module,
+# so just handle both cases ... UGLY!
+if type(__builtins__) is dict:
+ BUILTIN_IMPORT = __builtins__['__import__']
+else:
+ assert type(__builtins__) is types.ModuleType
+ BUILTIN_IMPORT = __builtins__.__import__
+
+
+# whitelist of module imports
+ALLOWED_STDLIB_MODULE_IMPORTS = ('math', 'random', 'time', 'datetime',
+ 'functools', 'itertools', 'operator', 'string',
+ 'collections', 're', 'json',
+ 'heapq', 'bisect', 'copy', 'hashlib')
+
+# allow users to import but don't explicitly import it since it's
+# already been done above
+OTHER_STDLIB_WHITELIST = ('StringIO', 'io')
+
+# TODO: 2017-01-14: this CUSTOM_MODULE_IMPORTS thing is now DEPRECATED ...
+# whitelist of custom modules to import into OPT
+# (TODO: support modules in a subdirectory, but there are various
+# logistical problems with doing so that I can't overcome at the moment,
+# especially getting setHTML, setCSS, and setJS to work in the imported
+# modules.)
+CUSTOM_MODULE_IMPORTS = () # ignore these for now
+# ('callback_module',
+# 'ttt_module',
+# 'html_module',
+# 'htmlexample_module',
+# ignore these troublesome imports for now
+# 'watch_module', # 'import sys' might be troublesome
+# 'bintree_module',
+# 'GChartWrapper',
+# 'matrix',
+# 'htmlFrame')
+
+
+# PREEMPTIVELY import all of these modules, so that when the user's
+# script imports them, it won't try to do a file read (since they've
+# already been imported and cached in memory). Remember that when
+# the user's code runs, resource.setrlimit(resource.RLIMIT_NOFILE, (0, 0))
+# will already be in effect, so no more files can be opened.
+#
+# NB: All modules in CUSTOM_MODULE_IMPORTS will be imported, warts and
+# all, so they better work on Python 2 and 3!
+for m in ALLOWED_STDLIB_MODULE_IMPORTS + CUSTOM_MODULE_IMPORTS:
+ __import__(m)
+
+
+# Restrict imports to a whitelist
+def __restricted_import__(*args):
+ # filter args to ONLY take in real strings so that someone can't
+ # subclass str and bypass the 'in' test on the next line
+ args = [e for e in args if type(e) is str]
+
+ if args[0] in ALLOWED_STDLIB_MODULE_IMPORTS + CUSTOM_MODULE_IMPORTS + OTHER_STDLIB_WHITELIST:
+ imported_mod = BUILTIN_IMPORT(*args)
+
+ if args[0] in CUSTOM_MODULE_IMPORTS:
+ # add special magical functions to custom imported modules
+ setattr(imported_mod, 'setHTML', setHTML)
+ setattr(imported_mod, 'setCSS', setCSS)
+ setattr(imported_mod, 'setJS', setJS)
+
+ # somewhat weak protection against imported modules that contain one
+ # of these troublesome builtins. again, NOTHING is foolproof ...
+ # just more defense in depth :)
+ for mod in ('os', 'sys', 'posix', 'gc'):
+ if hasattr(imported_mod, mod):
+ delattr(imported_mod, mod)
+
+ return imported_mod
+ else:
+ raise ImportError('{0} not supported'.format(args[0]))
+
+
+# Support interactive user input by:
+#
+# 1. running the entire program up to a call to raw_input (or input in py3),
+# 2. bailing and returning a trace ending in a special 'raw_input' event,
+# 3. letting the web frontend issue a prompt to the user to grab a string,
+# 4. RE-RUNNING the whole program with that string added to input_string_queue,
+# 5. which should bring execution to the next raw_input call (if
+# available), or to termination.
+# Repeat until no more raw_input calls are encountered.
+# Note that this is mad inefficient, but is simple to implement!
+
+# VERY IMPORTANT -- set random seed to 0 to ensure deterministic execution:
+import random
+random.seed(0)
+
+# queue of input strings passed from either raw_input or mouse_input
+input_string_queue = []
+
+
+def open_wrapper(*args):
+ if is_python3:
+ raise Exception('''open() is not supported by Python Tutor.
+Instead use io.StringIO() to simulate a file.
+Here is an example: http://goo.gl/uNvBGl''')
+ else:
+ raise Exception('''open() is not supported by Python Tutor.
+Instead use StringIO.StringIO() to simulate a file.
+Here is an example: http://goo.gl/Q9xQ4p''')
+
+# create a more sensible error message for unsupported features
+def create_banned_builtins_wrapper(fn_name):
+ def err_func(*args):
+ raise Exception("'" + fn_name + "' is not supported by Python Tutor.")
+ return err_func
+
+
+class RawInputException(Exception):
+ pass
+
+def raw_input_wrapper(prompt=''):
+ if input_string_queue:
+ input_str = input_string_queue.pop(0)
+
+ # write the prompt and user input to stdout, to emulate what happens
+ # at the terminal
+ sys.stdout.write(str(prompt)) # always convert prompt into a string
+ sys.stdout.write(input_str + "\n") # newline to simulate the user hitting Enter
+ return input_str
+ raise RawInputException(str(prompt)) # always convert prompt into a string
+
+
+# Python 2 input() does eval(raw_input())
+def python2_input_wrapper(prompt=''):
+ if input_string_queue:
+ input_str = input_string_queue.pop(0)
+
+ # write the prompt and user input to stdout, to emulate what happens
+ # at the terminal
+ sys.stdout.write(str(prompt)) # always convert prompt into a string
+ sys.stdout.write(input_str + "\n") # newline to simulate the user hitting Enter
+ return eval(input_str) # remember to eval!
+ raise RawInputException(str(prompt)) # always convert prompt into a string
+
+class MouseInputException(Exception):
+ pass
+
+def mouse_input_wrapper(prompt=''):
+ if input_string_queue:
+ return input_string_queue.pop(0)
+ raise MouseInputException(prompt)
+
+
+
+# blacklist of builtins
+BANNED_BUILTINS = ['reload', 'open', 'compile',
+ 'file', 'eval', 'exec', 'execfile',
+ 'exit', 'quit', 'help',
+ 'dir', 'globals', 'locals', 'vars']
+# Peter says 'apply' isn't dangerous, so don't ban it
+
+IGNORE_VARS = set(('__builtins__', '__name__', '__exception__', '__doc__', '__package__'))
+
+
+'''
+2013-12-26
+
+Okay, what's with this f_valuestack business?
+
+If you compile your own CPython and patch Objects/frameobject.c to add a
+Python accessor for f_valuestack, then you can actually access the value
+stack, which is useful for, say, grabbbing the objects within
+list/set/dict comprehensions as they're being built. e.g., try:
+
+ z = [x*y for x in range(5) for y in range(5)]
+
+Note that on pythontutor.com, I am currently running custom-compiled
+versions of Python-2.7.6 and Python-3.3.3 with this f_valuestack hack.
+Unless you run your own custom CPython, you won't get these benefits.
+
+
+Patch:
+
+ static PyObject *
+ frame_getlineno(PyFrameObject *f, void *closure)
+ {
+ return PyLong_FromLong(PyFrame_GetLineNumber(f));
+ }
+
++// copied from Py2crazy, which was for Python 2, but let's hope this still works!
++static PyObject *
++frame_getvaluestack(PyFrameObject* f) {
++ // pgbovine - TODO: will this memory leak? hopefully not,
++ // since all other accessors seem to follow the same idiom
++ PyObject* lst = PyList_New(0);
++ if (f->f_stacktop != NULL) {
++ PyObject** p = NULL;
++ for (p = f->f_valuestack; p < f->f_stacktop; p++) {
++ PyList_Append(lst, *p);
++ }
++ }
++
++ return lst;
++}
++
+ /* Setter for f_lineno - you can set f_lineno from within a trace function in
+ * order to jump to a given line of code, subject to some restrictions. Most
+ * lines are OK to jump to because they don't make any assumptions about the
+@@ -368,6 +384,11 @@
+
+ static PyGetSetDef frame_getsetlist[] = {
+ {"f_locals", (getter)frame_getlocals, NULL, NULL},
+ {"f_lineno", (getter)frame_getlineno,
+ (setter)frame_setlineno, NULL},
+ {"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL},
++
++ // pgbovine
++ {"f_valuestack",(getter)frame_getvaluestack,
++ (setter)NULL /* don't let it be set */, NULL},
++
+ {0}
+ };
+'''
+
+# at_global_scope should be true only if 'frame' represents the global scope
+def get_user_globals(frame, at_global_scope=False):
+ d = filter_var_dict(frame.f_globals)
+
+ # don't blurt out all of f_valuestack for now ...
+ '''
+ if at_global_scope and hasattr(frame, 'f_valuestack'):
+ for (i, e) in enumerate(frame.f_valuestack):
+ d['_tmp' + str(i+1)] = e
+ '''
+
+ # print out list objects being built up in Python 2.x list comprehensions
+ # (which don't have its own special <listcomp> frame, sadly)
+ if not is_python3 and hasattr(frame, 'f_valuestack'):
+ for (i, e) in enumerate([e for e in frame.f_valuestack if type(e) is list]):
+ d['_tmp' + str(i+1)] = e
+
+ # also filter out __return__ for globals only, but NOT for locals
+ if '__return__' in d:
+ del d['__return__']
+ return d
+
+def get_user_locals(frame):
+ ret = filter_var_dict(frame.f_locals)
+ # don't blurt out all of f_valuestack for now ...
+ '''
+ if hasattr(frame, 'f_valuestack'):
+ for (i, e) in enumerate(frame.f_valuestack):
+ ret['_tmp' + str(i+1)] = e
+ '''
+
+ # special printing of list/set/dict comprehension objects as they are
+ # being built up incrementally ...
+ f_name = frame.f_code.co_name
+ if hasattr(frame, 'f_valuestack'):
+ # print out list objects being built up in Python 2.x list comprehensions
+ # (which don't have its own special <listcomp> frame, sadly)
+ if not is_python3:
+ for (i, e) in enumerate([e for e in frame.f_valuestack
+ if type(e) is list]):
+ ret['_tmp' + str(i+1)] = e
+
+ # for dict and set comprehensions, which have their own frames:
+ if f_name.endswith('comp>'):
+ for (i, e) in enumerate([e for e in frame.f_valuestack
+ if type(e) in (list, set, dict)]):
+ ret['_tmp' + str(i+1)] = e
+
+ return ret
+
+def filter_var_dict(d):
+ ret = {}
+ for (k,v) in d.items():
+ if k not in IGNORE_VARS:
+ ret[k] = v
+ return ret
+
+
+# yield all function objects locally-reachable from frame,
+# making sure to traverse inside all compound objects ...
+def visit_all_locally_reachable_function_objs(frame):
+ for (k, v) in get_user_locals(frame).items():
+ for e in visit_function_obj(v, set()):
+ if e: # only non-null if it's a function object
+ assert type(e) in (types.FunctionType, types.MethodType)
+ yield e
+
+
+# TODO: this might be slow if we're traversing inside lots of objects:
+def visit_function_obj(v, ids_seen_set):
+ v_id = id(v)
+
+ # to prevent infinite loop
+ if v_id in ids_seen_set:
+ yield None
+ else:
+ ids_seen_set.add(v_id)
+
+ typ = type(v)
+
+ # simple base case
+ if typ in (types.FunctionType, types.MethodType):
+ yield v
+
+ # recursive cases
+ elif typ in (list, tuple, set):
+ for child in v:
+ for child_res in visit_function_obj(child, ids_seen_set):
+ yield child_res
+
+ elif typ == dict or pg_encoder.is_class(v) or pg_encoder.is_instance(v):
+ contents_dict = None
+
+ if typ == dict:
+ contents_dict = v
+ # warning: some classes or instances don't have __dict__ attributes
+ elif hasattr(v, '__dict__'):
+ contents_dict = v.__dict__
+
+ if contents_dict:
+ for (key_child, val_child) in contents_dict.items():
+ for key_child_res in visit_function_obj(key_child, ids_seen_set):
+ yield key_child_res
+ for val_child_res in visit_function_obj(val_child, ids_seen_set):
+ yield val_child_res
+
+ # degenerate base case
+ yield None
+
+
+class PGLogger(bdb.Bdb):
+ # if custom_modules is non-empty, it should be a dict mapping module
+ # names to the python source code of each module. when _runscript is
+ # called, it will do "from <module> import *" for all modules in
+ # custom_modules before running the user's script and then trace all
+ # code within custom_modules
+ #
+ # if separate_stdout_by_module, then have a separate stdout stream
+ # for each module rather than all stdout going to a single stream
+ def __init__(self, cumulative_mode, heap_primitives, show_only_outputs, finalizer_func,
+ disable_security_checks=False, crazy_mode=False,
+ custom_modules=None, separate_stdout_by_module=False, probe_exprs=None):
+ bdb.Bdb.__init__(self)
+ self.mainpyfile = ''
+ self._wait_for_mainpyfile = 0
+
+ if probe_exprs:
+ self.probe_exprs = probe_exprs
+ else:
+ self.probe_exprs = None
+
+ self.separate_stdout_by_module = separate_stdout_by_module
+ self.stdout_by_module = {} # Key: module name, Value: StringIO faux-stdout
+
+ self.modules_to_trace = set(['__main__']) # always trace __main__!
+
+ # Key: module name
+ # Value: module's python code as a string
+ self.custom_modules = custom_modules
+ if self.custom_modules:
+ for module_name in self.custom_modules:
+ self.modules_to_trace.add(module_name)
+
+ self.disable_security_checks = disable_security_checks
+
+ # if True, then displays ALL stack frames that have ever existed
+ # rather than only those currently on the stack (and their
+ # lexical parents)
+ self.cumulative_mode = cumulative_mode
+
+ # if True, then render certain primitive objects as heap objects
+ self.render_heap_primitives = heap_primitives
+
+ # if True, then don't render any data structures in the trace,
+ # and show only outputs
+ self.show_only_outputs = show_only_outputs
+
+ # Run using the custom Py2crazy Python interpreter
+ self.crazy_mode = crazy_mode
+
+ # a function that takes the output trace as a parameter and
+ # processes it
+ self.finalizer_func = finalizer_func
+
+ # each entry contains a dict with the information for a single
+ # executed line
+ self.trace = []
+
+ # if this is true, don't put any more stuff into self.trace
+ self.done = False
+
+ # if this is non-null, don't do any more tracing until a
+ # 'return' instruction with a stack gotten from
+ # get_stack_code_IDs() that matches wait_for_return_stack
+ self.wait_for_return_stack = None
+
+ #http://stackoverflow.com/questions/2112396/in-python-in-google-app-engine-how-do-you-capture-output-produced-by-the-print
+ self.GAE_STDOUT = sys.stdout
+
+ # Key: function object
+ # Value: parent frame
+ self.closures = {}
+
+ # Key: code object for a lambda
+ # Value: parent frame
+ self.lambda_closures = {}
+
+ # set of function objects that were defined in the global scope
+ self.globally_defined_funcs = set()
+
+ # Key: frame object
+ # Value: monotonically increasing small ID, based on call order
+ self.frame_ordered_ids = {}
+ self.cur_frame_id = 1
+
+ # List of frames to KEEP AROUND after the function exits.
+ # If cumulative_mode is True, then keep ALL frames in
+ # zombie_frames; otherwise keep only frames where
+ # nested functions were defined within them.
+ self.zombie_frames = []
+
+ # set of elements within zombie_frames that are also
+ # LEXICAL PARENTS of other frames
+ self.parent_frames_set = set()
+
+ # all globals that ever appeared in the program, in the order in
+ # which they appeared. note that this might be a superset of all
+ # the globals that exist at any particular execution point,
+ # since globals might have been deleted (using, say, 'del')
+ self.all_globals_in_order = []
+
+ # very important for this single object to persist throughout
+ # execution, or else canonical small IDs won't be consistent.
+ self.encoder = pg_encoder.ObjectEncoder(self.render_heap_primitives)
+
+ self.executed_script = None # Python script to be executed!
+
+ # if there is at least one line that ends with BREAKPOINT_STR,
+ # then activate "breakpoint mode", where execution should stop
+ # ONLY at breakpoint lines.
+ self.breakpoints = []
+
+ self.prev_lineno = -1 # keep track of previous line just executed
+
+
+ def get_user_stdout(self):
+ def encode_stringio(sio):
+ # This is SUPER KRAZY! In Python 2, the buflist inside of a StringIO
+ # instance can be made up of both str and unicode, so we need to convert
+ # the str to unicode and replace invalid characters with the Unicode '?'
+ # But leave unicode elements alone. This way, EVERYTHING inside buflist
+ # will be unicode. (Note that in Python 3, everything is already unicode,
+ # so we're fine.)
+ if not is_python3:
+ sio.buflist = [(e.decode('utf-8', 'replace')
+ if type(e) is str
+ else e)
+ for e in sio.buflist]
+ return sio.getvalue()
+
+ if self.separate_stdout_by_module:
+ ret = {}
+ for module_name in self.stdout_by_module:
+ ret[module_name] = encode_stringio(self.stdout_by_module[module_name])
+ return ret
+ else:
+ # common case - single stdout stream
+ return encode_stringio(self.user_stdout)
+
+
+ def get_frame_id(self, cur_frame):
+ return self.frame_ordered_ids[cur_frame]
+
+ # Returns the (lexical) parent of a function value.
+ def get_parent_of_function(self, val):
+ if val in self.closures:
+ return self.get_frame_id(self.closures[val])
+ elif val in self.lambda_closures:
+ return self.get_frame_id(self.lambda_closures[val])
+ else:
+ return None
+
+
+ # Returns the (lexical) parent frame of the function that was called
+ # to create the stack frame 'frame'.
+ #
+ # OKAY, this is a SUPER hack, but I don't see a way around it
+ # since it's impossible to tell exactly which function
+ # ('closure') object was called to create 'frame'.
+ #
+ # The Python interpreter doesn't maintain this information,
+ # so unless we hack the interpreter, we will simply have
+ # to make an educated guess based on the contents of local
+ # variables inherited from possible parent frame candidates.
+ def get_parent_frame(self, frame):
+ #print >> sys.stderr, 'get_parent_frame: frame.f_code', frame.f_code
+ for (func_obj, parent_frame) in self.closures.items():
+ # ok, there's a possible match, but let's compare the
+ # local variables in parent_frame to those of frame
+ # to make sure. this is a hack that happens to work because in
+ # Python, each stack frame inherits ('inlines') a copy of the
+ # variables from its (lexical) parent frame.
+ if func_obj.__code__ == frame.f_code:
+ all_matched = True
+ for k in frame.f_locals:
+ # Do not try to match local names
+ if k in frame.f_code.co_varnames:
+ continue
+ if k != '__return__' and k in parent_frame.f_locals:
+ if parent_frame.f_locals[k] != frame.f_locals[k]:
+ all_matched = False
+ break
+
+ if all_matched:
+ return parent_frame
+
+ for (lambda_code_obj, parent_frame) in self.lambda_closures.items():
+ if lambda_code_obj == frame.f_code:
+ # TODO: should we do more verification like above?!?
+ return parent_frame
+
+ return None
+
+
+ def lookup_zombie_frame_by_id(self, frame_id):
+ # TODO: kinda inefficient
+ for e in self.zombie_frames:
+ if self.get_frame_id(e) == frame_id:
+ return e
+ assert False # should never get here
+
+
+ # unused ...
+ #def reset(self):
+ # bdb.Bdb.reset(self)
+ # self.forget()
+
+
+ def forget(self):
+ self.lineno = None
+ self.stack = []
+ self.curindex = 0
+ self.curframe = None
+
+ def setup(self, f, t):
+ self.forget()
+ self.stack, self.curindex = self.get_stack(f, t)
+ self.curframe = self.stack[self.curindex][0]
+
+ # should be a reasonably unique ID to match calls and returns:
+ def get_stack_code_IDs(self):
+ return [id(e[0].f_code) for e in self.stack]
+
+
+ # Override Bdb methods
+
+ def user_call(self, frame, argument_list):
+ """This method is called when there is the remote possibility
+ that we ever need to stop in this function."""
+ # TODO: figure out a way to move this down to 'def interaction'
+ # or right before self.trace.append ...
+ if self.done: return
+
+ if self._wait_for_mainpyfile:
+ return
+ if self.stop_here(frame):
+ # delete __return__ so that on subsequent calls to
+ # a generator function, the OLD yielded (returned)
+ # value gets deleted from the frame ...
+ try:
+ del frame.f_locals['__return__']
+ except KeyError:
+ pass
+
+ self.interaction(frame, None, 'call')
+
+ def user_line(self, frame):
+ """This function is called when we stop or break at this line."""
+ if self.done: return
+
+ if self._wait_for_mainpyfile:
+ if ((frame.f_globals['__name__'] not in self.modules_to_trace) or
+ frame.f_lineno <= 0):
+ # older code:
+ #if (self.canonic(frame.f_code.co_filename) != "<string>" or
+ # frame.f_lineno <= 0):
+ return
+ self._wait_for_mainpyfile = 0
+ self.interaction(frame, None, 'step_line')
+
+ def user_return(self, frame, return_value):
+ """This function is called when a return trap is set here."""
+ if self.done: return
+
+ frame.f_locals['__return__'] = return_value
+ self.interaction(frame, None, 'return')
+
+ def user_exception(self, frame, exc_info):
+ """This function is called if an exception occurs,
+ but only if we are to stop at or just below this level."""
+ if self.done: return
+
+ exc_type, exc_value, exc_traceback = exc_info
+ frame.f_locals['__exception__'] = exc_type, exc_value
+ if type(exc_type) == type(''):
+ exc_type_name = exc_type
+ else: exc_type_name = exc_type.__name__
+
+ if exc_type_name == 'RawInputException':
+ raw_input_arg = str(exc_value.args[0]) # make sure it's a string so it's JSON serializable!
+ self.trace.append(dict(event='raw_input', prompt=raw_input_arg))
+ self.done = True
+ elif exc_type_name == 'MouseInputException':
+ mouse_input_arg = str(exc_value.args[0]) # make sure it's a string so it's JSON serializable!
+ self.trace.append(dict(event='mouse_input', prompt=mouse_input_arg))
+ self.done = True
+ else:
+ self.interaction(frame, exc_traceback, 'exception')
+
+ def get_script_line(self, n):
+ return self.executed_script_lines[n-1]
+
+ # General interaction function
+
+ def interaction(self, frame, traceback, event_type):
+ self.setup(frame, traceback)
+ tos = self.stack[self.curindex]
+ top_frame = tos[0]
+ lineno = tos[1]
+
+ topframe_module = top_frame.f_globals['__name__']
+
+ # debug ...
+ '''
+ print >> sys.stderr
+ print >> sys.stderr, '=== STACK ===', 'curindex:', self.curindex
+ for (e,ln) in self.stack:
+ print >> sys.stderr, e.f_code.co_name + ' ' + e.f_code.co_filename + ' ' + str(ln)
+ print >> sys.stderr, "top_frame", top_frame.f_code.co_name, top_frame.f_code
+ '''
+
+
+ # don't trace inside of ANY functions that aren't user-written code
+ # (e.g., those from imported modules -- e.g., random, re -- or the
+ # __restricted_import__ function in this file)
+ #
+ # empirically, it seems like the FIRST entry in self.stack is
+ # the 'run' function from bdb.py, but everything else on the
+ # stack is the user program's "real stack"
+
+ # Look only at the "topmost" frame on the stack ...
+
+ # if we're not in a module that we are explicitly tracing, skip:
+ # (this comes up in tests/backend-tests/namedtuple.txt)
+ if topframe_module not in self.modules_to_trace:
+ return
+ # also don't trace inside of the magic "constructor" code
+ if top_frame.f_code.co_name == '__new__':
+ return
+ # or __repr__, which is often called when running print statements
+ if top_frame.f_code.co_name == '__repr__':
+ return
+
+ # don't trace if wait_for_return_stack is non-null ...
+ if self.wait_for_return_stack:
+ if event_type == 'return' and \
+ (self.wait_for_return_stack == self.get_stack_code_IDs()):
+ self.wait_for_return_stack = None # reset!
+ return # always bail!
+ else:
+ # Skip all "calls" that are actually class definitions, since
+ # those faux calls produce lots of ugly cruft in the trace.
+ #
+ # NB: Only trigger on calls to functions defined in
+ # user-written code (i.e., co_filename == '<string>'), but that
+ # should already be ensured by the above check for whether we're
+ # in user-written code.
+ if event_type == 'call':
+ first_lineno = top_frame.f_code.co_firstlineno
+ if topframe_module == "__main__":
+ func_line = self.get_script_line(first_lineno)
+ elif topframe_module in self.custom_modules:
+ module_code = self.custom_modules[topframe_module]
+ module_code_lines = module_code.splitlines() # TODO: maybe pre-split lines?
+ func_line = module_code_lines[first_lineno-1]
+ else:
+ # you're hosed
+ func_line = ''
+ #print >> sys.stderr, func_line
+
+ if CLASS_RE.match(func_line.lstrip()): # ignore leading spaces
+ self.wait_for_return_stack = self.get_stack_code_IDs()
+ return
+
+
+ self.encoder.reset_heap() # VERY VERY VERY IMPORTANT,
+ # or else we won't properly capture heap object mutations in the trace!
+
+ if event_type == 'call':
+ # Don't be so strict about this assertion because it FAILS
+ # when you're calling a generator (not for the first time),
+ # since that frame has already previously been on the stack ...
+ #assert top_frame not in self.frame_ordered_ids
+
+ self.frame_ordered_ids[top_frame] = self.cur_frame_id
+ self.cur_frame_id += 1
+
+ if self.cumulative_mode:
+ self.zombie_frames.append(top_frame)
+
+ # kinda tricky to get the timing right -- basically, as soon as you
+ # make a call, set sys.stdout to the stream for the appropriate
+ # module, and as soon as you return, set sys.stdout to the
+ # stream for your caller's module. we need to do this on the
+ # return call since we want to immediately start picking up
+ # prints to stdout *right after* this function returns
+ if self.separate_stdout_by_module:
+ if event_type == 'call':
+ if topframe_module in self.stdout_by_module:
+ sys.stdout = self.stdout_by_module[topframe_module]
+ else:
+ sys.stdout = self.stdout_by_module["<other>"]
+ elif event_type == 'return' and self.curindex > 0:
+ prev_tos = self.stack[self.curindex - 1]
+ prev_topframe = prev_tos[0]
+ prev_topframe_module = prev_topframe.f_globals['__name__']
+ if prev_topframe_module in self.stdout_by_module:
+ sys.stdout = self.stdout_by_module[prev_topframe_module]
+ else:
+ sys.stdout = self.stdout_by_module["<other>"]
+
+
+ # only render zombie frames that are NO LONGER on the stack
+ #
+ # subtle: self.stack[:self.curindex+1] is the real stack, since
+ # everything after self.curindex+1 is beyond the top of the
+ # stack. this seems to be relevant only when there's an exception,
+ # since the ENTIRE stack is preserved but self.curindex
+ # starts decrementing as the exception bubbles up the stack.
+ cur_stack_frames = [e[0] for e in self.stack[:self.curindex+1]]
+ zombie_frames_to_render = [e for e in self.zombie_frames if e not in cur_stack_frames]
+
+
+ # each element is a pair of (function name, ENCODED locals dict)
+ encoded_stack_locals = []
+
+
+ # returns a dict with keys: function name, frame id, id of parent frame, encoded_locals dict
+ def create_encoded_stack_entry(cur_frame):
+ #print >> sys.stderr, '- create_encoded_stack_entry', cur_frame, self.closures, self.lambda_closures
+ ret = {}
+
+
+ parent_frame_id_list = []
+
+ f = cur_frame
+ while True:
+ p = self.get_parent_frame(f)
+ if p:
+ pid = self.get_frame_id(p)
+ assert pid
+ parent_frame_id_list.append(pid)
+ f = p
+ else:
+ break
+
+
+ cur_name = cur_frame.f_code.co_name
+
+ if cur_name == '':
+ cur_name = 'unnamed function'
+
+ # augment lambdas with line number
+ if cur_name == '<lambda>':
+ cur_name += pg_encoder.create_lambda_line_number(cur_frame.f_code,
+ self.encoder.line_to_lambda_code)
+
+ # encode in a JSON-friendly format now, in order to prevent ill
+ # effects of aliasing later down the line ...
+ encoded_locals = {}
+
+ for (k, v) in get_user_locals(cur_frame).items():
+ is_in_parent_frame = False
+
+ # don't display locals that appear in your parents' stack frames,
+ # since that's redundant
+ for pid in parent_frame_id_list:
+ parent_frame = self.lookup_zombie_frame_by_id(pid)
+ if k in parent_frame.f_locals:
+ # ignore __return__, which is never copied
+ if k != '__return__':
+ # these values SHOULD BE ALIASES
+ # (don't do an 'is' check since it might not fire for primitives)
+ if parent_frame.f_locals[k] == v:
+ is_in_parent_frame = True
+
+ if is_in_parent_frame and k not in cur_frame.f_code.co_varnames:
+ continue
+
+ # don't display some built-in locals ...
+ if k == '__module__':
+ continue
+
+ encoded_val = self.encoder.encode(v, self.get_parent_of_function)
+ encoded_locals[k] = encoded_val
+
+
+ # order the variable names in a sensible way:
+
+ # Let's start with co_varnames, since it (often) contains all
+ # variables in this frame, some of which might not exist yet.
+ ordered_varnames = []
+ for e in cur_frame.f_code.co_varnames:
+ if e in encoded_locals:
+ ordered_varnames.append(e)
+
+ # sometimes co_varnames doesn't contain all of the true local
+ # variables: e.g., when executing a 'class' definition. in that
+ # case, iterate over encoded_locals and push them onto the end
+ # of ordered_varnames in alphabetical order
+ for e in sorted(encoded_locals.keys()):
+ if e != '__return__' and e not in ordered_varnames:
+ ordered_varnames.append(e)
+
+ # finally, put __return__ at the very end
+ if '__return__' in encoded_locals:
+ ordered_varnames.append('__return__')
+
+ # doctor Python 3 initializer to look like a normal function (denero)
+ if '__locals__' in encoded_locals:
+ ordered_varnames.remove('__locals__')
+ local = encoded_locals.pop('__locals__')
+ if encoded_locals.get('__return__', True) is None:
+ encoded_locals['__return__'] = local
+
+ # crucial sanity checks!
+ assert len(ordered_varnames) == len(encoded_locals)
+ for e in ordered_varnames:
+ assert e in encoded_locals
+
+ return dict(func_name=cur_name,
+ is_parent=(cur_frame in self.parent_frames_set),
+ frame_id=self.get_frame_id(cur_frame),
+ parent_frame_id_list=parent_frame_id_list,
+ encoded_locals=encoded_locals,
+ ordered_varnames=ordered_varnames)
+
+
+ i = self.curindex
+
+ # look for whether a nested function has been defined during
+ # this particular call:
+ if i > 1: # i == 1 implies that there's only a global scope visible
+ for v in visit_all_locally_reachable_function_objs(top_frame):
+ if (v not in self.closures and \
+ v not in self.globally_defined_funcs):
+
+ # Look for the presence of the code object (v.func_code
+ # for Python 2 or v.__code__ for Python 3) in the
+ # constant pool (f_code.co_consts) of an enclosing
+ # stack frame, and set that frame as your parent.
+ #
+ # This technique properly handles lambdas passed as
+ # function parameters. e.g., this example:
+ #
+ # def foo(x):
+ # bar(lambda y: x + y)
+ # def bar(a):
+ # print a(20)
+ # foo(10)
+ chosen_parent_frame = None
+ # SUPER hacky but seems to work -- use reversed(self.stack)
+ # because we want to traverse starting from the TOP of the stack
+ # (most recent frame) and find the first frame containing
+ # a constant code object that matches v.__code__ or v.func_code
+ #
+ # required for this example from Berkeley CS61a:
+ #
+ # def f(p, k):
+ # def g():
+ # print(k)
+ # if k == 0:
+ # f(g, 1)
+ # f(None, 0)
+ #
+ # there are two calls to f, each of which defines a
+ # closure g that should point to the respective frame.
+ #
+ # note that for the second call to f, the parent of the
+ # g defined in there should be that frame, which is at
+ # the TOP of the stack. this reversed() hack does the
+ # right thing. note that if you don't traverse the stack
+ # backwards, then you will mistakenly get the parent as
+ # the FIRST f frame (bottom of the stack).
+ for (my_frame, my_lineno) in reversed(self.stack):
+ if chosen_parent_frame:
+ break
+
+ for frame_const in my_frame.f_code.co_consts:
+ if frame_const is (v.__code__ if is_python3 else v.func_code):
+ chosen_parent_frame = my_frame
+ break
+
+ # 2013-12-01 commented out this line so tests/backend-tests/papajohn-monster.txt
+ # works without an assertion failure ...
+ #assert chosen_parent_frame # I hope this always passes :0
+
+ # this condition should be False for functions declared in global scope ...
+ if chosen_parent_frame in self.frame_ordered_ids:
+ self.closures[v] = chosen_parent_frame
+ self.parent_frames_set.add(chosen_parent_frame) # unequivocally add to this set!!!
+ if not chosen_parent_frame in self.zombie_frames:
+ self.zombie_frames.append(chosen_parent_frame)
+ else:
+ # look for code objects of lambdas defined within this
+ # function, which comes up in cases like line 2 of:
+ # def x(y):
+ # (lambda z: lambda w: z+y)(y)
+ #
+ # x(42)
+ if top_frame.f_code.co_consts:
+ for e in top_frame.f_code.co_consts:
+ if type(e) == types.CodeType and e.co_name == '<lambda>':
+ # TODO: what if it's already in lambda_closures?
+ self.lambda_closures[e] = top_frame
+ self.parent_frames_set.add(top_frame) # copy-paste from above
+ if not top_frame in self.zombie_frames:
+ self.zombie_frames.append(top_frame)
+ else:
+ # if there is only a global scope visible ...
+ for (k, v) in get_user_globals(top_frame).items():
+ if (type(v) in (types.FunctionType, types.MethodType) and \
+ v not in self.closures):
+ self.globally_defined_funcs.add(v)
+
+
+ # climb up until you find '<module>', which is (hopefully) the global scope
+ top_frame = None
+ while True:
+ cur_frame = self.stack[i][0]
+ cur_name = cur_frame.f_code.co_name
+ if cur_name == '<module>':
+ break
+
+ # do this check because in some cases, certain frames on the
+ # stack might NOT be tracked, so don't push a stack entry for
+ # those frames. this happens when you have a callback function
+ # in an imported module. e.g., your code:
+ # def foo():
+ # bar(baz)
+ #
+ # def baz(): pass
+ #
+ # imported module code:
+ # def bar(callback_func):
+ # callback_func()
+ #
+ # when baz is executing, the real stack is [foo, bar, baz] but
+ # bar is in imported module code, so pg_logger doesn't trace
+ # it, and it doesn't show up in frame_ordered_ids. thus, the
+ # stack to render should only be [foo, baz].
+ if cur_frame in self.frame_ordered_ids:
+ encoded_stack_locals.append(create_encoded_stack_entry(cur_frame))
+ if not top_frame:
+ top_frame = cur_frame
+ i -= 1
+
+ zombie_encoded_stack_locals = [create_encoded_stack_entry(e) for e in zombie_frames_to_render]
+
+
+ # encode in a JSON-friendly format now, in order to prevent ill
+ # effects of aliasing later down the line ...
+ encoded_globals = {}
+ cur_globals_dict = get_user_globals(tos[0], at_global_scope=(self.curindex <= 1))
+ for (k, v) in cur_globals_dict.items():
+ encoded_val = self.encoder.encode(v, self.get_parent_of_function)
+ encoded_globals[k] = encoded_val
+
+ if k not in self.all_globals_in_order:
+ self.all_globals_in_order.append(k)
+
+ # filter out globals that don't exist at this execution point
+ # (because they've been, say, deleted with 'del')
+ ordered_globals = [e for e in self.all_globals_in_order if e in encoded_globals]
+ assert len(ordered_globals) == len(encoded_globals)
+
+
+ # merge zombie_encoded_stack_locals and encoded_stack_locals
+ # into one master ordered list using some simple rules for
+ # making it look aesthetically pretty
+ stack_to_render = [];
+
+ # first push all regular stack entries
+ if encoded_stack_locals:
+ for e in encoded_stack_locals:
+ e['is_zombie'] = False
+ e['is_highlighted'] = False
+ stack_to_render.append(e)
+
+ # highlight the top-most active stack entry
+ stack_to_render[0]['is_highlighted'] = True
+
+
+ # now push all zombie stack entries
+ for e in zombie_encoded_stack_locals:
+ # don't display return value for zombie frames
+ # TODO: reconsider ...
+ '''
+ try:
+ e['ordered_varnames'].remove('__return__')
+ except ValueError:
+ pass
+ '''
+
+ e['is_zombie'] = True
+ e['is_highlighted'] = False # never highlight zombie entries
+
+ stack_to_render.append(e)
+
+ # now sort by frame_id since that sorts frames in "chronological
+ # order" based on the order they were invoked
+ stack_to_render.sort(key=lambda e: e['frame_id'])
+
+
+
+ # create a unique hash for this stack entry, so that the
+ # frontend can uniquely identify it when doing incremental
+ # rendering. the strategy is to use a frankenstein-like mix of the
+ # relevant fields to properly disambiguate closures and recursive
+ # calls to the same function
+ for e in stack_to_render:
+ hash_str = e['func_name']
+ # frame_id is UNIQUE, so it can disambiguate recursive calls
+ hash_str += '_f' + str(e['frame_id'])
+
+ # needed to refresh GUI display ...
+ if e['is_parent']:
+ hash_str += '_p'
+
+ # TODO: this is no longer needed, right? (since frame_id is unique)
+ #if e['parent_frame_id_list']:
+ # hash_str += '_p' + '_'.join([str(i) for i in e['parent_frame_id_list']])
+ if e['is_zombie']:
+ hash_str += '_z'
+
+ e['unique_hash'] = hash_str
+
+
+ # handle probe_exprs *before* encoding the heap with self.encoder.get_heap
+ encoded_probe_vals = {}
+ if self.probe_exprs:
+ if top_frame: # are we in a function call?
+ top_frame_locals = get_user_locals(top_frame)
+ else:
+ top_frame_locals = {}
+ for e in self.probe_exprs:
+ try:
+ # evaluate it with globals + locals of the top frame ...
+ probe_val = eval(e, cur_globals_dict, top_frame_locals)
+ encoded_probe_vals[e] = self.encoder.encode(probe_val, self.get_parent_of_function)
+ except:
+ pass # don't encode the value if there's been an error
+
+ if self.show_only_outputs:
+ trace_entry = dict(line=lineno,
+ event=event_type,
+ func_name=tos[0].f_code.co_name,
+ globals={},
+ ordered_globals=[],
+ stack_to_render=[],
+ heap={},
+ stdout=self.get_user_stdout())
+ else:
+ trace_entry = dict(line=lineno,
+ event=event_type,
+ func_name=tos[0].f_code.co_name,
+ globals=encoded_globals,
+ ordered_globals=ordered_globals,
+ stack_to_render=stack_to_render,
+ heap=self.encoder.get_heap(),
+ stdout=self.get_user_stdout())
+ if encoded_probe_vals:
+ trace_entry['probe_exprs'] = encoded_probe_vals
+
+ # optional column numbers for greater precision
+ # (only relevant in Py2crazy, a hacked CPython that supports column numbers)
+ if self.crazy_mode:
+ # at the very least, grab the column number
+ trace_entry['column'] = frame.f_colno
+
+ # now try to find start_col and extent
+ # (-1 is an invalid instruction index)
+ if frame.f_lasti >= 0:
+ key = (frame.f_code.co_code, frame.f_lineno, frame.f_colno,frame.f_lasti)
+ if key in self.bytecode_map:
+ v = self.bytecode_map[key]
+ trace_entry['expr_start_col'] = v.start_col
+ trace_entry['expr_width'] = v.extent
+ trace_entry['opcode'] = v.opcode
+
+ # set a 'custom_module_name' field if we're executing in a module
+ # that's not the __main__ script:
+ if topframe_module != "__main__":
+ trace_entry['custom_module_name'] = topframe_module
+
+ # TODO: refactor into a non-global
+ # these are now deprecated as of 2016-06-28
+ global __html__, __css__, __js__
+ if __html__:
+ trace_entry['html_output'] = __html__
+ if __css__:
+ trace_entry['css_output'] = __css__
+ if __js__:
+ trace_entry['js_output'] = __js__
+
+ # if there's an exception, then record its info:
+ if event_type == 'exception':
+ # always check in f_locals
+ exc = frame.f_locals['__exception__']
+ trace_entry['exception_msg'] = exc[0].__name__ + ': ' + str(exc[1])
+
+
+ # append to the trace only the breakpoint line and the next
+ # executed line, so that if you set only ONE breakpoint, OPT shows
+ # the state before and after that line gets executed.
+ append_to_trace = True
+ if self.breakpoints:
+ if not ((lineno in self.breakpoints) or (self.prev_lineno in self.breakpoints)):
+ append_to_trace = False
+
+ # TRICKY -- however, if there's an exception, then ALWAYS
+ # append it to the trace, so that the error can be displayed
+ if event_type == 'exception':
+ append_to_trace = True
+
+ self.prev_lineno = lineno
+
+ if append_to_trace:
+ self.trace.append(trace_entry)
+
+
+ # sanity check to make sure the state of the world at a 'call' instruction
+ # is identical to that at the instruction immediately following it ...
+ '''
+ if len(self.trace) > 1:
+ cur = self.trace[-1]
+ prev = self.trace[-2]
+ if prev['event'] == 'call':
+ assert cur['globals'] == prev['globals']
+ for (s1, s2) in zip(cur['stack_to_render'], prev['stack_to_render']):
+ assert s1 == s2
+ assert cur['heap'] == prev['heap']
+ assert cur['stdout'] == prev['stdout']
+ '''
+
+
+ if len(self.trace) >= MAX_EXECUTED_LINES:
+ self.trace.append(dict(event='instruction_limit_reached', exception_msg='Stopped after running ' + str(MAX_EXECUTED_LINES) + ' steps. Please shorten your code,\nsince Python Tutor is not designed to handle long-running code.'))
+ self.force_terminate()
+
+ self.forget()
+
+
+ def _runscript(self, script_str):
+ self.executed_script = script_str
+ self.executed_script_lines = self.executed_script.splitlines()
+
+ for (i, line) in enumerate(self.executed_script_lines):
+ line_no = i + 1
+ if line.endswith(BREAKPOINT_STR):
+ self.breakpoints.append(line_no)
+
+
+ # populate an extent map to get more accurate ranges from code
+ if self.crazy_mode:
+ # in Py2crazy standard library as Python-2.7.5/Lib/super_dis.py
+ import super_dis
+ try:
+ self.bytecode_map = super_dis.get_bytecode_map(self.executed_script)
+ except:
+ # failure oblivious
+ self.bytecode_map = {}
+
+
+ # When bdb sets tracing, a number of call and line events happens
+ # BEFORE debugger even reaches user's code (and the exact sequence of
+ # events depends on python version). So we take special measures to
+ # avoid stopping before we reach the main script (see user_line and
+ # user_call for details).
+ self._wait_for_mainpyfile = 1
+
+
+ # ok, let's try to sorta 'sandbox' the user script by not
+ # allowing certain potentially dangerous operations.
+ user_builtins = {}
+
+ # ugh, I can't figure out why in Python 2, __builtins__ seems to
+ # be a dict, but in Python 3, __builtins__ seems to be a module,
+ # so just handle both cases ... UGLY!
+ if type(__builtins__) is dict:
+ builtin_items = __builtins__.items()
+ else:
+ assert type(__builtins__) is types.ModuleType
+ builtin_items = []
+ for k in dir(__builtins__):
+ builtin_items.append((k, getattr(__builtins__, k)))
+
+ for (k, v) in builtin_items:
+ if k == 'open': # put this before BANNED_BUILTINS
+ user_builtins[k] = open_wrapper
+ elif k in BANNED_BUILTINS:
+ user_builtins[k] = create_banned_builtins_wrapper(k)
+ elif k == '__import__':
+ user_builtins[k] = __restricted_import__
+ else:
+ if k == 'raw_input':
+ user_builtins[k] = raw_input_wrapper
+ elif k == 'input':
+ if is_python3:
+ # Python 3 input() is Python 2 raw_input()
+ user_builtins[k] = raw_input_wrapper
+ else:
+ user_builtins[k] = python2_input_wrapper
+ else:
+ user_builtins[k] = v
+
+ user_builtins['mouse_input'] = mouse_input_wrapper
+
+ # TODO: we can disable these imports here, but a crafty user can
+ # always get a hold of them by importing one of the external
+ # modules, so there's no point in trying security by obscurity
+ user_builtins['setHTML'] = setHTML
+ user_builtins['setCSS'] = setCSS
+ user_builtins['setJS'] = setJS
+
+ if self.separate_stdout_by_module:
+ self.stdout_by_module["__main__"] = StringIO.StringIO()
+ if self.custom_modules:
+ for module_name in self.custom_modules:
+ self.stdout_by_module[module_name] = StringIO.StringIO()
+ self.stdout_by_module["<other>"] = StringIO.StringIO() # catch-all for all other modules we're NOT tracing
+ sys.stdout = self.stdout_by_module["<other>"] # start with <other>
+ else:
+ # default -- a single unified stdout stream
+ self.user_stdout = StringIO.StringIO()
+ sys.stdout = self.user_stdout
+
+ self.ORIGINAL_STDERR = sys.stderr
+
+ # don't do this, or else certain kinds of errors, such as syntax
+ # errors, will be silently ignored. WEIRD!
+ #sys.stderr = NullDevice # silence errors
+
+ user_globals = {}
+
+ # if there are custom_modules, 'import' them into user_globals,
+ # which emulates "from <module> import *"
+ if self.custom_modules:
+ for mn in self.custom_modules:
+ # http://code.activestate.com/recipes/82234-importing-a-dynamically-generated-module/
+ new_m = imp.new_module(mn)
+ exec(self.custom_modules[mn], new_m.__dict__) # exec in custom globals
+ user_globals.update(new_m.__dict__)
+
+ # important: do this LAST to get precedence over values in custom_modules
+ user_globals.update({"__name__" : "__main__",
+ "__builtins__" : user_builtins})
+
+ try:
+ # enforce resource limits RIGHT BEFORE running script_str
+
+ # set ~200MB virtual memory limit AND a 5-second CPU time
+ # limit (tuned for Webfaction shared hosting) to protect against
+ # memory bombs such as:
+ # x = 2
+ # while True: x = x*x
+ if resource_module_loaded and (not self.disable_security_checks):
+ resource.setrlimit(resource.RLIMIT_AS, (200000000, 200000000))
+ resource.setrlimit(resource.RLIMIT_CPU, (5, 5))
+
+ # protect against unauthorized filesystem accesses ...
+ resource.setrlimit(resource.RLIMIT_NOFILE, (0, 0)) # no opened files allowed
+
+ # VERY WEIRD. If you activate this resource limitation, it
+ # ends up generating an EMPTY trace for the following program:
+ # "x = 0\nfor i in range(10):\n x += 1\n print x\n x += 1\n"
+ # (at least on my Webfaction hosting with Python 2.7)
+ #resource.setrlimit(resource.RLIMIT_FSIZE, (0, 0)) # (redundancy for paranoia)
+
+ # The posix module is a built-in and has a ton of OS access
+ # facilities ... if you delete those functions from
+ # sys.modules['posix'], it seems like they're gone EVEN IF
+ # someone else imports posix in a roundabout way. Of course,
+ # I don't know how foolproof this scheme is, though.
+ # (It's not sufficient to just "del sys.modules['posix']";
+ # it can just be reimported without accessing an external
+ # file and tripping RLIMIT_NOFILE, since the posix module
+ # is baked into the python executable, ergh. Actually DON'T
+ # "del sys.modules['posix']", since re-importing it will
+ # refresh all of the attributes. ergh^2)
+ for a in dir(sys.modules['posix']):
+ delattr(sys.modules['posix'], a)
+ # do the same with os
+ for a in dir(sys.modules['os']):
+ # 'path' is needed for __restricted_import__ to work
+ # and 'stat' is needed for some errors to be reported properly
+ if a not in ('path', 'stat'):
+ delattr(sys.modules['os'], a)
+ # ppl can dig up trashed objects with gc.get_objects()
+ import gc
+ for a in dir(sys.modules['gc']):
+ delattr(sys.modules['gc'], a)
+ del sys.modules['gc']
+
+ # sys.modules contains an in-memory cache of already-loaded
+ # modules, so if you delete modules from here, they will
+ # need to be re-loaded from the filesystem.
+ #
+ # Thus, as an extra precaution, remove these modules so that
+ # they can't be re-imported without opening a new file,
+ # which is disallowed by resource.RLIMIT_NOFILE
+ #
+ # Of course, this isn't a foolproof solution by any means,
+ # and it might lead to UNEXPECTED FAILURES later in execution.
+ del sys.modules['os']
+ del sys.modules['os.path']
+ del sys.modules['sys']
+
+ self.run(script_str, user_globals, user_globals)
+ # sys.exit ...
+ except SystemExit:
+ #sys.exit(0)
+ raise bdb.BdbQuit
+ except:
+ if DEBUG:
+ traceback.print_exc()
+
+ trace_entry = dict(event='uncaught_exception')
+
+ (exc_type, exc_val, exc_tb) = sys.exc_info()
+ if hasattr(exc_val, 'lineno'):
+ trace_entry['line'] = exc_val.lineno
+ if hasattr(exc_val, 'offset'):
+ trace_entry['offset'] = exc_val.offset
+
+ trace_entry['exception_msg'] = type(exc_val).__name__ + ": " + str(exc_val)
+
+ # SUPER SUBTLE! if ANY exception has already been recorded by
+ # the program, then DON'T record it again as an uncaught_exception.
+ # This looks kinda weird since the exact exception message doesn't
+ # need to match up, but in practice, there should be at most only
+ # ONE exception per trace.
+ already_caught = False
+ for e in self.trace:
+ if e['event'] == 'exception':
+ already_caught = True
+ break
+
+ if not already_caught:
+ if not self.done:
+ self.trace.append(trace_entry)
+
+ raise bdb.BdbQuit # need to forceably STOP execution
+
+
+ def force_terminate(self):
+ #self.finalize()
+ raise bdb.BdbQuit # need to forceably STOP execution
+
+
+ def finalize(self):
+ sys.stdout = self.GAE_STDOUT # very important!
+ sys.stderr = self.ORIGINAL_STDERR
+
+ assert len(self.trace) <= (MAX_EXECUTED_LINES + 1)
+
+ # don't do this anymore ...
+ '''
+ # filter all entries after 'return' from '<module>', since they
+ # seem extraneous:
+ res = []
+ for e in self.trace:
+ res.append(e)
+ if e['event'] == 'return' and e['func_name'] == '<module>':
+ break
+ '''
+
+ res = self.trace
+
+ # if the SECOND to last entry is an 'exception'
+ # and the last entry is return from <module>, then axe the last
+ # entry, for aesthetic reasons :)
+ if len(res) >= 2 and \
+ res[-2]['event'] == 'exception' and \
+ res[-1]['event'] == 'return' and res[-1]['func_name'] == '<module>':
+ res.pop()
+
+ self.trace = res
+
+ if self.custom_modules:
+ # when there's custom_modules, call with a dict as the first parameter
+ return self.finalizer_func(dict(main_code=self.executed_script,
+ custom_modules=self.custom_modules),
+ self.trace)
+ else:
+ # common case
+ return self.finalizer_func(self.executed_script, self.trace)
+
+
+import json
+
+# the MAIN meaty function!!!
+def exec_script_str(script_str, raw_input_lst_json, options_json, finalizer_func):
+ if options_json:
+ options = json.loads(options_json)
+ else:
+ # defaults
+ options = {'cumulative_mode': False,
+ 'heap_primitives': False, 'show_only_outputs': False}
+
+ py_crazy_mode = ('py_crazy_mode' in options and options['py_crazy_mode'])
+
+ logger = PGLogger(options['cumulative_mode'], options['heap_primitives'], options['show_only_outputs'], finalizer_func,
+ crazy_mode=py_crazy_mode)
+
+ # TODO: refactor these NOT to be globals
+ global input_string_queue
+ input_string_queue = []
+ if raw_input_lst_json:
+ # TODO: if we want to support unicode, remove str() cast
+ input_string_queue = [str(e) for e in json.loads(raw_input_lst_json)]
+
+ global __html__, __css__, __js__
+ __html__, __css__, __js__ = None, None, None
+
+ try:
+ logger._runscript(script_str)
+ except bdb.BdbQuit:
+ pass
+ finally:
+ logger.finalize()
+
+
+# disables security check and returns the result of finalizer_func
+# WARNING: ONLY RUN THIS LOCALLY and never over the web, since
+# security checks are disabled
+#
+# [optional] probe_exprs is a list of strings representing
+# expressions whose values to probe at each step (advanced)
+def exec_script_str_local(script_str, raw_input_lst_json, cumulative_mode, heap_primitives, finalizer_func, probe_exprs=None):
+ # TODO: add py_crazy_mode option here too ...
+ logger = PGLogger(cumulative_mode, heap_primitives, False, finalizer_func, disable_security_checks=True, probe_exprs=probe_exprs)
+
+ # TODO: refactor these NOT to be globals
+ global input_string_queue
+ input_string_queue = []
+ if raw_input_lst_json:
+ # TODO: if we want to support unicode, remove str() cast
+ input_string_queue = [str(e) for e in json.loads(raw_input_lst_json)]
+
+ global __html__, __css__, __js__
+ __html__, __css__, __js__ = None, None, None
+
+ try:
+ logger._runscript(script_str)
+ except bdb.BdbQuit:
+ pass
+ finally:
+ return logger.finalize()
+
+
+# deprecated?!?
+def exec_str_with_user_ns(script_str, user_ns, finalizer_func):
+ logger = PGLogger(False, False, False, finalizer_func, disable_security_checks=True)
+
+ global __html__, __css__, __js__
+ __html__, __css__, __js__ = None, None, None
+
+ try:
+ logger._runscript(script_str, user_ns)
+ except bdb.BdbQuit:
+ pass
+ finally:
+ return logger.finalize()
+