Rework and optimize _Extra

Make `_Extra` a normal class rather than a subclass of `bytes`,
avoiding the performance penalty of copying the passed bytes upon each
instantiation.

Introduce `.iter()` in place of `.strip()` to yield each subfield info
as a tuple. This provides better semantics and is more performant than
subclassing `bytes`. The method name change also enables feature
detection for these behavior changes.

Stop using memoryview internally because each slice creates an overhead
of around 184 bytes, making it inefficient for small bytes operations
(each extra field is usually only several to tens of bytes).

Remove `.read_one()` since it is now unused and obsolete.

Author: danny0838

Lib/zipfile/__init__.py

@@ -195,53 +195,53 @@ class LargeZipFile(Exception):
 _DD_SIGNATURE = 0x08074b50
 
 
-class _Extra(bytes):
+class _Extra:
     FIELD_STRUCT = struct.Struct('<HH')
 
-    def __new__(cls, val, id=None):
-        return super().__new__(cls, val)
-
-    def __init__(self, val, id=None):
-        self.id = id
-
     @classmethod
-    def read_one(cls, raw, validate=False):
-        try:
-            xid, xlen = cls.FIELD_STRUCT.unpack_from(raw)
-        except struct.error:
-            xid, xlen = None, 0
-        else:
-            if validate and xlen + 4 > len(raw):
-                raise BadZipFile("Corrupt extra field %04x (size=%d)" % (xid, xlen))
-        return cls(raw[:4+xlen], xid), raw[4+xlen:]
+    def iter(cls, data, validate=False):
+        """Iter through and yield each (field, id)."""
+        # early return for empty extra data
+        if not data:
+            return
 
-    @classmethod
-    def split(cls, data, validate=False):
-        # use memoryview for zero-copy slices
-        rest = memoryview(data)
-        while rest:
-            extra, rest = cls.read_one(rest, validate=validate)
-            yield extra
+        pos, data_len = 0, len(data)
+        while pos < data_len:
+            try:
+                xid, xlen = cls.FIELD_STRUCT.unpack_from(data, pos)
+            except struct.error:
+                xid, xlen = None, 0
+            else:
+                if validate and pos + 4 + xlen > data_len:
+                    raise BadZipFile(
+                        "Corrupt extra field %04x (size=%d)" % (xid, xlen))
+            yield data[pos:pos + 4 + xlen], xid
+            pos += 4 + xlen
 
     @classmethod
     def strip(cls, data, xids):
         """Remove Extra fields with specified IDs."""
         return b''.join(
             ex
-            for ex in cls.split(data)
-            if ex.id not in xids
+            for ex, xid in cls.iter(data)
+            if xid not in xids
         )
 
     @classmethod
     def update(cls, data, extra):
         """Insert fields from extra and strip duplicates."""
+        # early return for empty data
+        if not data:
+            return extra
+
         extras = {
-            ex.id: ex
-            for ex in cls.split(extra, True)
-            if ex.id is not None
+            xid: ex
+            for ex, xid in cls.iter(extra)
+            if xid is not None
         }
         # New fields first since data may have a corrupted tail that renders
-        # following fields inaccessible.
+        # following fields inaccessible.  (The caller is responsible for making
+        # sure that extra is valid.)
         return b''.join(extras.values()) + cls.strip(data, extras)
 
 
@@ -600,8 +600,7 @@ def _encodeFilenameFlags(self):
     def _decodeExtra(self, filename_crc):
         # Try to decode the extra field.
         unpack = struct.unpack
-        for extra in _Extra.split(self.extra, True):
-            tp = extra.id
+        for extra, tp in _Extra.iter(self.extra, True):
             if tp == 0x0001:
                 data = extra[4:]
                 # ZIP64 extension (large files and/or large archives)