class RawVal:
class ObservableDict(Dict[int, str]):
class Field(Generic[I, M]):
class _FieldContainer(object):
class Emph(_FieldContainer):
class ActionField(_FieldContainer):
class ConditionalField(_FieldContainer):
class MultipleTypeField(_FieldContainer):
class PadField(_FieldContainer):
class ReversePadField(PadField):
class FCSField(Field[int, int]):
class DestField(Field[str, bytes]):
class MACField(Field[Optional[str], bytes]):
class IPField(Field[Union[str, Net], bytes]):
class SourceIPField(IPField):
class IP6Field(Field[Optional[Union[str, Net6]], bytes]):
class SourceIP6Field(IP6Field):
class DestIP6Field(IP6Field, DestField):
class ByteField(Field[int, int]):
class XByteField(ByteField):
class OByteField(ByteField):
class ThreeBytesField(Field[int, int]):
class X3BytesField(ThreeBytesField, XByteField):
class LEThreeBytesField(ByteField):
class LEX3BytesField(LEThreeBytesField, XByteField):
class NBytesField(Field[int, List[int]]):
class XNBytesField(NBytesField):
class SignedByteField(Field[int, int]):
class FieldValueRangeException(Scapy_Exception):
class FieldAttributeException(Scapy_Exception):
class YesNoByteField(ByteField):
class ShortField(Field[int, int]):
class SignedShortField(Field[int, int]):
class LEShortField(Field[int, int]):
class LESignedShortField(Field[int, int]):
class XShortField(ShortField):
class IntField(Field[int, int]):
class SignedIntField(Field[int, int]):
class LEIntField(Field[int, int]):
class LESignedIntField(Field[int, int]):
class XIntField(IntField):
class XLEIntField(LEIntField, XIntField):
class XLEShortField(LEShortField, XShortField):
class LongField(Field[int, int]):
class SignedLongField(Field[int, int]):
class LELongField(LongField):
class LESignedLongField(Field[int, int]):
class XLongField(LongField):
class XLELongField(LELongField, XLongField):
class IEEEFloatField(Field[int, int]):
class IEEEDoubleField(Field[int, int]):
class _StrField(Field[I, bytes]):
class StrField(_StrField[bytes]):
class StrFieldUtf16(StrField):
class _PacketField(_StrField[K]):
class PacketField(_PacketField[BasePacket]):
class PacketLenField(_PacketField[Optional[BasePacket]]):
class PacketListField(_PacketField[List[BasePacket]]):
class StrFixedLenField(StrField):
class StrFixedLenEnumField(StrFixedLenField):
class NetBIOSNameField(StrFixedLenField):
class StrLenField(StrField):
class XStrField(StrField):
class _XStrLenField:
class XStrLenField(_XStrLenField, StrLenField):
class XStrFixedLenField(_XStrLenField, StrFixedLenField):
class XLEStrLenField(XStrLenField):
class StrLenFieldUtf16(StrLenField, StrFieldUtf16):
class BoundStrLenField(StrLenField):
class FieldListField(Field[List[Any], List[Any]]):
class FieldLenField(Field[int, int]):
class StrNullField(StrField):
class StrNullFieldUtf16(StrNullField, StrFieldUtf16):
class StrStopField(StrField):
class LenField(Field[int, int]):
class BCDFloatField(Field[float, int]):
class _BitField(Field[I, int]):
class BitField(_BitField[int]):
class BitFixedLenField(BitField):
class BitFieldLenField(BitField):
class XBitField(BitField):
class _EnumField(Field[Union[List[I], I], I]):
class EnumField(_EnumField[I]):
class CharEnumField(EnumField[str]):
class BitEnumField(_BitField[Union[List[int], int]], _EnumField[int]):
class ShortEnumField(EnumField[int]):
class LEShortEnumField(EnumField[int]):
class LELongEnumField(EnumField[int]):
class ByteEnumField(EnumField[int]):
class XByteEnumField(ByteEnumField):
class IntEnumField(EnumField[int]):
class SignedIntEnumField(EnumField[int]):
class LEIntEnumField(EnumField[int]):
class XShortEnumField(ShortEnumField):
class _MultiEnumField(_EnumField[I]):
class MultiEnumField(_MultiEnumField[int], EnumField[int]):
class BitMultiEnumField(_BitField[Union[List[int], int]],
                        _MultiEnumField[int]):
class ByteEnumKeysField(ByteEnumField):
class ShortEnumKeysField(ShortEnumField):
class IntEnumKeysField(IntEnumField):
class LEFieldLenField(FieldLenField):
class FlagValueIter(object):
class FlagValue(object):
class FlagsField(_BitField[Optional[Union[int, FlagValue]]]):
class MultiFlagsField(_BitField[Set[str]]):
class FixedPointField(BitField):
class _IPPrefixFieldBase(Field[Tuple[str, int], Tuple[bytes, int]]):
class IPPrefixField(_IPPrefixFieldBase):
class IP6PrefixField(_IPPrefixFieldBase):
class UTCTimeField(Field[float, int]):
class SecondsIntField(Field[float, int]):
class _ScalingField(object):
class ScalingField(_ScalingField,
                   Field[Union[int, float], Union[int, float]]):
class BitScalingField(_ScalingField, BitField):  # type: ignore
class OUIField(X3BytesField):
class UUIDField(Field[UUID, bytes]):
class UUIDEnumField(UUIDField, _EnumField[UUID]):
class BitExtendedField(Field[Optional[int], bytes]):
class LSBExtendedField(BitExtendedField):
class MSBExtendedField(BitExtendedField):
    def __init__(self, val=b""):
    def __str__(self):
    def __bytes__(self):
    def __len__(self):
    def __repr__(self):
    def __init__(self, *args, **kw):
    def observe(self, observer):
    def __setitem__(self, key, value):
    def __delitem__(self, key):
    def update(self, anotherDict):  # type: ignore
    def __init__(self, name, default, fmt="H"):
    def register_owner(self, cls):
    def i2len(self,
              pkt,  # type: Packet
              x,  # type: Any
              ):
    def i2count(self, pkt, x):
    def h2i(self, pkt, x):
    def i2h(self, pkt, x):
    def m2i(self, pkt, x):
    def i2m(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def addfield(self, pkt, s, val):
    def getfield(self, pkt, s):
    def do_copy(self, x):
    def __repr__(self):
    def copy(self):
    def randval(self):
    def __getattr__(self, attr):
    def __init__(self, fld):
    def __eq__(self, other):
    def __ne__(self, other):
    def __init__(self, fld, action_method, **kargs):
    def any2i(self, pkt, val):
    def __init__(self,
                 fld,  # type: Field[Any, Any]
                 cond  # type: Callable[[Packet], bool]
                 ):
    def _evalcond(self, pkt):
    def any2i(self, pkt, x):
    def i2h(self, pkt, val):
    def getfield(self, pkt, s):
    def addfield(self, pkt, s, val):
    def __getattr__(self, attr):
    def __init__(self,
                 flds,  # type: List[Tuple[Field[Any, Any], Any]]
                 dflt  # type: Field[Any, Any]
                 ):
    def _iterate_fields_cond(self, pkt, val, use_val):
    def _find_fld_pkt(self, pkt):
    def _find_fld_pkt_val(self,
                          pkt,  # type: Optional[Packet]
                          val,  # type: Any
                          ):
    def _find_fld(self):
    def getfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 ):
    def addfield(self, pkt, s, val):
    def any2i(self, pkt, val):
    def h2i(self, pkt, val):
    def i2h(self,
            pkt,  # type: Packet
            val,  # type: Any
            ):
    def i2m(self, pkt, val):
    def i2len(self, pkt, val):
    def i2repr(self, pkt, val):
    def register_owner(self, cls):
    def fld(self):
    def __init__(self, fld, align, padwith=None):
    def padlen(self, flen):
    def getfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 ):
    def addfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 val,  # type: Any
                 ):
    def getfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 ):
    def addfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 val,  # type: Any
                 ):
    def getfield(self, pkt, s):
        def _post_dissect(self, s):
    def addfield(self, pkt, s, val):
        def _post_build(self, p, pay):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def dst_from_pkt(self, pkt):
    def bind_addr(cls, layer, addr, **condition):
    def __init__(self, name, default):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def randval(self):
    def __init__(self, name, default):
    def h2i(self, pkt, x):
    def i2h(self, pkt, x):
    def resolve(self, x):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def randval(self):
    def __init__(self, name, dstname):
    def __findaddr(self, pkt):
    def i2m(self, pkt, x):
    def i2h(self, pkt, x):
    def __init__(self, name, default):
    def h2i(self, pkt, x):
    def i2h(self, pkt, x):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def randval(self):
    def __init__(self, name, dstname):
    def i2m(self, pkt, x):
    def i2h(self, pkt, x):
    def __init__(self, name, default):
    def i2m(self, pkt, x):
    def i2h(self, pkt, x):
    def __init__(self, name, default):
    def i2repr(self, pkt, x):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def addfield(self, pkt, s, val):
    def getfield(self, pkt, s):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def addfield(self, pkt, s, val):
    def getfield(self, pkt, s):
    def i2repr(self, pkt, x):
    def __init__(self, name, default, sz):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def addfield(self, pkt, s, val):
    def getfield(self, pkt, s):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def _build_config_representation(self, config):
    def __init__(self, name, default, config=None):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def i2repr(self, pkt, x):
    def i2repr(self, pkt, x):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def i2repr(self, pkt, x):
    def i2repr(self, pkt, x):
    def __init__(self, name, default):
    def __init__(self, name, default):
    def __init__(self, name, default, fmt="H", remain=0):
    def i2len(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def i2m(self, pkt, x):
    def addfield(self, pkt, s, val):
    def getfield(self, pkt, s):
    def randval(self):
    def h2i(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def i2h(self, pkt, x):
    def __init__(self,
                 name,  # type: str
                 default,  # type: Optional[K]
                 pkt_cls,  # type: Union[Callable[[bytes], Packet], Type[Packet]]  # noqa: E501
                 ):
    def i2m(self,
            pkt,  # type: Optional[Packet]
            i,  # type: Any
            ):
    def m2i(self, pkt, m):
    def getfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 ):
    def randval(self):
    def __init__(self,
                 name,  # type: str
                 default,  # type: Packet
                 cls,  # type: Union[Callable[[bytes], Packet], Type[Packet]]  # noqa: E501
                 length_from=None  # type: Optional[Callable[[Packet], int]]  # noqa: E501
                 ):
    def getfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 ):
    def __init__(
            self,
            name,  # type: str
            default,  # type: Optional[List[BasePacket]]
            pkt_cls=None,  # type: Optional[Union[Callable[[bytes], Packet], Type[Packet]]]  # noqa: E501
            count_from=None,  # type: Optional[Callable[[Packet], int]]
            length_from=None,  # type: Optional[Callable[[Packet], int]]
            next_cls_cb=None,  # type: Optional[Callable[[Packet, List[BasePacket], Optional[Packet], bytes], Type[Packet]]]  # noqa: E501
    ):
    def any2i(self, pkt, x):
    def i2count(self,
                pkt,  # type: Optional[Packet]
                val,  # type: List[BasePacket]
                ):
    def i2len(self,
              pkt,  # type: Optional[Packet]
              val,  # type: List[Packet]
              ):
    def getfield(self, pkt, s):
    def addfield(self, pkt, s, val):
    def __init__(
            self,
            name,  # type: str
            default,  # type: Optional[bytes]
            length=None,  # type: Optional[int]
            length_from=None,  # type: Optional[Callable[[Packet], int]]  # noqa: E501
    ):
    def i2repr(self,
               pkt,  # type: Optional[Packet]
               v,  # type: bytes
               ):
    def getfield(self, pkt, s):
    def addfield(self, pkt, s, val):
    def randval(self):
    def __init__(
            self,
            name,  # type: str
            default,  # type: bytes
            length=None,  # type: Optional[int]
            enum=None,  # type: Optional[Dict[str, str]]
            length_from=None  # type: Optional[Callable[[Optional[Packet]], int]]  # noqa: E501
    ):
    def i2repr(self, pkt, w):
    def __init__(self, name, default, length=31):
    def i2m(self, pkt, y):
    def m2i(self, pkt, x):
    def __init__(
            self,
            name,  # type: str
            default,  # type: bytes
            length_from=None,  # type: Optional[Callable[[Packet], int]]
            max_length=None,  # type: Optional[Any]
    ):
    def getfield(self, pkt, s):
    def randval(self):
    def i2repr(self, pkt, x):
    def i2repr(self, pkt, x):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def __init__(
            self,
            name,  # type: str
            default,  # type: bytes
            minlen=0,  # type: int
            maxlen=255,  # type: int
            length_from=None  # type: Optional[Callable[[Packet], int]]
    ):
    def randval(self):
    def __init__(
            self,
            name,  # type: str
            default,  # type: Optional[List[AnyField]]
            field,  # type: AnyField
            length_from=None,  # type: Optional[Callable[[Packet], int]]
            count_from=None,  # type: Optional[Callable[[Packet], int]]
    ):
    def i2count(self, pkt, val):
    def i2len(self, pkt, val):
    def any2i(self, pkt, x):
    def i2repr(self,
               pkt,  # type: Optional[Packet]
               x,  # type: List[Any]
               ):
    def addfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 val,  # type: Optional[List[Any]]
                 ):
    def getfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 ):
    def __init__(
            self,
            name,  # type: str
            default,  # type: Optional[Any]
            length_of=None,  # type: Optional[str]
            fmt="H",  # type: str
            count_of=None,  # type: Optional[str]
            adjust=lambda pkt, x: x,  # type: Callable[[Packet, int], int]
    ):
    def i2m(self, pkt, x):
    def addfield(self, pkt, s, val):
    def getfield(self,
                 pkt,  # type: Packet
                 s,  # type: bytes
                 ):
    def randval(self):
    def __init__(self, name, default, stop, additional=0):
    def getfield(self, pkt, s):
    def randval(self):
    def __init__(self, name, default, fmt="H", adjust=lambda x: x):
    def i2m(self,
            pkt,  # type: Optional[Packet]
            x,  # type: Optional[int]
            ):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def __init__(self, name, default, size,
                 tot_size=0, end_tot_size=0):
    def addfield(self,  # type: ignore
                 pkt,  # type: Packet
                 s,  # type: Union[Tuple[bytes, int, int], bytes]
                 ival,  # type: I
                 ):
    def getfield(self,  # type: ignore
                 pkt,  # type: Packet
                 s,  # type: Union[Tuple[bytes, int], bytes]
                 ):
    def randval(self):
    def i2len(self, pkt, x):  # type: ignore
    def __init__(self,
                 name,  # type: str
                 default,  # type: Optional[int]
                 length_from  # type: Callable[[Packet], int]
                 ):
    def getfield(self,  # type: ignore
                 pkt,  # type: Packet
                 s,  # type: Union[Tuple[bytes, int], bytes]
                 ):
    def addfield(self,  # type: ignore
                 pkt,  # type: Packet
                 s,  # type: Union[Tuple[bytes, int, int], bytes]
                 val  # type: int
                 ):
    def __init__(self,
                 name,  # type: str
                 default,  # type: Optional[int]
                 size,  # type: int
                 length_of=None,  # type: Optional[Union[Callable[[Optional[Packet]], int], str]]  # noqa: E501
                 count_of=None,  # type: Optional[str]
                 adjust=lambda pkt, x: x,  # type: Callable[[Optional[Packet], int], int]  # noqa: E501
                 ):
    def i2m(self, pkt, x):
    def i2repr(self, pkt, x):
    def __init__(self,
                 name,  # type: str
                 default,  # type: Optional[I]
                 enum,  # type: Union[Dict[I, str], Dict[str, I], List[str], DADict[I, str], Tuple[Callable[[I], str], Callable[[str], I]]]  # noqa: E501
                 fmt="H",  # type: str
                 ):
    def any2i_one(self, pkt, x):
    def i2repr_one(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):  # type: ignore
    def notify_set(self, enum, key, value):
    def notify_del(self, enum, key):
    def __init__(self,
                 name,  # type: str
                 default,  # type: str
                 enum,  # type: Union[Dict[str, str], Tuple[Callable[[str], str], Callable[[str], str]]]  # noqa: E501
                 fmt="1s",  # type: str
                 ):
    def any2i_one(self, pkt, x):
    def __init__(self, name, default, size, enum, **kwargs):
    def any2i(self, pkt, x):
    def i2repr(self,
               pkt,  # type: Optional[Packet]
               x,  # type: Union[List[int], int]
               ):
    def __init__(self,
                 name,  # type: str
                 default,  # type: int
                 enum,  # type: Union[Dict[int, str], Dict[str, int], Tuple[Callable[[int], str], Callable[[str], int]], DADict[int, str]]  # noqa: E501
                 ):
    def __init__(self, name, default, enum):
    def __init__(self, name, default, enum):
    def __init__(self, name, default, enum):
    def i2repr_one(self, pkt, x):
    def __init__(self, name, default, enum):
    def __init__(self, name, default, enum):
    def __init__(self, name, default, enum):
    def i2repr_one(self, pkt, x):
    def __init__(self,
                 name,  # type: str
                 default,  # type: int
                 enum,  # type: Dict[I, Dict[I, str]]
                 depends_on,  # type: Callable[[Optional[Packet]], I]
                 fmt="H"  # type: str
                 ):
    def any2i_one(self, pkt, x):
    def i2repr_one(self, pkt, x):
    def __init__(
            self,
            name,  # type: str
            default,  # type: int
            size,  # type: int
            enum,  # type: Dict[int, Dict[int, str]]
            depends_on  # type: Callable[[Optional[Packet]], int]
    ):
    def any2i(self, pkt, x):
    def i2repr(  # type: ignore
            self,
            pkt,  # type: Optional[Packet]
            x  # type: Union[List[int], int]
    ):
    def randval(self):
    def randval(self):
    def randval(self):
    def __init__(
            self,
            name,  # type: str
            default,  # type: int
            length_of=None,  # type: Optional[str]
            fmt="<H",  # type: str
            count_of=None,  # type: Optional[str]
            adjust=lambda pkt, x: x,  # type: Callable[[Packet, int], int]
    ):
    def __init__(self, flagvalue):
    def __iter__(self):
    def __next__(self):
    def _fixvalue(self, value):
    def __init__(self, value, names):
    def __hash__(self):
    def __int__(self):
    def __eq__(self, other):
    def __lt__(self, other):
    def __le__(self, other):
    def __gt__(self, other):
    def __ge__(self, other):
    def __ne__(self, other):
    def __and__(self, other):
    def __or__(self, other):
    def __sub__(self, other):
    def __xor__(self, other):
    def __lshift__(self, other):
    def __rshift__(self, other):
    def __nonzero__(self):
    def flagrepr(self):
    def __str__(self):
    def __iter__(self):
    def __repr__(self):
    def __deepcopy__(self, memo):
    def __getattr__(self, attr):
    def __setattr__(self, attr, value):
    def copy(self):
    def __init__(self,
                 name,  # type: str
                 default,  # type: Optional[Union[int, FlagValue]]
                 size,  # type: int
                 names  # type: Union[List[str], str, Dict[int, str]]
                 ):
    def _fixup_val(self, x):
    def any2i(self, pkt, x):
    def m2i(self, pkt, x):
    def i2h(self, pkt, x):
    def i2repr(self,
               pkt,  # type: Optional[Packet]
               x,  # type: Any
               ):
    def __init__(self,
                 name,  # type: str
                 default,  # type: Set[str]
                 size,  # type: int
                 names,  # type: Dict[int, Dict[int, MultiFlagsEntry]]
                 depends_on,  # type: Callable[[Optional[Packet]], int]
                 ):
    def any2i(self, pkt, x):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def __init__(self, name, default, size, frac_bits=16):
    def any2i(self, pkt, val):
    def i2h(self, pkt, val):
    def i2repr(self, pkt, val):
    def __init__(
            self,
            name,  # type: str
            default,  # type: Tuple[str, int]
            wordbytes,  # type: int
            maxbytes,  # type: int
            aton,  # type: Callable[..., Any]
            ntoa,  # type: Callable[..., Any]
            length_from=None  # type: Optional[Callable[[Packet], int]]
    ):
    def _numbytes(self, pfxlen):
    def h2i(self, pkt, x):
    def i2h(self, pkt, x):
    def i2m(self,
            pkt,  # type: Optional[Packet]
            x  # type: Optional[Tuple[str, int]]
            ):
    def m2i(self, pkt, x):
    def any2i(self, pkt, x):
    def i2len(self, pkt, x):
    def addfield(self, pkt, s, val):
    def getfield(self, pkt, s):
    def __init__(
            self,
            name,  # type: str
            default,  # type: Tuple[str, int]
            wordbytes=1,  # type: int
            length_from=None  # type: Optional[Callable[[Packet], int]]
    ):
    def __init__(
            self,
            name,  # type: str
            default,  # type: Tuple[str, int]
            wordbytes=1,  # type: int
            length_from=None  # type: Optional[Callable[[Packet], int]]
    ):
    def __init__(self,
                 name,  # type: str
                 default,  # type: int
                 use_msec=False,  # type: bool
                 use_micro=False,  # type: bool
                 use_nano=False,  # type: bool
                 epoch=None,  # type: Optional[Tuple[int, int, int, int, int, int, int, int, int]]  # noqa: E501
                 strf="%a, %d %b %Y %H:%M:%S %z",  # type: str
                 custom_scaling=None,  # type: Optional[int]
                 fmt="I"  # type: str
                 ):
    def i2repr(self, pkt, x):
    def i2m(self, pkt, x):
    def __init__(self, name, default,
                 use_msec=False,
                 use_micro=False,
                 use_nano=False):
    def i2repr(self, pkt, x):
    def __init__(self,
                 name,  # type: str
                 default,  # type: float
                 scaling=1,  # type: Union[int, float]
                 unit="",  # type: str
                 offset=0,  # type: Union[int, float]
                 ndigits=3,  # type: int
                 fmt="B",  # type: str
                 ):
    def i2m(self,
            pkt,  # type: Optional[Packet]
            x  # type: Optional[Union[int, float]]
            ):
    def m2i(self, pkt, x):
    def any2i(self, pkt, x):
    def i2repr(self, pkt, x):
    def randval(self):
    def __init__(self, name, default, size, *args, **kwargs):
    def i2repr(self, pkt, val):
    def __init__(self, name, default, uuid_fmt=FORMAT_BE):
    def _check_uuid_fmt(self):
    def i2m(self, pkt, x):
    def m2i(self,
            pkt,  # type: Optional[Packet]
            x,  # type: bytes
            ):
    def any2i(self,
              pkt,  # type: Optional[Packet]
              x  # type: Any  # noqa: E501
              ):
    def randval():
    def __init__(self, name, default, enum, uuid_fmt=0):
    def any2i(self, pkt, x):
    def i2repr(self,
               pkt,  # type: Optional[Packet]
               x,  # type: UUID
               ):
    def prepare_byte(self, x):
    def str2extended(self, x=b""):
    def extended2str(self, x):
    def __init__(self, name, default, extension_bit):
    def i2m(self, pkt, x):
    def m2i(self, pkt, x):
    def addfield(self, pkt, s, val):
    def getfield(self, pkt, s):
    def __init__(self, name, default):
    def __init__(self, name, default):
I = TypeVar('I')  # Internal storage  # noqa: E741
M = TypeVar('M')  # Machine storage
K = TypeVar('K', List[BasePacket], BasePacket, Optional[BasePacket])
    DELIMITER = b"\x00"
    ALIGNMENT = 1
    DELIMITER = b"\x00\x00"
    ALIGNMENT = 2
    FORMAT_BE = 0
    FORMAT_LE = 1
    FORMAT_REV = 2
    FORMATS = (FORMAT_BE, FORMAT_LE, FORMAT_REV) class ConfClass(object):
class Interceptor(object):
class ProgPath(ConfClass):
class ConfigFieldList:
class Emphasize(ConfigFieldList):
class Resolve(ConfigFieldList):
class Num2Layer:
class LayersList(List[Type['scapy.packet.Packet']]):
class CommandsList(List[Callable[..., Any]]):
class CacheInstance(Dict[str, Any], object):
class NetCache:
class Conf(ConfClass):
    def configure(self, cnf):
    def __repr__(self):
    def __str__(self):
    def __init__(self,
                 name,  # type: str
                 default,  # type: Any
                 hook,  # type: Callable[..., Any]
                 args=None,  # type: Optional[List[Any]]
                 kargs=None  # type: Optional[Dict[str, Any]]
                 ):
    def __get__(self, obj, typ=None):
    def set_from_hook(obj, name, val):
    def __set__(self, obj, val):
def _readonly(name):
    def __init__(self):
    def _is_field(f):
    def _recalc_layer_list(self):
    def add(self, *flds):
    def remove(self, *flds):
    def __contains__(self, elt):
    def __repr__(self):
    def __init__(self):
    def register(self, num, layer):
    def register_num2layer(self, num, layer):
    def register_layer2num(self, num, layer):
    def __getitem__(self, item):
    def __contains__(self, item):
    def get(self,
            item,  # type: Union[int, Type[Packet]]
            default=None,  # type: Optional[Type[Packet]]
            ):
    def __repr__(self):
    def __init__(self):
    def __repr__(self):
    def register(self, layer):
    def layers(self):
    def filter(self, items):
    def unfilter(self):
    def __repr__(self):
    def register(self, cmd):
def lsc():
    def __init__(self, name="noname", timeout=None):
    def flush(self):
    def __getitem__(self, item):
    def get(self, item, default=None):
    def __setitem__(self, item, v):
    def update(self,  # type: ignore
               other,  # type: Any
               **kwargs  # type: Any
               ):
    def iteritems(self):
    def iterkeys(self):
    def __iter__(self):
    def itervalues(self):
    def items(self):
    def keys(self):
    def values(self):
    def __len__(self):
    def summary(self):
    def __repr__(self):
    def copy(self):
    def __init__(self):
    def add_cache(self, cache):
    def new_cache(self, name, timeout=None):
    def __delattr__(self, attr):
    def update(self, other):
    def flush(self):
    def __repr__(self):
def _version_checker(module, minver):
def isCryptographyValid():
def isCryptographyAdvanced():
def isPyPy():
def _prompt_changer(attr, val, old):
def _set_conf_sockets():
def _socket_changer(attr, val, old):
def _loglevel_changer(attr, val, old):
def _iface_changer(attr, val, old):
    def __getattribute__(self, attr):
def crypto_validator(func):
    def func_in(*args, **kwargs):
def scapy_delete_temp_files(): def raw(x):
    # type: (Union[Packet]) -> bytes
    """
    Builds a packet and returns its bytes representation.
    This function is and will always be cross-version compatible
    """
    if hasattr(x, "__bytes__"):
        return x.__bytes__()
    return bytes(x) def orb(x):
    # type: (Union[int, str, bytes]) -> int
    """Return ord(x) when not already an int."""
    if isinstance(x, int):
        return x
    return ord(x) def bytes_encode(x):
    # type: (Any) -> bytes
    """Ensure that the given object is bytes.
    If the parameter is a packet, raw() should be preferred.
    """
    if isinstance(x, str):
        return x.encode()
    return bytes(x) class BasePacket(Gen['scapy.packet.Packet']):
    __slots__ = []  # type: List[str] class Gen(Generic[_T]):
    __slots__ = []  # type: List[str]

    def __iter__(self):
        # type: () -> Iterator[_T]
        return iter([])

    def __iterlen__(self):
        # type: () -> int
        return sum(1 for _ in iter(self)) class SetGen(Gen[_T]):
    def __init__(self, values, _iterpacket=1):
        # type: (Any, int) -> None
        self._iterpacket = _iterpacket
        if isinstance(values, (list, BasePacketList)):
            self.values = [_get_values(val) for val in values]
        else:
            self.values = [_get_values(values)]

    def __iter__(self):
        # type: () -> Iterator[Any]
        for i in self.values:
            if (isinstance(i, Gen) and
                (self._iterpacket or not isinstance(i, BasePacket))) or (
                    isinstance(i, (range, types.GeneratorType))):
                for j in i:
                    yield j
            else:
                yield i

    def __len__(self):
        # type: () -> int
        return self.__iterlen__()

    def __repr__(self):
        # type: () -> str
        return "<SetGen %r>" % self.values class Packet_metaclass(_Generic_metaclass):
    def __new__(cls,
                name,  # type: str
                bases,  # type: Tuple[type, ...]
                dct  # type: Dict[str, Any]
                ):
        # type: (...) -> Type['scapy.packet.Packet']
        if "fields_desc" in dct:  # perform resolution of references to other packets  # noqa: E501
            current_fld = dct["fields_desc"]  # type: List[Union[scapy.fields.Field[Any, Any], Packet_metaclass]]  # noqa: E501
            resolved_fld = []  # type: List[scapy.fields.Field[Any, Any]]
            for fld_or_pkt in current_fld:
                if isinstance(fld_or_pkt, Packet_metaclass):
                    # reference to another fields_desc
                    for pkt_fld in fld_or_pkt.fields_desc:  # type: ignore
                        resolved_fld.append(pkt_fld)
                else:
                    resolved_fld.append(fld_or_pkt)
        else:  # look for a fields_desc in parent classes
            resolved_fld = []
            for b in bases:
                if hasattr(b, "fields_desc"):
                    resolved_fld = b.fields_desc  # type: ignore
                    break

        if resolved_fld:  # perform default value replacements
            final_fld = []  # type: List[scapy.fields.Field[Any, Any]]
            names = []
            for f in resolved_fld:
                if f.name in names:
                    war_msg = (
                        "Packet '%s' has a duplicated '%s' field ! "
                        "If you are using several ConditionalFields, have "
                        "a look at MultipleTypeField instead ! This will "
                        "become a SyntaxError in a future version of "
                        "Scapy !" % (
                            name, f.name
                        )
                    )
                    warnings.warn(war_msg, SyntaxWarning)
                names.append(f.name)
                if f.name in dct:
                    f = f.copy()
                    f.default = dct[f.name]
                    del(dct[f.name])
                final_fld.append(f)

            dct["fields_desc"] = final_fld

        dct.setdefault("__slots__", [])
        for attr in ["name", "overload_fields"]:
            try:
                dct["_%s" % attr] = dct.pop(attr)
            except KeyError:
                pass
        # Build and inject signature
        try:
            # Py3 only
            import inspect
            dct["__signature__"] = inspect.Signature([
                inspect.Parameter("_pkt", inspect.Parameter.POSITIONAL_ONLY),
            ] + [
                inspect.Parameter(f.name,
                                  inspect.Parameter.KEYWORD_ONLY,
                                  default=f.default)
                for f in dct["fields_desc"]
            ])
        except (ImportError, AttributeError, KeyError):
            pass
        newcls = cast('Type[scapy.packet.Packet]',
                      type.__new__(cls, name, bases, dct))
        # Note: below can't be typed because we use attributes
        # created dynamically..
        newcls.__all_slots__ = set(
            attr
            for cls in newcls.__mro__ if hasattr(cls, "__slots__")
            for attr in cls.__slots__
        )

        newcls.aliastypes = (
            [newcls] + getattr(newcls, "aliastypes", [])
        )

        if hasattr(newcls, "register_variant"):
            newcls.register_variant()
        for _f in newcls.fields_desc:
            if hasattr(_f, "register_owner"):
                _f.register_owner(newcls)
        if newcls.__name__[0] != "_":
            from scapy import config
            config.conf.layers.register(newcls)
        return newcls

    def __getattr__(self, attr):
        # type: (str) -> scapy.fields.Field[Any, Any]
        for k in self.fields_desc:  # type: ignore
            if k.name == attr:
                return k  # type: ignore
        raise AttributeError(attr)

    def __call__(cls,
                 *args,  # type: Any
                 **kargs  # type: Any
                 ):
        # type: (...) -> 'scapy.packet.Packet'
        if "dispatch_hook" in cls.__dict__:
            try:
                cls = cls.dispatch_hook(*args, **kargs)  # type: ignore
            except Exception:
                from scapy import config
                if config.conf.debug_dissector:
                    raise
                cls = config.conf.raw_layer  # type: ignore
        i = cls.__new__(
            cls,  # type: ignore
            cls.__name__,
            cls.__bases__,
            cls.__dict__
        )
        i.__init__(*args, **kargs)
        return i  # type: ignore class _CanvasDumpExtended(object):
    def canvas_dump(self, **kwargs):
        # type: (**Any) -> 'pyx.canvas.canvas'
        pass

    def psdump(self, filename=None, **kargs):
        # type: (Optional[str], **Any) -> None
        """
        psdump(filename=None, layer_shift=0, rebuild=1)

        Creates an EPS file describing a packet. If filename is not provided a
        temporary file is created and gs is called.

        :param filename: the file's filename
        """
        from scapy.config import conf
        from scapy.utils import get_temp_file, ContextManagerSubprocess
        canvas = self.canvas_dump(**kargs)
        if filename is None:
            fname = get_temp_file(autoext=kargs.get("suffix", ".eps"))
            canvas.writeEPSfile(fname)
            if WINDOWS and conf.prog.psreader is None:
                os.startfile(fname)
            else:
                with ContextManagerSubprocess(conf.prog.psreader):
                    subprocess.Popen([conf.prog.psreader, fname])
        else:
            canvas.writeEPSfile(filename)
        print()

    def pdfdump(self, filename=None, **kargs):
        # type: (Optional[str], **Any) -> None
        """
        pdfdump(filename=None, layer_shift=0, rebuild=1)

        Creates a PDF file describing a packet. If filename is not provided a
        temporary file is created and xpdf is called.

        :param filename: the file's filename
        """
        from scapy.config import conf
        from scapy.utils import get_temp_file, ContextManagerSubprocess
        canvas = self.canvas_dump(**kargs)
        if filename is None:
            fname = get_temp_file(autoext=kargs.get("suffix", ".pdf"))
            canvas.writePDFfile(fname)
            if WINDOWS and conf.prog.pdfreader is None:
                os.startfile(fname)
            else:
                with ContextManagerSubprocess(conf.prog.pdfreader):
                    subprocess.Popen([conf.prog.pdfreader, fname])
        else:
            canvas.writePDFfile(filename)
        print()

    def svgdump(self, filename=None, **kargs):
        # type: (Optional[str], **Any) -> None
        """
        svgdump(filename=None, layer_shift=0, rebuild=1)

        Creates an SVG file describing a packet. If filename is not provided a
        temporary file is created and gs is called.

        :param filename: the file's filename
        """
        from scapy.config import conf
        from scapy.utils import get_temp_file, ContextManagerSubprocess
        canvas = self.canvas_dump(**kargs)
        if filename is None:
            fname = get_temp_file(autoext=kargs.get("suffix", ".svg"))
            canvas.writeSVGfile(fname)
            if WINDOWS and conf.prog.svgreader is None:
                os.startfile(fname)
            else:
                with ContextManagerSubprocess(conf.prog.svgreader):
                    subprocess.Popen([conf.prog.svgreader, fname])
        else:
            canvas.writeSVGfile(filename)
        print() class RandField(VolatileValue[_T], Generic[_T]):
    pass class VolatileValue(Generic[_T]):
    def __repr__(self):
        # type: () -> str
        return "<%s>" % self.__class__.__name__

    def _command_args(self):
        # type: () -> str
        return ''

    def command(self):
        # type: () -> str
        return "%s(%s)" % (self.__class__.__name__, self._command_args())

    def __eq__(self, other):
        # type: (Any) -> bool
        x = self._fix()
        y = other._fix() if isinstance(other, VolatileValue) else other
        if not isinstance(x, type(y)):
            return False
        return bool(x == y)

    def __ne__(self, other):
        # type: (Any) -> bool
        # Python 2.7 compat
        return not self == other

    __hash__ = None  # type: ignore

    def __getattr__(self, attr):
        # type: (str) -> Any
        if attr in ["__setstate__", "__getstate__"]:
            raise AttributeError(attr)
        return getattr(self._fix(), attr)

    def __str__(self):
        # type: () -> str
        return str(self._fix())

    def __bytes__(self):
        # type: () -> bytes
        return bytes_encode(self._fix())

    def __len__(self):
        # type: () -> int
        # Does not work for some types (int?)
        return len(self._fix())  # type: ignore

    def copy(self):
        # type: () -> Any
        return copy.copy(self)

    def _fix(self):
        # type: () -> _T
        return cast(_T, None) @conf.commands.register
def import_hexcap(input_string=None):
    # type: (Optional[str]) -> bytes
    """Imports a tcpdump like hexadecimal view

    e.g: exported via hexdump() or tcpdump or wireshark's "export as hex"

    :param input_string: String containing the hexdump input to parse. If None,
        read from standard input.
    """
    re_extract_hexcap = re.compile(r"^((0x)?[0-9a-fA-F]{2,}[ :\t]{,3}|) *(([0-9a-fA-F]{2} {,2}){,16})")  # noqa: E501
    p = ""
    try:
        if input_string:
            input_function = six.StringIO(input_string).readline
        else:
            input_function = input
        while True:
            line = input_function().strip()
            if not line:
                break
            try:
                p += re_extract_hexcap.match(line).groups()[2]  # type: ignore
            except Exception:
                warning("Parsing error during hexcap")
                continue
    except EOFError:
        pass

    p = p.replace(" ", "")
    return hex_bytes(p) def tex_escape(x):
    # type: (str) -> str
    s = ""
    for c in x:
        s += _TEX_TR.get(c, c)
    return s def colgen(*lstcol,  # type: Any
           **kargs  # type: Any
           ):
    # type: (...) -> Iterator[Any]
    """Returns a generator that mixes provided quantities forever
    trans: a function to convert the three arguments into a color. lambda x,y,z:(x,y,z) by default"""  # noqa: E501
    if len(lstcol) < 2:
        lstcol *= 2
    trans = kargs.get("trans", lambda x, y, z: (x, y, z))
    while True:
        for i in range(len(lstcol)):
            for j in range(len(lstcol)):
                for k in range(len(lstcol)):
                    if i != j or j != k or k != i:
                        yield trans(lstcol[(i + j) % len(lstcol)], lstcol[(j + k) % len(lstcol)], lstcol[(k + i) % len(lstcol)])  # noqa: E501 def issubtype(x,  # type: Any
              t,  # type: Union[type, str]
              ):
    # type: (...) -> bool
    """issubtype(C, B) -> bool

    Return whether C is a class and if it is a subclass of class B.
    When using a tuple as the second argument issubtype(X, (A, B, ...)),
    is a shortcut for issubtype(X, A) or issubtype(X, B) or ... (etc.).
    """
    if isinstance(t, str):
        return t in (z.__name__ for z in x.__bases__)
    if isinstance(x, type) and issubclass(x, t):
        return True
    return False def pretty_list(rtlst,  # type: List[Tuple[Union[str, List[str]], ...]]
                header,  # type: List[Tuple[str, ...]]
                sortBy=0,  # type: int
                borders=False,  # type: bool
                ):
    # type: (...) -> str
    """
    Pretty list to fit the terminal, and add header.

    :param rtlst: a list of tuples. each tuple contains a value which can
        be either a string or a list of string.
    :param sortBy: the column id (starting with 0) which will be used for
        ordering
    :param borders: whether to put borders on the table or not
    """
    if borders:
        _space = "|"
    else:
        _space = "  "
    cols = len(header[0])
    # Windows has a fat terminal border
    _spacelen = len(_space) * (cols - 1) + int(WINDOWS)
    _croped = False
    # Sort correctly
    rtlst.sort(key=lambda x: x[sortBy])
    # Resolve multi-values
    for i, line in enumerate(rtlst):
        ids = []  # type: List[int]
        values = []  # type: List[Union[str, List[str]]]
        for j, val in enumerate(line):
            if isinstance(val, list):
                ids.append(j)
                values.append(val or " ")
        if values:
            del rtlst[i]
            k = 0
            for ex_vals in zip_longest(*values, fillvalue=" "):
                if k:
                    extra_line = [" "] * cols
                else:
                    extra_line = list(line)  # type: ignore
                for j, h in enumerate(ids):
                    extra_line[h] = ex_vals[j]
                rtlst.insert(i + k, tuple(extra_line))
                k += 1
    rtslst = cast(List[Tuple[str, ...]], rtlst)
    # Append tag
    rtslst = header + rtslst
    # Detect column's width
    colwidth = [max(len(y) for y in x) for x in zip(*rtslst)]
    # Make text fit in box (if required)
    width = get_terminal_width()
    if conf.auto_crop_tables and width:
        width = width - _spacelen
        while sum(colwidth) > width:
            _croped = True
            # Needs to be cropped
            # Get the longest row
            i = colwidth.index(max(colwidth))
            # Get all elements of this row
            row = [len(x[i]) for x in rtslst]
            # Get biggest element of this row: biggest of the array
            j = row.index(max(row))
            # Re-build column tuple with the edited element
            t = list(rtslst[j])
            t[i] = t[i][:-2] + "_"
            rtslst[j] = tuple(t)
            # Update max size
            row[j] = len(t[i])
            colwidth[i] = max(row)
    if _croped:
        log_runtime.info("Table cropped to fit the terminal (conf.auto_crop_tables==True)")  # noqa: E501
    # Generate padding scheme
    fmt = _space.join(["%%-%ds" % x for x in colwidth])
    # Append separation line if needed
    if borders:
        rtslst.insert(1, tuple("-" * x for x in colwidth))
    # Compile
    return "\n".join(fmt % x for x in rtslst) class EDecimal(Decimal):
    """Extended Decimal

    This implements arithmetic and comparison with float for
    backward compatibility
    """

    def __add__(self, other, context=None):
        # type: (_Decimal, Any) -> EDecimal
        return EDecimal(Decimal.__add__(self, Decimal(other)))

    def __radd__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__add__(self, Decimal(other)))

    def __sub__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__sub__(self, Decimal(other)))

    def __rsub__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__rsub__(self, Decimal(other)))

    def __mul__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__mul__(self, Decimal(other)))

    def __rmul__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__mul__(self, Decimal(other)))

    def __truediv__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__truediv__(self, Decimal(other)))

    def __floordiv__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__floordiv__(self, Decimal(other)))

    if sys.version_info >= (3,):
        def __divmod__(self, other):
            # type: (_Decimal) -> Tuple[EDecimal, EDecimal]
            r = Decimal.__divmod__(self, Decimal(other))
            return EDecimal(r[0]), EDecimal(r[1])
    else:
        def __div__(self, other):
            # type: (_Decimal) -> EDecimal
            return EDecimal(Decimal.__div__(self, Decimal(other)))

        def __rdiv__(self, other):
            # type: (_Decimal) -> EDecimal
            return EDecimal(Decimal.__rdiv__(self, Decimal(other)))

    def __mod__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__mod__(self, Decimal(other)))

    def __rmod__(self, other):
        # type: (_Decimal) -> EDecimal
        return EDecimal(Decimal.__rmod__(self, Decimal(other)))

    def __pow__(self, other, modulo=None):
        # type: (_Decimal, Optional[_Decimal]) -> EDecimal
        return EDecimal(Decimal.__pow__(self, Decimal(other), modulo))

    def __eq__(self, other):
        # type: (Any) -> bool
        return super(EDecimal, self).__eq__(other) or float(self) == other

    def normalize(self, precision):  # type: ignore
        # type: (int) -> EDecimal
        with decimal.localcontext() as ctx:
            ctx.prec = precision
            return EDecimal(super(EDecimal, self).normalize(ctx)) PYX = 1     FAKE_TYPING = False
    FAKE_TYPING = True
    TYPE_CHECKING = False
    IO = _FakeType("IO")  # type: ignore
        AF_INET = socket.AF_INET
        AF_INET6 = socket.AF_INET6
class _Generic_metaclass(type):
    class _FT(object):
    class Sized(object):  # type: ignore
    class Generic(object):  # type: ignore
        class _NT(cls):
    class AddressFamily:
        def __getitem__(self, typ):
def _FakeType(name, cls=object):
        def __init__(self, name):
        def __getitem__(self, item):  # type: ignore
        def __call__(self, *args, **kargs):
        def __repr__(self):
    def cast(_type, obj):  # type: ignore
    def _unpickleNamedTuple(name, len_params, *args):
    def NamedTuple(name, params):
            def __reduce__(self):
def lambda_tuple_converter(func):
    def chb(x):
    def raw(x):
    def raw(x):
    def bytes_encode(x):
        def plain_str(x):
        def plain_str(x):
    def chb(x):
    def orb(x):
def bytes_hex(x):
def hex_bytes(x):
    def int_bytes(x, size):
    def bytes_int(x):
    def int_bytes(x, size):
    def bytes_int(x):
def base64_bytes(x):
def bytes_base64(x):
    def gzip_decompress(x):
    def gzip_compress(x):
from collections import defaultdict
from scapy.fields import (
    AnyField,
    BitField,
    ConditionalField,
    Emph,
    EnumField,
    Field,
    FlagsField,
    MultiEnumField,
    MultipleTypeField,
    PacketListField,
    RawVal,
    StrField,
)
from scapy.config import conf, _version_checker
from scapy.compat import raw, orb, bytes_encode
from scapy.base_classes import BasePacket, Gen, SetGen, Packet_metaclass, \
    _CanvasDumpExtended
from scapy.interfaces import _GlobInterfaceType
from scapy.volatile import RandField, VolatileValue
from scapy.utils import import_hexcap, tex_escape, colgen, issubtype, \
    pretty_list, EDecimal
from scapy.error import Scapy_Exception, log_runtime, warning
from scapy.extlib import PYX
from scapy.compat import (
    Any,
    Callable,
    Dict,
    Iterator,
    List,
    NoReturn,
    Optional,
    Set,
    Tuple,
    Type,
    TypeVar,
    Union,
    Sequence,
    cast,
)
            from scapy.themes import AnsiColorTheme
        from prompt_toolkit.shortcuts.dialogs import radiolist_dialog, \
            button_dialog
        from prompt_toolkit.formatted_text import HTML
            from scapy.main import list_contrib
            from scapy.main import load_contrib
                from scapy.main import load_contrib
import re
import time
import itertools
import copy
import types
import warnings
import scapy.modules.six as six
    import pyx
            import prompt_toolkit
# This file is part of Scapy
# See http://www.secdev.org/projects/scapy for more information
# Copyright (C) Philippe Biondi <phil@secdev.org>
# This program is published under a GPLv2 license

"""
Packet class

Provides:
 - the default Packet classes
 - binding mechanisms
 - fuzz() method
 - exploration methods: explore() / ls()
"""

from __future__ import absolute_import
from __future__ import print_function


# Typing imports
try:
except ImportError:
    pass



_T = TypeVar("_T", Dict[str, Any], Optional[Dict[str, Any]])