python-stdlib/zipfile: Add read-only zipfile module.

python-stdlib/zipfile/manifest.py

@@ -0,0 +1,2 @@
+metadata(version="0.1.0")
+package("zipfile")

python-stdlib/zipfile/test_zipfile.py

@@ -0,0 +1,117 @@
+import zipfile
+import unittest
+
+# TODO: Find out which archiver can create ZSTD blobs
+null_zip_contents = (
+    ("null_bzip2.bin", 12, 4096, 46, (2026, 9, 4, 10, 1, 28), 0xC71C0011),
+    ("null_deflate.bin", zipfile.ZIP_DEFLATED, 4096, 20, (2026, 9, 4, 10, 1, 32), 0xC71C0011),
+    ("null_lzma.bin", 14, 4096, 41, (2026, 9, 4, 10, 1, 32), 0xC71C0011),
+    ("null_stored.bin", zipfile.ZIP_STORED, 4096, 4096, (2026, 9, 4, 10, 1, 20), 0xC71C0011),
+)
+
+deflate_zip_contents = (
+    ("directory/", True, 0, 0, 0, None),
+    ("directory/hello_again.txt", False, 6656, 66, 0x946f8D8C, b"Hello again, MicroPython!\n"),
+    ("empty", False, 0, 0, 0, None),
+    ("hello.txt", False, 5120, 57, 0xA89fD9B3, b"Hello, MicroPython!\n"),
+)
+
+stored_zip_contents = (
+    ("directory/", True, 0, 0, 0, None),
+    ("directory/hello_again.txt", False, 6656, 6656, 0x946f8D8C, b"Hello again, MicroPython!\n"),
+    ("empty", False, 0, 0, 0, None),
+    ("hello.txt", False, 5120, 5120, 0xA89fD9B3, b"Hello, MicroPython!\n"),
+)
+
+
+class TestZipFile(unittest.TestCase):
+    def check_header(self, file, expected):
+        name, method, uncompressed_size, compressed_size, timestamp, crc32 = expected
+        self.assertEqual(name, file.filename)
+        self.assertEqual(method, file.compress_type)
+        self.assertEqual(uncompressed_size, file.file_size)
+        self.assertEqual(compressed_size, file.compress_size)
+        self.assertEqual(timestamp, file.date_time)
+        self.assertEqual(crc32, file.CRC)
+
+    def test_null_iter(self):
+        zf = zipfile.ZipFile("null.zip")
+        for index, info in enumerate(zf.infolist()):
+            self.check_header(info, null_zip_contents[index])
+        zf.close()
+
+    def test_null_contents_read(self):
+        zf = zipfile.ZipFile("null.zip")
+        expected = bytes(4096)
+        for index, name in enumerate(zf.namelist()):
+            self.assertEqual(name, null_zip_contents[index][0])
+            try:
+                data = zf.read(name)
+                self.assertEqual(len(data), 4096)
+                self.assertEqual(data, expected)
+            except NotImplementedError:
+                if null_zip_contents[index][1] not in (zipfile.ZIP_DEFLATED, zipfile.ZIP_STORED):
+                    pass
+        zf.close()
+
+    def test_null_getinfo(self):
+        zf = zipfile.ZipFile("null.zip")
+        for zc in null_zip_contents:
+            info = zf.getinfo(zc[0])
+            self.check_header(info, zc)
+        zf.close()
+
+    def test_null_open(self):
+        zf = zipfile.ZipFile("null.zip")
+        expected = bytes(4096)
+        for zc in null_zip_contents:
+            info = zf.getinfo(zc[0])
+            try:
+                with zf.open(info.filename) as f:
+                    self.assertEqual(expected, f.read())
+            except NotImplementedError:
+                if info.compress_type not in (zipfile.ZIP_DEFLATED, zipfile.ZIP_STORED):
+                    pass
+        zf.close()
+
+    def test_context(self):
+        with zipfile.ZipFile("null.zip") as zf:
+            for index, info in enumerate(zf.infolist()):
+                self.check_header(info, null_zip_contents[index])
+
+    def test_close(self):
+        zf = zipfile.ZipFile("null.zip")
+        zf.close()
+        zf.close()  # check this doesn't raise
+        with self.assertRaises(ValueError):
+            zf.namelist()
+        with self.assertRaises(ValueError):
+            zf.infolist()
+        with self.assertRaises(ValueError):
+            zf.open(null_zip_contents[0][0])
+        with self.assertRaises(ValueError):
+            zf.read(null_zip_contents[0][0])
+
+    def check_contents(self, zf, found, expected, method):
+            self.assertEqual(found.is_dir(), expected[1])
+            self.assertEqual(found.file_size, expected[2])
+            self.assertEqual(found.compress_size, expected[3])
+            self.assertEqual(found.CRC, expected[4])
+            self.assertEqual(found.compress_type, zipfile.ZIP_STORED if expected[2] == 0 else method)
+            if payload := expected[5]:
+                data = payload * 256
+                with zf.open(expected[0]) as f:
+                    self.assertEqual(f.read(), data)
+                self.assertEqual(zf.read(expected[0]), data)
+
+    def test_read_deflate(self):
+        with zipfile.ZipFile("deflate.zip") as zf:
+            for file in deflate_zip_contents:
+                info = zf.getinfo(file[0])
+                self.check_contents(zf, info, file, zipfile.ZIP_DEFLATED)
+
+    def test_read_stored(self):
+        with zipfile.ZipFile("stored.zip") as zf:
+            for file in stored_zip_contents:
+                info = zf.getinfo(file[0])
+                self.check_contents(zf, info, file, zipfile.ZIP_STORED)