fix(vendor): stop get() minting; _missing_ fixed for 21 of 105 (#775)

docs/source/pcapkit/toolkit/3rdparty.rst

@@ -82,6 +82,8 @@ usable for its caller.
 
 .. autofunction:: pcapkit.toolkit.pyshark.tcp_traceflow
 
+.. autodata:: pcapkit.toolkit.pyshark.FILTER_NAME_TO_LINKTYPE
+
 Auxiliary Functions
 -------------------
 

pcapkit/const/arp/hardware.py

@@ -165,9 +165,52 @@ def get(key: 'int | str', default: 'int' = -1) -> 'Hardware':
                 if default == -1:
                     raise
                 return Hardware(default)
-        if key not in Hardware._member_map_:  # pylint: disable=no-member
-            return extend_enum(Hardware, key, default)
-        return Hardware[key]  # type: ignore[misc]
+        try:
+            return Hardware[key]  # type: ignore[misc]
+        except KeyError:
+            if default == -1:
+                raise
+            return Hardware(default)
+
+    @classmethod
+    def register(cls, value: 'int', name: 'str') -> 'Hardware':
+        """Explicitly register a new member.
+
+        Unlike :meth:`get` and :meth:`_missing_`, which resolve a key or a
+        value without minting anything new, this is the caller-named entry
+        point that still grows the registry, via :func:`aenum.extend_enum`.
+
+        Args:
+            value: Value of the new member.
+            name: Name of the new member.
+
+        Returns:
+            The newly registered member.
+
+        """
+        return extend_enum(cls, name, value)
+
+    @classmethod
+    def _unregistered_member(cls, value: 'int', name: 'str') -> 'Hardware':
+        """Build a member absent from this registry's own lookup tables.
+
+        Used by :meth:`_missing_` for a bounded-but-unassigned value it
+        resolves without anyone asking for a name, so that such a lookup no
+        longer grows the registry -- contrast :meth:`register`, the explicit
+        path that still does.
+
+        Args:
+            value: The member's value.
+            name: The member's name.
+
+        Returns:
+            The unregistered member.
+
+        """
+        obj = int.__new__(cls, value)
+        obj._name_ = name  # pylint: disable=protected-access
+        obj._value_ = value  # pylint: disable=protected-access
+        return obj
 
     @classmethod
     def _missing_(cls, value: 'int') -> 'Hardware':
@@ -181,8 +224,8 @@ def _missing_(cls, value: 'int') -> 'Hardware':
             raise ValueError('%r is not a valid %s' % (value, cls.__name__))
         if 39 <= value <= 255:
             #: Unassigned
-            return extend_enum(cls, 'Unassigned_%d' % value, value)
+            return cls._unregistered_member(value, 'Unassigned')
         if 258 <= value <= 65534:
             #: Unassigned
-            return extend_enum(cls, 'Unassigned_%d' % value, value)
+            return cls._unregistered_member(value, 'Unassigned')
         return super()._missing_(value)

pcapkit/const/arp/operation.py

@@ -118,9 +118,52 @@ def get(key: 'int | str', default: 'int' = -1) -> 'Operation':
                 if default == -1:
                     raise
                 return Operation(default)
-        if key not in Operation._member_map_:  # pylint: disable=no-member
-            return extend_enum(Operation, key, default)
-        return Operation[key]  # type: ignore[misc]
+        try:
+            return Operation[key]  # type: ignore[misc]
+        except KeyError:
+            if default == -1:
+                raise
+            return Operation(default)
+
+    @classmethod
+    def register(cls, value: 'int', name: 'str') -> 'Operation':
+        """Explicitly register a new member.
+
+        Unlike :meth:`get` and :meth:`_missing_`, which resolve a key or a
+        value without minting anything new, this is the caller-named entry
+        point that still grows the registry, via :func:`aenum.extend_enum`.
+
+        Args:
+            value: Value of the new member.
+            name: Name of the new member.
+
+        Returns:
+            The newly registered member.
+
+        """
+        return extend_enum(cls, name, value)
+
+    @classmethod
+    def _unregistered_member(cls, value: 'int', name: 'str') -> 'Operation':
+        """Build a member absent from this registry's own lookup tables.
+
+        Used by :meth:`_missing_` for a bounded-but-unassigned value it
+        resolves without anyone asking for a name, so that such a lookup no
+        longer grows the registry -- contrast :meth:`register`, the explicit
+        path that still does.
+
+        Args:
+            value: The member's value.
+            name: The member's name.
+
+        Returns:
+            The unregistered member.
+
+        """
+        obj = int.__new__(cls, value)
+        obj._name_ = name  # pylint: disable=protected-access
+        obj._value_ = value  # pylint: disable=protected-access
+        return obj
 
     @classmethod
     def _missing_(cls, value: 'int') -> 'Operation':
@@ -134,5 +177,5 @@ def _missing_(cls, value: 'int') -> 'Operation':
             raise ValueError('%r is not a valid %s' % (value, cls.__name__))
         if 26 <= value <= 65534:
             #: Unassigned
-            return extend_enum(cls, 'Unassigned_%d' % value, value)
+            return cls._unregistered_member(value, 'Unassigned')
         return super()._missing_(value)

pcapkit/const/esp/cipher.py

@@ -235,9 +235,52 @@ def get(key: 'int | str', default: 'int' = -1) -> 'Cipher':
                 if default == -1:
                     raise
                 return Cipher(default)
-        if key not in Cipher._member_map_:  # pylint: disable=no-member
-            return extend_enum(Cipher, key, default)
-        return Cipher[key]  # type: ignore[misc]
+        try:
+            return Cipher[key]  # type: ignore[misc]
+        except KeyError:
+            if default == -1:
+                raise
+            return Cipher(default)
+
+    @classmethod
+    def register(cls, value: 'int', name: 'str') -> 'Cipher':
+        """Explicitly register a new member.
+
+        Unlike :meth:`get` and :meth:`_missing_`, which resolve a key or a
+        value without minting anything new, this is the caller-named entry
+        point that still grows the registry, via :func:`aenum.extend_enum`.
+
+        Args:
+            value: Value of the new member.
+            name: Name of the new member.
+
+        Returns:
+            The newly registered member.
+
+        """
+        return extend_enum(cls, name, value)
+
+    @classmethod
+    def _unregistered_member(cls, value: 'int', name: 'str') -> 'Cipher':
+        """Build a member absent from this registry's own lookup tables.
+
+        Used by :meth:`_missing_` for a bounded-but-unassigned value it
+        resolves without anyone asking for a name, so that such a lookup no
+        longer grows the registry -- contrast :meth:`register`, the explicit
+        path that still does.
+
+        Args:
+            value: The member's value.
+            name: The member's name.
+
+        Returns:
+            The unregistered member.
+
+        """
+        obj = int.__new__(cls, value)
+        obj._name_ = name  # pylint: disable=protected-access
+        obj._value_ = value  # pylint: disable=protected-access
+        return obj
 
     @classmethod
     def _missing_(cls, value: 'int') -> 'Cipher':

pcapkit/const/esp/integrity.py

@@ -124,9 +124,52 @@ def get(key: 'int | str', default: 'int' = -1) -> 'Integrity':
                 if default == -1:
                     raise
                 return Integrity(default)
-        if key not in Integrity._member_map_:  # pylint: disable=no-member
-            return extend_enum(Integrity, key, default)
-        return Integrity[key]  # type: ignore[misc]
+        try:
+            return Integrity[key]  # type: ignore[misc]
+        except KeyError:
+            if default == -1:
+                raise
+            return Integrity(default)
+
+    @classmethod
+    def register(cls, value: 'int', name: 'str') -> 'Integrity':
+        """Explicitly register a new member.
+
+        Unlike :meth:`get` and :meth:`_missing_`, which resolve a key or a
+        value without minting anything new, this is the caller-named entry
+        point that still grows the registry, via :func:`aenum.extend_enum`.
+
+        Args:
+            value: Value of the new member.
+            name: Name of the new member.
+
+        Returns:
+            The newly registered member.
+
+        """
+        return extend_enum(cls, name, value)
+
+    @classmethod
+    def _unregistered_member(cls, value: 'int', name: 'str') -> 'Integrity':
+        """Build a member absent from this registry's own lookup tables.
+
+        Used by :meth:`_missing_` for a bounded-but-unassigned value it
+        resolves without anyone asking for a name, so that such a lookup no
+        longer grows the registry -- contrast :meth:`register`, the explicit
+        path that still does.
+
+        Args:
+            value: The member's value.
+            name: The member's name.
+
+        Returns:
+            The unregistered member.
+
+        """
+        obj = int.__new__(cls, value)
+        obj._name_ = name  # pylint: disable=protected-access
+        obj._value_ = value  # pylint: disable=protected-access
+        return obj
 
     @classmethod
     def _missing_(cls, value: 'int') -> 'Integrity':

pcapkit/const/hip/certificate.py

@@ -64,9 +64,52 @@ def get(key: 'int | str', default: 'int' = -1) -> 'Certificate':
                 if default == -1:
                     raise
                 return Certificate(default)
-        if key not in Certificate._member_map_:  # pylint: disable=no-member
-            return extend_enum(Certificate, key, default)
-        return Certificate[key]  # type: ignore[misc]
+        try:
+            return Certificate[key]  # type: ignore[misc]
+        except KeyError:
+            if default == -1:
+                raise
+            return Certificate(default)
+
+    @classmethod
+    def register(cls, value: 'int', name: 'str') -> 'Certificate':
+        """Explicitly register a new member.
+
+        Unlike :meth:`get` and :meth:`_missing_`, which resolve a key or a
+        value without minting anything new, this is the caller-named entry
+        point that still grows the registry, via :func:`aenum.extend_enum`.
+
+        Args:
+            value: Value of the new member.
+            name: Name of the new member.
+
+        Returns:
+            The newly registered member.
+
+        """
+        return extend_enum(cls, name, value)
+
+    @classmethod
+    def _unregistered_member(cls, value: 'int', name: 'str') -> 'Certificate':
+        """Build a member absent from this registry's own lookup tables.
+
+        Used by :meth:`_missing_` for a bounded-but-unassigned value it
+        resolves without anyone asking for a name, so that such a lookup no
+        longer grows the registry -- contrast :meth:`register`, the explicit
+        path that still does.
+
+        Args:
+            value: The member's value.
+            name: The member's name.
+
+        Returns:
+            The unregistered member.
+
+        """
+        obj = int.__new__(cls, value)
+        obj._name_ = name  # pylint: disable=protected-access
+        obj._value_ = value  # pylint: disable=protected-access
+        return obj
 
     @classmethod
     def _missing_(cls, value: 'int') -> 'Certificate':
@@ -80,5 +123,5 @@ def _missing_(cls, value: 'int') -> 'Certificate':
             raise ValueError('%r is not a valid %s' % (value, cls.__name__))
         if 9 <= value <= 255:
             #: Unassigned
-            return extend_enum(cls, 'Unassigned_%d' % value, value)
+            return cls._unregistered_member(value, 'Unassigned')
         return super()._missing_(value)

pcapkit/const/hip/cipher.py

@@ -52,9 +52,52 @@ def get(key: 'int | str', default: 'int' = -1) -> 'Cipher':
                 if default == -1:
                     raise
                 return Cipher(default)
-        if key not in Cipher._member_map_:  # pylint: disable=no-member
-            return extend_enum(Cipher, key, default)
-        return Cipher[key]  # type: ignore[misc]
+        try:
+            return Cipher[key]  # type: ignore[misc]
+        except KeyError:
+            if default == -1:
+                raise
+            return Cipher(default)
+
+    @classmethod
+    def register(cls, value: 'int', name: 'str') -> 'Cipher':
+        """Explicitly register a new member.
+
+        Unlike :meth:`get` and :meth:`_missing_`, which resolve a key or a
+        value without minting anything new, this is the caller-named entry
+        point that still grows the registry, via :func:`aenum.extend_enum`.
+
+        Args:
+            value: Value of the new member.
+            name: Name of the new member.
+
+        Returns:
+            The newly registered member.
+
+        """
+        return extend_enum(cls, name, value)
+
+    @classmethod
+    def _unregistered_member(cls, value: 'int', name: 'str') -> 'Cipher':
+        """Build a member absent from this registry's own lookup tables.
+
+        Used by :meth:`_missing_` for a bounded-but-unassigned value it
+        resolves without anyone asking for a name, so that such a lookup no
+        longer grows the registry -- contrast :meth:`register`, the explicit
+        path that still does.
+
+        Args:
+            value: The member's value.
+            name: The member's name.
+
+        Returns:
+            The unregistered member.
+
+        """
+        obj = int.__new__(cls, value)
+        obj._name_ = name  # pylint: disable=protected-access
+        obj._value_ = value  # pylint: disable=protected-access
+        return obj
 
     @classmethod
     def _missing_(cls, value: 'int') -> 'Cipher':
@@ -68,5 +111,5 @@ def _missing_(cls, value: 'int') -> 'Cipher':
             raise ValueError('%r is not a valid %s' % (value, cls.__name__))
         if 5 <= value <= 65535:
             #: Unassigned
-            return extend_enum(cls, 'Unassigned_%d' % value, value)
+            return cls._unregistered_member(value, 'Unassigned')
         return super()._missing_(value)