def _eval_cell(self, key, code):
"""Evaluates one cell and returns its result"""
# Flatten helper function
def nn(val):
"""Returns flat numpy arraz without None values"""
try:
return numpy.array(filter(None, val.flat))
except AttributeError:
# Probably no numpy array
return numpy.array(filter(None, val))
# Set up environment for evaluation
env_dict = {
'X': key[0],
'Y': key[1],
'Z': key[2],
'bz2': bz2,
'base64': base64,
'charts': charts,
'nn': nn,
'R': key[0],
'C': key[1],
'T': key[2],
'S': self,
'vlcpanel_factory': vlcpanel_factory
}
env = self._get_updated_environment(env_dict=env_dict)
#_old_code = self(key)
# Return cell value if in safe mode
if self.safe_mode:
return code
# If cell is not present return None
if code is None:
return
elif is_generator_like(code):
# We have a generator object
return numpy.array(self._make_nested_list(code), dtype="O")
# If only 1 term in front of the "=" --> global
try:
assignment_target_error = None
module = ast.parse(code)
assignment_target_end = self._get_assignment_target_end(module)
except ValueError, err:
assignment_target_error = ValueError(err)
def _eval_cell(self, key, code):
"""Evaluates one cell and returns its result"""
# Flatten helper function
def nn(val):
"""Returns flat numpy arraz without None values"""
try:
return numpy.array(filter(None, val.flat))
except AttributeError:
# Probably no numpy array
return numpy.array(filter(None, val))
# Set up environment for evaluation
env_dict = {'X': key[0], 'Y': key[1], 'Z': key[2], 'bz2': bz2,
'base64': base64, 'charts': charts, 'nn': nn,
'R': key[0], 'C': key[1], 'T': key[2], 'S': self,
'vlcpanel_factory': vlcpanel_factory}
env = self._get_updated_environment(env_dict=env_dict)
_old_code = self(key)
# Return cell value if in safe mode
if self.safe_mode:
return code
# If cell is not present return None
if code is None:
return
elif is_generator_like(code):
# We have a generator object
return numpy.array(self._make_nested_list(code), dtype="O")
# If only 1 term in front of the "=" --> global
try:
assignment_target_error = None
module = ast.parse(code)
assignment_target_end = self._get_assignment_target_end(module)
except ValueError, err:
assignment_target_error = ValueError(err)
def _eval_cell(self, key):
"""Evaluates one cell"""
# Set up environment for evaluation
env_dict = {'X': key[0], 'Y': key[1], 'Z': key[2], 'bz2': bz2,
'base64': base64, 'chart': chart,
'R': key[0], 'C': key[1], 'T': key[2], 'S': self}
env = self._get_updated_environment(env_dict=env_dict)
code = self(key)
# Return cell value if in safe mode
if self.safe_mode:
return code
# If cell is not present return None
if code is None:
return
elif is_generator_like(code):
# We have a generator object
return numpy.array(self._make_nested_list(code), dtype="O")
# If only 1 term in front of the "=" --> global
split_exp = code.split("=")
if self._has_assignment(split_exp):
glob_var = split_exp[0].strip()
expression = "=".join(split_exp[1:])
# Delete result cache because assignment changes results
self.result_cache.clear()
else:
glob_var = None
expression = code
try:
result = eval(expression, env, {})
except AttributeError, err:
# Attribute Error includes RunTimeError
result = AttributeError(err)
def _make_nested_list(self, gen):
"""Makes nested list from generator for creating numpy.array"""
res = []
for ele in gen:
if ele is None:
res.append(None)
elif not is_string_like(ele) and is_generator_like(ele):
# Nested generator
res.append(self._make_nested_list(ele))
else:
res.append(ele)
return res
def _make_nested_list(self, gen):
"""Makes nested list from generator for creating numpy.array"""
res = []
for ele in gen:
if ele is None:
res.append(None)
elif not is_string_like(ele) and is_generator_like(ele):
# Nested generator
res.append(self._make_nested_list(ele))
else:
res.append(ele)
return res
def _eval_cell(self, key, code):
"""Evaluates one cell and returns its result"""
# Set up environment for evaluation
env_dict = {
'X': key[0],
'Y': key[1],
'Z': key[2],
'bz2': bz2,
'base64': base64,
'charts': charts,
'R': key[0],
'C': key[1],
'T': key[2],
'S': self
}
env = self._get_updated_environment(env_dict=env_dict)
_old_code = self(key)
# Return cell value if in safe mode
if self.safe_mode:
return code
# If cell is not present return None
if code is None:
return
elif is_generator_like(code):
# We have a generator object
return numpy.array(self._make_nested_list(code), dtype="O")
# If only 1 term in front of the "=" --> global
try:
assignment_target_error = None
module = ast.parse(code)
assignment_target_end = self._get_assignment_target_end(module)
except ValueError, err:
assignment_target_error = ValueError(err)
def _eval_cell(self, key, code):
"""Evaluates one cell and returns its result"""
# Set up environment for evaluation
env_dict = {
"X": key[0],
"Y": key[1],
"Z": key[2],
"bz2": bz2,
"base64": base64,
"charts": charts,
"R": key[0],
"C": key[1],
"T": key[2],
"S": self,
}
env = self._get_updated_environment(env_dict=env_dict)
_old_code = self(key)
# Return cell value if in safe mode
if self.safe_mode:
return code
# If cell is not present return None
if code is None:
return
elif is_generator_like(code):
# We have a generator object
return numpy.array(self._make_nested_list(code), dtype="O")
# If only 1 term in front of the "=" --> global
try:
assignment_target_error = None
module = ast.parse(code)
assignment_target_end = self._get_assignment_target_end(module)
except ValueError, err:
assignment_target_error = ValueError(err)
def test_is_generator_like(gen, res):
"""Unit test for is_generator_like"""
assert is_generator_like(gen) == res
def test_is_generator_like(gen, res):
"""Unit test for is_generator_like"""
assert is_generator_like(gen) == res
