pypcapkit 1.3.3.post1__cp313-none-any.whl

pcapkit/const/mh/fb_action.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Flow Binding Action Values
+================================
+
+.. module:: pcapkit.const.mh.fb_action
+
+This module contains the constant enumeration for **Flow Binding Action Values**,
+which is automatically generated from :class:`pcapkit.vendor.mh.fb_action.FlowBindingAction`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['FlowBindingAction']
+
+
+class FlowBindingAction(IntEnum):
+    """[FlowBindingAction] Flow Binding Action Values"""
+
+    #: Add a flow binding [:rfc:`7109`]
+    Add = 11
+
+    #: Delete a flow binding [:rfc:`7109`]
+    Delete = 12
+
+    #: Modify a flow binding [:rfc:`7109`]
+    Modify = 13
+
+    #: Refresh a flow binding [:rfc:`7109`]
+    Refresh = 14
+
+    #: Move a flow binding [:rfc:`7109`]
+    Move = 15
+
+    #: Revoke a flow binding [:rfc:`7109`]
+    Revoke = 16
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'FlowBindingAction':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return FlowBindingAction(key)
+        if key not in FlowBindingAction._member_map_:  # pylint: disable=no-member
+            return extend_enum(FlowBindingAction, key, default)
+        return FlowBindingAction[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'FlowBindingAction':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 0 <= value <= 10:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        if 17 <= value <= 255:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        return super()._missing_(value)

pcapkit/const/mh/fb_indication_trigger.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Flow Binding Indication Triggers
+======================================
+
+.. module:: pcapkit.const.mh.fb_indication_trigger
+
+This module contains the constant enumeration for **Flow Binding Indication Triggers**,
+which is automatically generated from :class:`pcapkit.vendor.mh.fb_indication_trigger.FlowBindingIndicationTrigger`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['FlowBindingIndicationTrigger']
+
+
+class FlowBindingIndicationTrigger(IntEnum):
+    """[FlowBindingIndicationTrigger] Flow Binding Indication Triggers"""
+
+    #: Reserved [:rfc:`7109`]
+    Reserved_0 = 0
+
+    #: Unspecified [:rfc:`7109`]
+    Unspecified = 1
+
+    #: Administrative Reason [:rfc:`7109`]
+    Administrative_Reason = 2
+
+    #: Possible Out-of-Sync BCE State [:rfc:`7109`]
+    Possible_Out_of_Sync_BCE_State = 3
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'FlowBindingIndicationTrigger':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return FlowBindingIndicationTrigger(key)
+        if key not in FlowBindingIndicationTrigger._member_map_:  # pylint: disable=no-member
+            return extend_enum(FlowBindingIndicationTrigger, key, default)
+        return FlowBindingIndicationTrigger[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'FlowBindingIndicationTrigger':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 4 <= value <= 249:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        if 250 <= value <= 255:
+            #: Reserved for Testing Purposes Only [:rfc:`7109`]
+            return extend_enum(cls, 'Reserved_for_Testing_Purposes_Only_%d' % value, value)
+        return super()._missing_(value)

pcapkit/const/mh/fb_type.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Flow Binding Type
+=======================
+
+.. module:: pcapkit.const.mh.fb_type
+
+This module contains the constant enumeration for **Flow Binding Type**,
+which is automatically generated from :class:`pcapkit.vendor.mh.fb_type.FlowBindingType`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['FlowBindingType']
+
+
+class FlowBindingType(IntEnum):
+    """[FlowBindingType] Flow Binding Type"""
+
+    #: Unassigned
+    Unassigned_0 = 0
+
+    #: Flow Binding Indication [:rfc:`7109`]
+    Indication = 1
+
+    #: Flow Binding Acknowledgement [:rfc:`7109`]
+    Acknowledgement = 2
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'FlowBindingType':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return FlowBindingType(key)
+        if key not in FlowBindingType._member_map_:  # pylint: disable=no-member
+            return extend_enum(FlowBindingType, key, default)
+        return FlowBindingType[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'FlowBindingType':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 3 <= value <= 255:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        return super()._missing_(value)

pcapkit/const/mh/flow_id_status.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Flow Identification Mobility Option Status Codes
+======================================================
+
+.. module:: pcapkit.const.mh.flow_id_status
+
+This module contains the constant enumeration for **Flow Identification Mobility Option Status Codes**,
+which is automatically generated from :class:`pcapkit.vendor.mh.flow_id_status.FlowIDStatus`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['FlowIDStatus']
+
+
+class FlowIDStatus(IntEnum):
+    """[FlowIDStatus] Flow Identification Mobility Option Status Codes"""
+
+    #: Flow binding successful [:rfc:`6089`]
+    Flow_binding_successful = 0
+
+    #: Administratively prohibited [:rfc:`6089`]
+    Administratively_prohibited = 128
+
+    #: Flow binding rejected, reason unspecified [:rfc:`6089`]
+    Flow_binding_rejected_reason_unspecified = 129
+
+    #: Flow identification mobility option malformed [:rfc:`6089`]
+    Flow_identification_mobility_option_malformed = 130
+
+    #: BID not found [:rfc:`6089`]
+    BID_not_found = 131
+
+    #: FID not found [:rfc:`6089`]
+    FID_not_found = 132
+
+    #: Traffic selector format not supported [:rfc:`6089`]
+    Traffic_selector_format_not_supported = 133
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'FlowIDStatus':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return FlowIDStatus(key)
+        if key not in FlowIDStatus._member_map_:  # pylint: disable=no-member
+            return extend_enum(FlowIDStatus, key, default)
+        return FlowIDStatus[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'FlowIDStatus':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 1 <= value <= 127:
+            #: Unassigned; available for success codes
+            return extend_enum(cls, 'Unassigned_available_for_success_codes_%d' % value, value)
+        if 134 <= value <= 250:
+            #: Unassigned; available for reject codes
+            return extend_enum(cls, 'Unassigned_available_for_reject_codes_%d' % value, value)
+        if 251 <= value <= 255:
+            #: Reserved for Experimental Use [:rfc:`6089`]
+            return extend_enum(cls, 'Reserved_for_Experimental_Use_%d' % value, value)
+        return super()._missing_(value)

pcapkit/const/mh/flow_id_suboption.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Flow Identification Sub-Options
+=====================================
+
+.. module:: pcapkit.const.mh.flow_id_suboption
+
+This module contains the constant enumeration for **Flow Identification Sub-Options**,
+which is automatically generated from :class:`pcapkit.vendor.mh.flow_id_suboption.FlowIDSuboption`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['FlowIDSuboption']
+
+
+class FlowIDSuboption(IntEnum):
+    """[FlowIDSuboption] Flow Identification Sub-Options"""
+
+    #: Pad [:rfc:`6089`]
+    Pad = 0
+
+    #: PadN [:rfc:`6089`]
+    PadN = 1
+
+    #: BID Reference [:rfc:`6089`]
+    BID_Reference = 2
+
+    #: Traffic Selector [:rfc:`6089`]
+    Traffic_Selector = 3
+
+    #: Flow Binding Action [:rfc:`7109`]
+    Flow_Binding_Action = 4
+
+    #: Target Care-of Address [:rfc:`7109`]
+    Target_Care_of_Address = 5
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'FlowIDSuboption':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return FlowIDSuboption(key)
+        if key not in FlowIDSuboption._member_map_:  # pylint: disable=no-member
+            return extend_enum(FlowIDSuboption, key, default)
+        return FlowIDSuboption[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'FlowIDSuboption':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 6 <= value <= 250:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        if 251 <= value <= 255:
+            #: Reserved for Experimental Use [:rfc:`6089`]
+            return extend_enum(cls, 'Reserved_for_Experimental_Use_%d' % value, value)
+        return super()._missing_(value)

pcapkit/const/mh/handoff_type.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Handoff Indicator Option Type Values
+==========================================
+
+.. module:: pcapkit.const.mh.handoff_type
+
+This module contains the constant enumeration for **Handoff Indicator Option Type Values**,
+which is automatically generated from :class:`pcapkit.vendor.mh.handoff_type.HandoffType`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['HandoffType']
+
+
+class HandoffType(IntEnum):
+    """[HandoffType] Handoff Indicator Option Type Values"""
+
+    #: Reserved [:rfc:`5213`]
+    Reserved_0 = 0
+
+    #: Attachment over a new interface [:rfc:`5213`]
+    Attachment_over_a_new_interface = 1
+
+    #: Handoff between two different interfaces of the mobile node [:rfc:`5213`]
+    Handoff_between_two_different_interfaces_of_the_mobile_node = 2
+
+    #: Handoff between mobile access gateways for the same interface [:rfc:`5213`]
+    Handoff_between_mobile_access_gateways_for_the_same_interface = 3
+
+    #: Handoff state unknown [:rfc:`5213`]
+    Handoff_state_unknown = 4
+
+    #: Handoff state not changed (Re-registration) [:rfc:`5213`]
+    Handoff_state_not_changed = 5
+
+    #: Attachment over a new interface sharing prefixes [:rfc:`7864`]
+    Attachment_over_a_new_interface_sharing_prefixes = 6
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'HandoffType':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return HandoffType(key)
+        if key not in HandoffType._member_map_:  # pylint: disable=no-member
+            return extend_enum(HandoffType, key, default)
+        return HandoffType[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'HandoffType':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 7 <= value <= 255:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        return super()._missing_(value)

pcapkit/const/mh/handover_ack_flag.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Handover Acknowledge Flags
+================================
+
+.. module:: pcapkit.const.mh.handover_ack_flag
+
+This module contains the constant enumeration for **Handover Acknowledge Flags**,
+which is automatically generated from :class:`pcapkit.vendor.mh.handover_ack_flag.HandoverACKFlag`.
+
+"""
+
+from aenum import IntFlag
+
+__all__ = ['HandoverACKFlag']
+
+
+class HandoverACKFlag(IntFlag):
+    """[HandoverACKFlag] Handover Acknowledge Flags"""
+
+    #: Buffer flag [:rfc:`5949`]
+    U = 0x80
+
+    #: Proxy flag [:rfc:`5949`]
+    P = 0x40
+
+    #: Forwarding flag [:rfc:`5949`]
+    F = 0x20
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'HandoverACKFlag':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return HandoverACKFlag(key)
+        return HandoverACKFlag[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'HandoverACKFlag':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 0xFF):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        return cls(value)

pcapkit/const/mh/handover_ack_status.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Handover Acknowledge Status Codes
+=======================================
+
+.. module:: pcapkit.const.mh.handover_ack_status
+
+This module contains the constant enumeration for **Handover Acknowledge Status Codes**,
+which is automatically generated from :class:`pcapkit.vendor.mh.handover_ack_status.HandoverACKStatus`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['HandoverACKStatus']
+
+
+class HandoverACKStatus(IntEnum):
+    """[HandoverACKStatus] Handover Acknowledge Status Codes"""
+
+    #: Handover Accepted or Successful (when 'P' flag is set) [:rfc:`5949`]
+    Handover_Accepted_or_Successful = 0
+
+    #: Handover Accepted with NCoA valid [:rfc:`5568`]
+    Handover_Accepted_with_NCoA_valid = 0
+
+    #: Handover Accepted, NCoA not valid [:rfc:`5568`]
+    Handover_Accepted_NCoA_not_valid = 1
+
+    #: Handover Accepted, NCoA assigned [:rfc:`5568`]
+    Handover_Accepted_NCoA_assigned = 2
+
+    #: Handover Accepted, use PCoA [:rfc:`5568`]
+    Handover_Accepted_use_PCoA = 3
+
+    #: Message sent unsolicited [:rfc:`5568`]
+    Message_sent_unsolicited = 4
+
+    #: Context Transfer Accepted or Successful [:rfc:`5949`]
+    Context_Transfer_Accepted_or_Successful = 5
+
+    #: All available Context Transferred [:rfc:`5949`]
+    All_available_Context_Transferred = 6
+
+    #: Handover Not Accepted, reason unspecified [:rfc:`5568`]
+    Handover_Not_Accepted_reason_unspecified = 128
+
+    #: Administratively prohibited [:rfc:`5568`]
+    Administratively_prohibited = 129
+
+    #: Insufficient resources [:rfc:`5568`]
+    Insufficient_resources = 130
+
+    #: Requested Context Not Available [:rfc:`5949`]
+    Requested_Context_Not_Available = 131
+
+    #: Forwarding Not Available [:rfc:`5949`]
+    Forwarding_Not_Available = 132
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'HandoverACKStatus':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return HandoverACKStatus(key)
+        if key not in HandoverACKStatus._member_map_:  # pylint: disable=no-member
+            return extend_enum(HandoverACKStatus, key, default)
+        return HandoverACKStatus[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'HandoverACKStatus':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 7 <= value <= 127:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        if 133 <= value <= 255:
+            #: Unassigned
+            return extend_enum(cls, 'Unassigned_%d' % value, value)
+        return super()._missing_(value)

pcapkit/const/mh/handover_initiate_flag.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Handover Initiate Flags
+=============================
+
+.. module:: pcapkit.const.mh.handover_initiate_flag
+
+This module contains the constant enumeration for **Handover Initiate Flags**,
+which is automatically generated from :class:`pcapkit.vendor.mh.handover_initiate_flag.HandoverInitiateFlag`.
+
+"""
+
+from aenum import IntFlag
+
+__all__ = ['HandoverInitiateFlag']
+
+
+class HandoverInitiateFlag(IntFlag):
+    """[HandoverInitiateFlag] Handover Initiate Flags"""
+
+    #: Assigned Address Configuration flag [:rfc:`5568`]
+    S = 0x80
+
+    #: Buffer flag [:rfc:`5568`]
+    U = 0x40
+
+    #: Proxy flag [:rfc:`5949`]
+    P = 0x20
+
+    #: Forwarding flag [:rfc:`5949`]
+    F = 0x10
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'HandoverInitiateFlag':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return HandoverInitiateFlag(key)
+        return HandoverInitiateFlag[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'HandoverInitiateFlag':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 0xFF):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        return cls(value)

pcapkit/const/mh/handover_initiate_status.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long,consider-using-f-string
+"""Handover Initiate Status Codes
+====================================
+
+.. module:: pcapkit.const.mh.handover_initiate_status
+
+This module contains the constant enumeration for **Handover Initiate Status Codes**,
+which is automatically generated from :class:`pcapkit.vendor.mh.handover_initiate_status.HandoverInitiateStatus`.
+
+"""
+
+from aenum import IntEnum, extend_enum
+
+__all__ = ['HandoverInitiateStatus']
+
+
+class HandoverInitiateStatus(IntEnum):
+    """[HandoverInitiateStatus] Handover Initiate Status Codes"""
+
+    #: FBU with the PCoA as source IP address [:rfc:`5568`]
+    FBU_with_the_PCoA_as_source_IP_address = 0
+
+    #: FBU whose source IP address is not PCoA [:rfc:`5568`]
+    FBU_whose_source_IP_address_is_not_PCoA = 1
+
+    #: Indicate the completion of forwarding [:rfc:`5949`]
+    Indicate_the_completion_of_forwarding = 2
+
+    #: All available context transferred [:rfc:`5949`]
+    All_available_context_transferred = 3
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1) -> 'HandoverInitiateStatus':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+
+        """
+        if isinstance(key, int):
+            return HandoverInitiateStatus(key)
+        if key not in HandoverInitiateStatus._member_map_:  # pylint: disable=no-member
+            extend_enum(HandoverInitiateStatus, key, default)
+        return HandoverInitiateStatus[key]  # type: ignore[misc]
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> 'HandoverInitiateStatus':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not (isinstance(value, int) and 0 <= value <= 255):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if 4 <= value <= 255:
+            #: Unassigned
+            extend_enum(cls, 'Unassigned_%d' % value, value)
+            return cls(value)
+        return super()._missing_(value)