Rework and optimize _Extra

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

Remove `.read_one()` since it has never been used and is now obsolete.

Make `_Extra` a normal class rather than a subclass of `bytes`, which
is imperformant by having to copy the passed bytes when instantiated.

Author: danny0838

Lib/zipfile/__init__.py

@@ -195,50 +195,45 @@ 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."""
         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, True)
+            if xid is not None
         }
         # New fields first since data may have a corrupted tail that renders
         # following fields inaccessible.
@@ -600,8 +595,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)