refactor: Store Buffer directly in attribute _packed fields

Remove unnecessary bytes() conversions throughout attribute classes.
The _packed field now stores Buffer (bytes or memoryview) directly,
avoiding copies when data comes from memoryview slices.

Changes:
- Update __init__ signatures to accept Buffer instead of bytes
- Remove data_bytes = bytes(data) patterns in from_packet() methods
- Use data directly for length checks and comparisons
- Update tests to use factory methods instead of raw constructors

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: thomas-mangin

src/exabgp/bgp/message/open/asn.py

@@ -7,12 +7,12 @@
 
 from __future__ import annotations
 
+from collections.abc import Buffer
 from struct import pack, unpack
 from typing import Type
 
 from exabgp.protocol.resource import Resource
 
-
 # =================================================================== ASN
 
 
@@ -36,7 +36,7 @@ def pack_asn(self, asn4: bool) -> bytes:
         return pack('!L' if asn4 else '!H', self)
 
     @classmethod
-    def unpack_asn(cls: Type[ASN], data: bytes, klass: Type[ASN]) -> ASN:
+    def unpack_asn(cls: Type[ASN], data: Buffer, klass: Type[ASN]) -> ASN:
         kls = klass
         if len(data) == cls.SIZE_4BYTE:
             value = unpack('!L', data)[0]

src/exabgp/bgp/message/open/routerid.py

@@ -6,21 +6,20 @@
 """
 
 from __future__ import annotations
+
+from collections.abc import Buffer
 from typing import Type
 
-from exabgp.protocol.family import AFI
 from exabgp.protocol.ip import IPv4
 
 # ===================================================================== RouterID
 #
 
 
 class RouterID(IPv4):
-    def __init__(self, ip: str, packed: bytes | None = None) -> None:
-        if IPv4.toafi(ip) != AFI.ipv4:
-            raise ValueError('wrong address family')
-        IPv4.__init__(self, ip, packed)
+    def __init__(self, ip: str) -> None:
+        IPv4.__init__(self, IPv4.pton(ip))
 
     @classmethod
-    def unpack_routerid(cls: Type[RouterID], data: bytes) -> RouterID:  # pylint: disable=W0221
-        return cls('.'.join(str(_) for _ in data), data)
+    def unpack_routerid(cls: Type[RouterID], data: Buffer) -> RouterID:
+        return cls(IPv4.ntop(data))

src/exabgp/bgp/message/update/__init__.py

@@ -19,7 +19,7 @@
 from exabgp.bgp.message.notification import Notify
 from exabgp.bgp.message.update.attribute import MPRNLRI, MPURNLRI, Attribute, AttributeCollection
 from exabgp.bgp.message.update.eor import EOR
-from exabgp.bgp.message.update.nlri import NLRI, NLRICollection, MPNLRICollection
+from exabgp.bgp.message.update.nlri import NLRI, MPNLRICollection, NLRICollection
 from exabgp.logger import lazyformat, lazymsg, log
 from exabgp.protocol.family import AFI, SAFI
 from exabgp.protocol.ip import IP
@@ -650,17 +650,16 @@ def unpack_message(cls, data: Buffer, negotiated: Negotiated) -> 'UpdateCollecti
         This method is kept for backward compatibility.
         """
         # Convert to bytes for comparison and downstream parsing
-        data_bytes = bytes(data) if isinstance(data, memoryview) else data
-        length = len(data_bytes)
+        length = len(data)
 
         # Check for End-of-RIB markers (fast path)
-        if length == EOR_IPV4_UNICAST_LENGTH and data_bytes == b'\x00\x00\x00\x00':
+        if length == EOR_IPV4_UNICAST_LENGTH and data == b'\x00\x00\x00\x00':
             return EOR(AFI.ipv4, SAFI.unicast)
-        if length == EOR_WITH_PREFIX_LENGTH and data_bytes.startswith(EOR.NLRI.PREFIX):
-            return EOR.unpack_message(data_bytes, negotiated)
+        if length == EOR_WITH_PREFIX_LENGTH and data.startswith(EOR.NLRI.PREFIX):
+            return EOR.unpack_message(data, negotiated)
 
         # Parse normally
-        return cls._parse_payload(data_bytes, negotiated)
+        return cls._parse_payload(data, negotiated)
 
 
 # Backward compatibility aliases

src/exabgp/bgp/message/update/attribute/aggregator.py

@@ -67,11 +67,10 @@ def from_packet(cls, data: Buffer, asn4: bool) -> 'Aggregator':
         Raises:
             ValueError: If data length is invalid
         """
-        data_bytes = bytes(data)
         expected_len = 8 if asn4 else 6
-        if len(data_bytes) != expected_len:
-            raise ValueError(f'Aggregator must be {expected_len} bytes for asn4={asn4}, got {len(data_bytes)}')
-        return cls(data_bytes, asn4)
+        if len(data) != expected_len:
+            raise ValueError(f'Aggregator must be {expected_len} bytes for asn4={asn4}, got {len(data)}')
+        return cls(data, asn4)
 
     @classmethod
     def make_aggregator(cls, asn: ASN, speaker: IPv4) -> 'Aggregator':
@@ -181,10 +180,9 @@ def from_packet(cls, data: Buffer, asn4: bool = True) -> 'Aggregator4':
 
         AS4_AGGREGATOR always uses 4-byte ASNs.
         """
-        data_bytes = bytes(data)
-        if len(data_bytes) != 8:
-            raise ValueError(f'AS4_AGGREGATOR must be 8 bytes, got {len(data_bytes)}')
-        return cls(data_bytes)
+        if len(data) != 8:
+            raise ValueError(f'AS4_AGGREGATOR must be 8 bytes, got {len(data)}')
+        return cls(data)
 
     @classmethod
     def make_aggregator(cls, asn: ASN, speaker: IPv4) -> 'Aggregator4':

src/exabgp/bgp/message/update/attribute/aigp.py

@@ -8,16 +8,14 @@
 from __future__ import annotations
 
 from collections.abc import Buffer
-from struct import pack
-from struct import unpack
+from struct import pack, unpack
 from typing import TYPE_CHECKING, ClassVar
 
 if TYPE_CHECKING:
     from exabgp.bgp.message.open.capability.negotiated import Negotiated
 
 from exabgp.bgp.message.update.attribute.attribute import Attribute
 
-
 # ========================================================================== TLV
 #
 
@@ -53,7 +51,7 @@ class AIGP(Attribute):
     _TLV_HEADER: ClassVar[bytes] = b'\x01\x00\x0b'
     _TLV_LENGTH: ClassVar[int] = 11
 
-    def __init__(self, packed: bytes) -> None:
+    def __init__(self, packed: Buffer) -> None:
         """Initialize AIGP from packed TLV bytes.
 
         NO validation - trusted internal use only.
@@ -62,7 +60,7 @@ def __init__(self, packed: bytes) -> None:
         Args:
             packed: Raw TLV bytes (11 bytes: 1 type + 2 length + 8 value)
         """
-        self._packed: bytes = packed
+        self._packed: Buffer = packed
 
     @classmethod
     def from_packet(cls, data: Buffer) -> 'AIGP':
@@ -77,18 +75,17 @@ def from_packet(cls, data: Buffer) -> 'AIGP':
         Raises:
             ValueError: If data is malformed
         """
-        data_bytes = bytes(data)
-        if len(data_bytes) < 3:
-            raise ValueError(f'AIGP TLV too short: {len(data_bytes)} bytes')
-        tlv_type = data_bytes[0]
-        tlv_length = unpack('!H', data_bytes[1:3])[0]
+        if len(data) < 3:
+            raise ValueError(f'AIGP TLV too short: {len(data)} bytes')
+        tlv_type = data[0]
+        tlv_length = unpack('!H', data[1:3])[0]
         if tlv_type != 1:
             raise ValueError(f'Unknown AIGP TLV type: {tlv_type}')
         if tlv_length != cls._TLV_LENGTH:
             raise ValueError(f'Invalid AIGP TLV length: {tlv_length}')
-        if len(data_bytes) < tlv_length:
-            raise ValueError(f'AIGP data truncated: got {len(data_bytes)}, expected {tlv_length}')
-        return cls(data_bytes[:tlv_length])
+        if len(data) < tlv_length:
+            raise ValueError(f'AIGP data truncated: got {len(data)}, expected {tlv_length}')
+        return cls(data[:tlv_length])
 
     @classmethod
     def from_int(cls, value: int) -> 'AIGP':

src/exabgp/bgp/message/update/attribute/aspath.py

@@ -88,7 +88,7 @@ class ASPath(Attribute):
         CONFED_SET.ID: CONFED_SET,
     }
 
-    def __init__(self, packed: bytes, asn4: bool = False) -> None:
+    def __init__(self, packed: Buffer, asn4: bool = False) -> None:
         """Initialize from packed wire-format bytes.
 
         NO validation - trusted internal use only.
@@ -98,7 +98,7 @@ def __init__(self, packed: bytes, asn4: bool = False) -> None:
             packed: Raw attribute value bytes
             asn4: True if packed uses 4-byte ASNs, False for 2-byte
         """
-        self._packed: bytes = packed
+        self._packed: Buffer = packed
         self._asn4: bool = asn4
 
     @classmethod
@@ -115,10 +115,9 @@ def from_packet(cls, data: Buffer, asn4: bool) -> 'ASPath':
         Raises:
             Notify: If data format is invalid
         """
-        data_bytes = bytes(data)
         # Validate by attempting to parse - will raise Notify on error
-        cls._unpack_segments_static(data_bytes, asn4)
-        return cls(data_bytes, asn4)
+        cls._unpack_segments_static(data, asn4)
+        return cls(data, asn4)
 
     @classmethod
     def make_aspath(
@@ -142,7 +141,7 @@ def aspath(self) -> tuple[SET | SEQUENCE | CONFED_SEQUENCE | CONFED_SET, ...]:
         return self._unpack_segments_static(self._packed, self._asn4)
 
     @property
-    def index(self) -> bytes:
+    def index(self) -> Buffer:
         """Get the original packed data, used for indexing/caching."""
         return self._packed
 
@@ -201,7 +200,7 @@ def json(self) -> str:
 
     @classmethod
     def _unpack_segments_static(
-        cls, data: bytes, asn4: bool
+        cls, data: Buffer, asn4: bool
     ) -> tuple[SET | SEQUENCE | CONFED_SEQUENCE | CONFED_SET, ...]:
         """Unpack segments from wire format."""
         unpacker = '!L' if asn4 else '!H'
@@ -333,10 +332,9 @@ def from_packet(cls, data: Buffer, asn4: bool = True) -> 'AS4Path':
 
         AS4Path always uses 4-byte ASNs.
         """
-        data_bytes = bytes(data)
         # Validate by attempting to parse - will raise Notify on error
-        cls._unpack_segments_static(data_bytes, asn4=True)
-        return cls(data_bytes)
+        cls._unpack_segments_static(data, asn4=True)
+        return cls(data)
 
     @classmethod
     def make_aspath(

src/exabgp/bgp/message/update/attribute/atomicaggregate.py

@@ -15,7 +15,6 @@
 
 from exabgp.bgp.message.update.attribute.attribute import Attribute
 
-
 # ========================================================== AtomicAggregate (6)
 #
 
@@ -28,7 +27,7 @@ class AtomicAggregate(Attribute):
     DISCARD = True
     VALID_ZERO = True
 
-    def __init__(self, packed: bytes = b'') -> None:
+    def __init__(self, packed: Buffer) -> None:
         """Initialize AtomicAggregate from packed wire-format bytes.
 
         NO validation - trusted internal use only.
@@ -37,7 +36,7 @@ def __init__(self, packed: bytes = b'') -> None:
         Args:
             packed: Raw attribute value bytes (must be empty for AtomicAggregate)
         """
-        self._packed: bytes = packed
+        self._packed: Buffer = packed
 
     @classmethod
     def from_packet(cls, data: Buffer) -> 'AtomicAggregate':
@@ -52,10 +51,9 @@ def from_packet(cls, data: Buffer) -> 'AtomicAggregate':
         Raises:
             ValueError: If data is not empty
         """
-        data_bytes = bytes(data)
-        if data_bytes:
-            raise ValueError(f'AtomicAggregate must be empty, got {len(data_bytes)} bytes')
-        return cls(data_bytes)
+        if data:
+            raise ValueError(f'AtomicAggregate must be empty, got {len(data)} bytes')
+        return cls(data)
 
     @classmethod
     def make_atomic_aggregate(cls) -> 'AtomicAggregate':

src/exabgp/bgp/message/update/attribute/attribute.py

@@ -15,7 +15,6 @@
     from exabgp.bgp.message.open.capability.negotiated import Negotiated
 
 from exabgp.bgp.message.notification import Notify
-
 from exabgp.util.cache import Cache
 
 # Attribute length encoding constants
@@ -220,7 +219,7 @@ def matches(self, value: int) -> bool:
     # ---------------------------------------------------------------------------
 
     @classmethod
-    def _attribute(klass, value: bytes) -> bytes:
+    def _attribute(klass, value: Buffer) -> bytes:
         flag: int = klass.FLAG
         if flag & Attribute.Flag.OPTIONAL and not value:
             return b''
@@ -304,16 +303,15 @@ def unpack(cls, attribute_id: int, flag: int, data: Buffer, negotiated: Negotiat
         cache: bool = cls.caching and cls.CACHING
 
         # Convert to bytes for cache lookup (memoryview isn't hashable)
-        data_bytes = bytes(data)
-        if cache and data_bytes in cls.cache.get(cls.ID, {}):
-            return cls.cache[cls.ID].retrieve(data_bytes)  # type: ignore[no-any-return]
+        if cache and data in cls.cache.get(cls.ID, {}):
+            return cls.cache[cls.ID].retrieve(data)  # type: ignore[no-any-return]
 
         key: tuple[int, int] = (attribute_id, flag | Attribute.Flag.EXTENDED_LENGTH)
         if key in Attribute.registered_attributes.keys():
             instance: Attribute = cls.klass(attribute_id, flag).unpack_attribute(data, negotiated)  # type: ignore[attr-defined]
 
             if cache:
-                cls.cache[cls.ID].cache(data_bytes, instance)
+                cls.cache[cls.ID].cache(data, instance)
             return instance
 
         raise Notify(2, 4, 'can not handle attribute id {}'.format(attribute_id))

src/exabgp/bgp/message/update/attribute/clusterlist.py

@@ -13,18 +13,15 @@
 if TYPE_CHECKING:
     from exabgp.bgp.message.open.capability.negotiated import Negotiated
 
-from exabgp.protocol.ip import IPv4
-
 from exabgp.bgp.message.update.attribute.attribute import Attribute
-
+from exabgp.protocol.ip import IPv4
 
 # ===================================================================
 #
 
 
 class ClusterID(IPv4):
-    def __init__(self, ip: str) -> None:
-        IPv4.__init__(self, ip)
+    pass
 
 
 @Attribute.register()
@@ -38,7 +35,7 @@ class ClusterList(Attribute):
     FLAG: ClassVar[int] = Attribute.Flag.OPTIONAL
     CACHING: ClassVar[bool] = True
 
-    def __init__(self, packed: bytes) -> None:
+    def __init__(self, packed: Buffer) -> None:
         """Initialize from packed wire-format bytes.
 
         NO validation - trusted internal use only.
@@ -47,7 +44,7 @@ def __init__(self, packed: bytes) -> None:
         Args:
             packed: Raw cluster list bytes (concatenated 4-byte IPv4 addresses)
         """
-        self._packed: bytes = packed
+        self._packed: Buffer = packed
 
     @classmethod
     def from_packet(cls, data: Buffer) -> 'ClusterList':
@@ -62,10 +59,9 @@ def from_packet(cls, data: Buffer) -> 'ClusterList':
         Raises:
             ValueError: If data length is not a multiple of 4
         """
-        data_bytes = bytes(data)
-        if len(data_bytes) % 4 != 0:
-            raise ValueError(f'ClusterList must be a multiple of 4 bytes, got {len(data_bytes)}')
-        return cls(data_bytes)
+        if len(data) % 4 != 0:
+            raise ValueError(f'ClusterList must be a multiple of 4 bytes, got {len(data)}')
+        return cls(data)
 
     @classmethod
     def make_clusterlist(cls, clusters: Sequence[IPv4]) -> 'ClusterList':