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")