Plumbing hooked up for Import zip with members.

Now we just gotta get ImportString[xxx, "JSON"] working on its own.

Also, other small fixes and improvements.

Author: rocky

mathics/builtin/import_export/compression.py

@@ -30,3 +30,7 @@ class ImportZIP(Builtin):
     def eval(self, path: String, evaluation: Evaluation):
         "ImportZIP[path_String]"
         return eval_ImportZIP(path.value, evaluation)
+
+    def eval_with_elements(self, path: String, elements, evaluation: Evaluation):
+        "ImportZIP[path_String, elements_]"
+        return eval_ImportZIP(path.value, evaluation, elements)

mathics/builtin/import_export/importexport.py

@@ -13,10 +13,10 @@
 from itertools import chain
 from urllib.error import HTTPError, URLError
 
-from mathics.builtin.import_export.checking import (
-    check_filename,
-    import_setup_check,
-)
+# Use this when accessing IMPORTERS to get changes
+# since initializiation.
+import mathics.eval.import_export.importexport as importexport
+from mathics.builtin.import_export.checking import check_filename, import_setup_check
 from mathics.core.atoms import ByteArray
 from mathics.core.attributes import A_PROTECTED, A_READ_PROTECTED
 from mathics.core.builtin import Builtin, Integer, Predefined, String
@@ -36,7 +36,6 @@
 from mathics.eval.files_io.files import eval_Close
 from mathics.eval.files_io.filesystem import eval_FindFile
 from mathics.eval.import_export.importexport import (
-    IMPORTERS,
     MIMETYPE_TO_SHORTNAME,
     eval_FileFormat,
     eval_Import_data_only,
@@ -92,7 +91,9 @@ class ImportFormats(Predefined):
     summary_text = "list supported import formats"
 
     def evaluate(self, evaluation: Evaluation):
-        return to_mathics_list(*sorted(IMPORTERS.keys()), elements_conversion_fn=String)
+        return to_mathics_list(
+            *sorted(importexport.IMPORTERS.keys()), elements_conversion_fn=String
+        )
 
 
 class RegisterImport(Builtin):
@@ -238,7 +239,7 @@ def eval(
         # as well.
         # By doing this, we accept "text, "Text", "TEXT", and other combinations,
         # which what WMA seems to do.
-        IMPORTERS[formatname.value.upper()] = (
+        importexport.IMPORTERS[formatname.value.upper()] = (
             conditionals,
             default,
             posts,
@@ -455,15 +456,16 @@ def eval_source_only(self, source, evaluation, options={}):
     def eval_with_element_list(self, source, elements, evaluation, options={}):
         "Import[source_, elements_List?(AllTrue[#, NotOptionQ]&), OptionsPattern[]]"
 
-        findfile, data = import_setup_check(source, evaluation)
+        findfile, file_format = import_setup_check(source, evaluation)
         if findfile is SymbolFailed:
             return SymbolFailed
 
+        # FIXME remove the need for determine_filetype
         def determine_filetype(data: str) -> str:
-            return data
+            return file_format
 
         return eval_Import_general(
-            findfile, determine_filetype, elements, evaluation, options, data
+            findfile, determine_filetype, elements, evaluation, options
         )
 
     # In contrast to Import[source_], we allow an explicit format type
@@ -481,7 +483,7 @@ def eval_with_single_element(self, source, elt: String, evaluation, options={}):
         # The code below tests for the first case, and if that fails assumes the
         # second case.
         file_format = elt.value.upper()
-        if file_format in IMPORTERS.keys():
+        if file_format in importexport.IMPORTERS.keys():
             # A file format was specified: use the custom routine
             return eval_Import_source_only(findfile, file_format, evaluation, options)
 
@@ -563,7 +565,7 @@ def eval_with_single_element(self, data, elt: String, evaluation, options={}):
         # The code below tests for the first case, and if that fails assumes the
         # second case.
         file_format = elt.value.upper()
-        if file_format in IMPORTERS.keys():
+        if file_format in importexport.IMPORTERS.keys():
             # A file format was specified: use the custom routine
             return eval_Import_data_only(data.value, file_format, evaluation, options)
 

mathics/eval/import_export/compression.py

@@ -6,6 +6,7 @@
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
+from mathics.core.symbols import SymbolNull
 from mathics.core.systemsymbols import SymbolFailed, SymbolRule
 from mathics.eval.import_export.importexport import (
     IMPORTERS,
@@ -17,42 +18,62 @@
 def eval_ImportZIP(
     zip_path: str, evaluation: Evaluation, members: Optional[list[str]] = None
 ) -> ListExpression:
-    """Takes a ZIP file path and returns a list of file names/paths contained inside."""
-    with zipfile.ZipFile(zip_path, "r") as archive:
-        if members is None:
-            filenames = archive.namelist()
-            mathics_filenames = to_mathics_list(*filenames)
-            exprs = [
-                Expression(
-                    SymbolRule,
-                    String("FileNames"),
-                    mathics_filenames,
-                ),
-                Expression(
-                    SymbolRule,
-                    String("Summary"),
-                    mathics_filenames,
-                ),
-            ]
-
-            if filenames:
-                for filename in filenames:
-                    exprs.append(
-                        Expression(
-                            SymbolRule,
-                            String(filename),
-                            String(archive.read(filename).decode("utf-8")),
+    """If `members` is empty, this function takes a ZIP file path and returns a
+    list of file names/paths contained inside.
+
+    "If `members` is given, then extract those members from the ZIP file.
+    """
+    try:
+        with zipfile.ZipFile(zip_path, "r") as archive:
+            if members is None:
+                filenames = archive.namelist()
+                mathics_filenames = to_mathics_list(*filenames)
+                exprs = [
+                    Expression(
+                        SymbolRule,
+                        String("FileNames"),
+                        mathics_filenames,
+                    ),
+                    Expression(
+                        SymbolRule,
+                        String("Summary"),
+                        mathics_filenames,
+                    ),
+                ]
+
+                if filenames:
+                    for filename in filenames:
+                        exprs.append(
+                            Expression(
+                                SymbolRule,
+                                String(filename),
+                                String(archive.read(filename).decode("utf-8")),
+                            )
                         )
-                    )
 
-            return ListExpression(*exprs)
+                return ListExpression(*exprs)
+
+            if members.has_form("List", None):
+                elements = members.get_elements()
+            else:
+                elements = [members]
 
-        for member in members:
-            file_format = infer_file_format(member).upper()
-            if file_format not in IMPORTERS.keys():
-                evaluation.message("Import", "fmtnosup", file_format)
-                return SymbolFailed
+            for element in elements:
+                member = element.value
+                file_format = infer_file_format(member).upper()
+                if file_format not in IMPORTERS.keys():
+                    evaluation.message("Import", "fmtnosup", file_format)
+                    return SymbolFailed
 
-            file_data = archive.read(member)
-            # FIXME: this handles one member. What do we do if we have more?
-            return eval_Import_data_only(file_data.value, file_format, evaluation, {})
+                file_data = archive.read(member).decode("utf-8")
+                # FIXME: this handles one member. What do we do if we have more?
+                return eval_Import_data_only(file_data, file_format, evaluation, {})
+    except FileNotFoundError:
+        evaluation.message("Import", "nffil", String(zip_path))
+        return SymbolFailed
+    except PermissionError:
+        evaluation.message("Import", "noopen", String(zip_path))
+        return SymbolFailed
+    except Exception:
+        # This seems to be what WMA does.
+        return SymbolNull

mathics/eval/import_export/importexport.py

@@ -20,6 +20,7 @@
     SymbolByteArray,
     SymbolFailed,
     SymbolInputStream,
+    SymbolNone,
     SymbolOpenWrite,
     SymbolRule,
     SymbolStringToStream,
@@ -37,7 +38,7 @@
 IMPORTERS = {}
 
 # TODO: This hard-coded dictionary should be
-# accessile from the WL API, and be user modifiable.
+# accessible from the WL API, and be user modifiable.
 FILE_EXTENSION_MAP: dict[str, str] = {
     "bmp": "BMP",
     "gif": "GIF",
@@ -219,7 +220,7 @@ def importer_exporter_options(
 
 def eval_FileFormat(path: str) -> String:
     """
-    Basic implemenation beind FileFormat[filename].
+    Basic implementation behind FileFormat[filename].
     """
     return String(filetype_from_path(path))
 
@@ -230,10 +231,10 @@ def eval_Import_general(
     elements,
     evaluation: Evaluation,
     options,
-    data: Optional[str],
+    data: Optional[str] = None,
 ):
     """
-    Basic implementation beind most general kind of Import[source, elements, options].
+    Basic implementation behind most general kind of Import[source, elements, options].
     """
 
     current_predetermined_out = evaluation.predetermined_out
@@ -252,12 +253,13 @@ def eval_Import_general(
     elements = [el.value for el in elements]
 
     # Determine file format
-    for el in elements:
+    file_format = None
+    for el in elements.copy():
         if el.upper() in IMPORTERS.keys():
             file_format = el.upper()
             elements.remove(el)
-            break
-    else:
+
+    if file_format is None:
         filetype = determine_filetype(data)
         file_format = MIME_SHORTNAME_TO_WMA.get(filetype, filetype).upper()
 
@@ -331,7 +333,37 @@ def eval_Import_general(
         assert len(elements) >= 1
         el = elements[0]
         if el == "Elements":
-            return eval_Import_Elements(file_format, evaluation)
+            if (
+                result := eval_Import_Elements(file_format, evaluation)
+            ) is not SymbolNone:
+                return result
+            # A list of "Elements" is not obtainable via AvailableElements listed when
+            # ImportExport`RegisterImport was used. Get a list of the field names via
+            # the the "defaults" and "conditional" keys.
+            defaults = get_results(
+                default_function,
+                findfile,
+                function_channels,
+                stream_options,
+                custom_options,
+                evaluation,
+                options,
+                data=data,
+            )
+            if defaults is None:
+                evaluation.predetermined_out = current_predetermined_out
+                return SymbolFailed
+            # 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(
@@ -342,8 +374,8 @@ def eval_Import_general(
                     custom_options,
                     evaluation,
                     options,
-                    data=data,
                     elements=elements,
+                    data=data,
                 )
                 if result is None:
                     evaluation.predetermined_out = current_predetermined_out
@@ -378,7 +410,7 @@ def eval_Import_general(
                     return SymbolFailed
 
 
-def eval_Import_Elements(file_format: str, evaluation: Evaluation):
+def eval_Import_Elements(file_format: str, evaluation):
     """
     Basic implementation behind Import[fileformat, Elements].
     This returns the element names that can be used for a specific
@@ -484,7 +516,7 @@ def eval_Import_data_only(
     options,
 ):
     """
-    Basic implementation beind Import_String[data].
+    Basic implementation behind Import_String[data].
     Here, no elements were given, just a import data string.
     """
 
@@ -560,7 +592,7 @@ def eval_Import_source_only(
     options,
 ):
     """
-    Basic implementation beind Import[source].
+    Basic implementation behind Import[source].
     Here, no elements were given, just a import source.
     """
 
@@ -638,7 +670,7 @@ def get_results_for_element_args(
     elements: list,
 ):
     """
-    Return Import results when elemnet args are given.
+    Return Import results when element args are given.
     For example:
       Import["ExampleData/ExampleData.txt", "Lines"]
                                             ^^^^^^^

test/builtin/import_export/test_importexport.py

@@ -171,33 +171,41 @@ def test_export():
             'Import["ExampleData/Testosterone.svg", "xml"] // Head',
             None,
             "XMLObject[Document]",
-            "Case use in explicit format name should not be significant",
+            "format case (xml) is not significant",
         ),
         (
             'Import["ExampleData/Testosterone.svg", "Xml"] // Head',
             None,
             "XMLObject[Document]",
-            "Case use in explicit format name should not be significant",
+            "format case (Xml) is not significant",
         ),
         (
             'Import["ExampleData/Testosterone.svg", {"XML"}] // Head',
             None,
             "XMLObject[Document]",
             None,
         ),
-        (
-            'Import["ExampleData/Testosterone.svg", {"XML", "XML"}];',
-            ("The Import element XML is not present when importing as XML.",),
-            "Null",
-            None,
-        ),
+        # This test does not match WMA. We are supposed to treat
+        # {"XML", "XML"} like, "XML" and not give an error.
+        # (
+        #     'Import["ExampleData/Testosterone.svg", {"XML", "XML"}];',
+        #     ("The Import element XML is not present when importing as XML.",),
+        #     "Null",
+        #     None,
+        # ),
         # XML
-        (
-            'MatchQ[Import["ExampleData/InventionNo1.xml", "Tags"],{__String}]',
-            None,
-            "True",
-            None,
-        ),
+        # This test does not match WMA. WMA gives:
+        # XML`Parser`XMLGet::prserr:
+        # NetAccessorException: Could not open file:
+        # http://www.musicxml.org/dtds/partwise.dtd at Line: 2 Character: 123 in
+        # InventionNo1.xml.
+        # Import::fmterr: Cannot import data as XML format.
+        # (
+        #     'MatchQ[Import["ExampleData/InventionNo1.xml", "Tags"],{__String}]',
+        #     None,
+        #     "True",
+        #     None,
+        # ),
         ("ImportString[x]", ("First argument x is not a string.",), "$Failed", None),
         # CSV
         (