def _importer_exporter_options(available_options, options, evaluation):
stream_options = []
custom_options = []
if available_options and available_options.has_form('List', None):
for name in available_options.leaves:
if isinstance(name, String):
py_name = name.get_string_value()
elif isinstance(name, Symbol):
py_name = strip_context(name.get_name())
else:
py_name = None
if py_name:
value = Builtin.get_option(options, py_name, evaluation)
if value is not None:
expr = Expression('Rule', String(py_name), value)
if py_name == 'CharacterEncoding':
stream_options.append(expr)
else:
custom_options.append(expr)
return stream_options, custom_options
def _importer_exporter_options(available_options, options, builtin_name: str,
evaluation):
stream_options = []
custom_options = []
remaining_options = options.copy()
if available_options and available_options.has_form('List', None):
for name in available_options.leaves:
if isinstance(name, String):
py_name = name.get_string_value()
elif isinstance(name, Symbol):
py_name = strip_context(name.get_name())
else:
py_name = None
if py_name:
value = get_option(remaining_options,
py_name,
evaluation,
pop=True)
if value is not None:
expr = Expression('Rule', String(py_name), value)
if py_name == 'CharacterEncoding':
stream_options.append(expr)
else:
custom_options.append(expr)
syntax_option = remaining_options.get("System`$OptionSyntax", None)
if syntax_option and syntax_option != Symbol("System`Ignore"):
# warn about unsupported options.
for name, value in remaining_options.items():
print(" es de acá....")
evaluation.message(builtin_name, "optx",
Expression('Rule', strip_context(name), value),
strip_context(builtin_name))
return stream_options, custom_options
def apply(self, filename, elements, evaluation):
'Import[filename_, elements_]'
# Check filename
path = filename.to_python()
if not (isinstance(path, basestring) and path[0] == path[-1] == '"'):
evaluation.message('Import', 'chtype', filename)
return Symbol('$Failed')
findfile = Expression('FindFile', filename).evaluate(evaluation)
if findfile == Symbol('$Failed'):
evaluation.message('Import', 'nffil')
return findfile
# Check elements
if elements.has_form('List', None):
elements = elements.get_leaves()
else:
elements = [elements]
for el in elements:
if not isinstance(el, String):
evaluation.message('Import', 'noelem', el)
return Symbol('$Failed')
elements = [el.get_string_value() for el in elements]
# Determine file type
for el in elements:
if el in IMPORTERS.keys():
filetype = el
elements.remove(el)
break
else:
filetype = Expression(
'FileFormat',
findfile).evaluate(evaluation=evaluation).get_string_value()
if filetype not in IMPORTERS.keys():
evaluation.message('Import', 'fmtnosup', filetype)
return Symbol('$Failed')
# Load the importer
(conditionals, default_function, posts,
importer_options) = IMPORTERS[filetype]
# XXX OptionsIssue
# function_channels = importer_options.get(String("FunctionChannels"))
function_channels = importer_options.get(Symbol("FunctionChannels"))
# XXX OptionsIssue
# default_element = importer_options.get(String("DefaultElement"))
default_element = importer_options.get(Symbol("DefaultElement"))
def get_results(tmp_function):
if function_channels == Expression('List', String('FileNames')):
tmp = Expression(tmp_function, findfile).evaluate(evaluation)
elif function_channels == Expression('List', String('Streams')):
stream = Expression('OpenRead', findfile).evaluate(evaluation)
if stream.get_head_name() != 'System`InputStream':
evaluation.message('Import', 'nffil')
return None
tmp = Expression(tmp_function, stream).evaluate(evaluation)
Expression('Close', stream).evaluate(evaluation)
else:
# TODO print appropriate error message
raise NotImplementedError
tmp = tmp.get_leaves()
if not all(expr.has_form('Rule', None) for expr in tmp):
return None
# return {a.get_string_value() : b for (a,b) in map(lambda x:
# x.get_leaves(), tmp)}
return dict((a.get_string_value(), b)
for (a, b) in map(lambda x: x.get_leaves(), tmp))
# Perform the import
defaults = None
if elements == []:
defaults = get_results(default_function)
if defaults is None:
return Symbol('$Failed')
if default_element == Symbol("Automatic"):
return Expression(
'List',
*(Expression('Rule', String(key), defaults[key])
for key in defaults.keys()))
else:
result = defaults.get(default_element.get_string_value())
if result is None:
evaluation.message('Import', 'noelem', default_element,
from_python(filetype))
return Symbol('$Failed')
return result
else:
assert len(elements) == 1
el = elements[0]
if el == "Elements":
defaults = get_results(default_function)
if defaults is None:
return Symbol('$Failed')
# Use set() to remove duplicates
return from_python(
sorted(
set(conditionals.keys() + defaults.keys() +
posts.keys())))
else:
if el in conditionals.keys():
result = get_results(conditionals[el])
if result is None:
return Symbol('$Failed')
if len(result.keys()) == 1 and result.keys()[0] == el:
return result.values()[0]
elif el in posts.keys():
# TODO: allow use of conditionals
result = get_results(posts[el])
if result is None:
return Symbol('$Failed')
else:
if defaults is None:
defaults = get_results(default_function)
if defaults is None:
return Symbol('$Failed')
if el in defaults.keys():
return defaults[el]
else:
evaluation.message('Import', 'noelem', from_python(el),
from_python(filetype))
return Symbol('$Failed')
def apply(self, image, evaluation):
'ImageColorSpace[image_Image]'
return String(image.color_space)
def apply(self, image, evaluation):
'ImageType[image_Image]'
return String(image.storage_type())
def apply(self, path, evaluation):
'''ImageImport[path_?StringQ]'''
pixels = skimage.io.imread(path.get_string_value())
is_rgb = len(pixels.shape) >= 3 and pixels.shape[2] >= 3
atom = Image(pixels, 'RGB' if is_rgb else 'Grayscale')
return Expression('List', Expression('Rule', String('Image'), atom))
def apply_elements(self, filename, expr, elems, evaluation, options={}):
"Export[filename_, expr_, elems_List?(AllTrue[#, NotOptionQ]&), OptionsPattern[]]"
# Check filename
if not self._check_filename(filename, evaluation):
return Symbol('$Failed')
# Process elems {comp* format?, elem1*}
leaves = elems.get_leaves()
format_spec, elems_spec = [], []
found_form = False
for leaf in leaves[::-1]:
leaf_str = leaf.get_string_value()
if not found_form and leaf_str in EXPORTERS:
found_form = True
if found_form:
format_spec.append(leaf_str)
else:
elems_spec.append(leaf)
# Just to be sure that the following calls do not change the state of this property
current_predetermined_out = evaluation.predetermined_out
# Infer format if not present
if not found_form:
assert format_spec == []
format_spec = self._infer_form(filename, evaluation)
if format_spec is None:
evaluation.message('Export', 'infer', filename)
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
format_spec = [format_spec]
else:
assert format_spec != []
# First item in format_spec is the explicit format.
# The other elements (if present) are compression formats
if elems_spec != []: # FIXME: support elems
evaluation.message('Export', 'noelem', elems,
String(format_spec[0]))
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
# Load the exporter
exporter_symbol, exporter_options = EXPORTERS[format_spec[0]]
function_channels = exporter_options.get("System`FunctionChannels")
stream_options, custom_options = _importer_exporter_options(
exporter_options.get("System`Options"), options, evaluation)
if function_channels is None:
evaluation.message('Export', 'emptyfch')
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
elif function_channels == Expression('List', String('FileNames')):
exporter_function = Expression(
exporter_symbol, filename, expr,
*list(chain(stream_options, custom_options)))
res = exporter_function.evaluate(evaluation)
elif function_channels == Expression('List', String('Streams')):
stream = Expression('OpenWrite', filename,
*stream_options).evaluate(evaluation)
if stream.get_head_name() != 'System`OutputStream':
evaluation.message('Export', 'nffil')
evaluation.predetermined_out = current_predetermined_out
return Symbol("$Failed")
exporter_function = Expression(
exporter_symbol, stream, expr,
*list(chain(stream_options, custom_options)))
res = exporter_function.evaluate(evaluation)
Expression('Close', stream).evaluate(evaluation)
if res == Symbol('Null'):
evaluation.predetermined_out = current_predetermined_out
return filename
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
def _import(findfile,
determine_filetype,
elements,
evaluation,
options,
data=None):
current_predetermined_out = evaluation.predetermined_out
# Check elements
if elements.has_form('List', None):
elements = elements.get_leaves()
else:
elements = [elements]
for el in elements:
if not isinstance(el, String):
evaluation.message('Import', 'noelem', el)
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
elements = [el.get_string_value() for el in elements]
# Determine file type
for el in elements:
if el in IMPORTERS.keys():
filetype = el
elements.remove(el)
break
else:
filetype = determine_filetype()
if filetype not in IMPORTERS.keys():
evaluation.message('Import', 'fmtnosup', filetype)
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
# Load the importer
(conditionals, default_function, posts,
importer_options) = IMPORTERS[filetype]
stream_options, custom_options = _importer_exporter_options(
importer_options.get("System`Options"), options, evaluation)
function_channels = importer_options.get("System`FunctionChannels")
if function_channels is None:
# TODO message
if data is None:
evaluation.message('Import', 'emptyfch')
else:
evaluation.message('ImportString', 'emptyfch')
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
default_element = importer_options.get("System`DefaultElement")
if default_element is None:
# TODO message
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
def get_results(tmp_function, findfile):
if function_channels == Expression('List', String('FileNames')):
joined_options = list(chain(stream_options, custom_options))
tmpfile = False
if findfile is None:
tmpfile = True
stream = Expression('OpenWrite').evaluate(evaluation)
findfile = stream.leaves[0]
if not data is None:
Expression('WriteString', data).evaluate(evaluation)
else:
Expression('WriteString',
String("")).evaluate(evaluation)
Expression('Close', stream).evaluate(evaluation)
stream = None
tmp = Expression(tmp_function, findfile,
*joined_options).evaluate(evaluation)
if tmpfile:
Expression("DeleteFile", findfile).evaluate(evaluation)
elif function_channels == Expression('List', String('Streams')):
if findfile is None:
stream = Expression('StringToStream',
data).evaluate(evaluation)
else:
stream = Expression('OpenRead', findfile,
*stream_options).evaluate(evaluation)
if stream.get_head_name() != 'System`InputStream':
evaluation.message('Import', 'nffil')
evaluation.predetermined_out = current_predetermined_out
return None
tmp = Expression(tmp_function, stream,
*custom_options).evaluate(evaluation)
Expression('Close', stream).evaluate(evaluation)
else:
# TODO message
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
tmp = tmp.get_leaves()
if not all(expr.has_form('Rule', None) for expr in tmp):
evaluation.predetermined_out = current_predetermined_out
return None
# return {a.get_string_value() : b for (a,b) in map(lambda x:
# x.get_leaves(), tmp)}
evaluation.predetermined_out = current_predetermined_out
return dict((a.get_string_value(), b)
for (a, b) in [x.get_leaves() for x in tmp])
# Perform the import
defaults = None
if not elements:
defaults = get_results(default_function, findfile)
if defaults is None:
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
if default_element == Symbol("Automatic"):
evaluation.predetermined_out = current_predetermined_out
return Expression(
'List',
*(Expression('Rule', String(key), defaults[key])
for key in defaults.keys()))
else:
result = defaults.get(default_element.get_string_value())
if result is None:
evaluation.message('Import', 'noelem', default_element,
from_python(filetype))
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
evaluation.predetermined_out = current_predetermined_out
return result
else:
assert len(elements) == 1
el = elements[0]
if el == "Elements":
defaults = get_results(default_function, findfile)
if defaults is None:
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
# Use set() to remove duplicates
evaluation.predetermined_out = current_predetermined_out
return from_python(
sorted(
set(
list(conditionals.keys()) + list(defaults.keys()) +
list(posts.keys()))))
else:
if el in conditionals.keys():
result = get_results(conditionals[el], findfile)
if result is None:
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
if len(list(result.keys())) == 1 and list(
result.keys())[0] == el:
evaluation.predetermined_out = current_predetermined_out
return list(result.values())[0]
elif el in posts.keys():
# TODO: allow use of conditionals
result = get_results(posts[el])
if result is None:
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
else:
if defaults is None:
defaults = get_results(default_function, findfile)
if defaults is None:
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
if el in defaults.keys():
evaluation.predetermined_out = current_predetermined_out
return defaults[el]
else:
evaluation.message('Import', 'noelem', from_python(el),
from_python(filetype))
evaluation.predetermined_out = current_predetermined_otu
return Symbol('$Failed')
def apply_elements(self, expr, elems, evaluation, options={}):
"ExportString[expr_, elems_List?(AllTrue[#, NotOptionQ]&), OptionsPattern[]]"
# Process elems {comp* format?, elem1*}
leaves = elems.get_leaves()
format_spec, elems_spec = [], []
found_form = False
for leaf in leaves[::-1]:
leaf_str = leaf.get_string_value()
if not found_form and leaf_str in EXPORTERS:
found_form = True
if found_form:
format_spec.append(leaf_str)
else:
elems_spec.append(leaf)
# Just to be sure that the following evaluations do not change the value of this property
current_predetermined_out = evaluation.predetermined_out
# Infer format if not present
if format_spec is None:
evaluation.message('ExportString', 'infer', filename)
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
# First item in format_spec is the explicit format.
# The other elements (if present) are compression formats
if elems_spec != []: # FIXME: support elems
if format_spec != []:
evaluation.message('ExportString', 'noelem', elems,
String(format_spec[0]))
else:
evaluation.message('ExportString', 'noelem', elems,
String("Unknown"))
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
# Load the exporter
exporter_symbol, exporter_options = EXPORTERS[format_spec[0]]
function_channels = exporter_options.get("System`FunctionChannels")
stream_options, custom_options = _importer_exporter_options(
exporter_options.get("System`Options"), options, evaluation)
if function_channels is None:
evaluation.message('ExportString', 'emptyfch')
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
elif function_channels == Expression('List', String('FileNames')):
# Generates a temporary file
import tempfile
tmpfile = tempfile.NamedTemporaryFile(dir=tempfile.gettempdir())
filename = String(tmpfile.name)
tmpfile.close()
exporter_function = Expression(
exporter_symbol, filename, expr,
*list(chain(stream_options, custom_options)))
if exporter_function.evaluate(evaluation) != Symbol('Null'):
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
else:
try:
tmpstream = open(filename.value, 'rb')
res = tmpstream.read().decode('utf-8')
tmpstream.close()
except Exception as e:
print("something went wrong")
print(e)
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
res = String(str(res))
elif function_channels == Expression('List', String('Streams')):
from io import StringIO
from mathics.builtin.files import STREAMS, NSTREAMS
pystream = StringIO()
n = next(NSTREAMS)
STREAMS.append(pystream)
stream = Expression('OutputStream', String('String'), Integer(n))
exporter_function = Expression(
exporter_symbol, stream, expr,
*list(chain(stream_options, custom_options)))
res = exporter_function.evaluate(evaluation)
if res == Symbol('Null'):
res = String(str(pystream.getvalue()))
else:
res = Symbol("$Failed")
Expression('Close', stream).evaluate(evaluation)
else:
evaluation.message('ExportString', 'emptyfch')
evaluation.predetermined_out = current_predetermined_out
return Symbol('$Failed')
evaluation.predetermined_out = current_predetermined_out
return res
def apply(self, val, evaluation):
'MyPyTestContext`MyPyTestFunction[val_]'
return String("This is a PyMathics output")
