$gndZddlZddlmZmZmZmZmZm Z m Z ddl m Z mZGddeZGddeZGd d eZdKd d d ZGddeeZGddeeZdZdZdZdZdZdZdLdZdZdZdZ dZ!edZ"eded ed!gZ#ed"Z$ed#Z%ed$Z&ed%ed&ed'ed(ed)ed*ed+d,ed-d.fe"e&fzZ'd/d0DZ(d1d2DZ)ed3Z*ed4Z+ed5Z,ed6Z-ed7ed8ed9ed:ed;ed<ed=ed>ed?ed@edAedBedCedDedEedFfZ.dGdHDZ/dIdJDZ0dS)Mz9Routines for IPv4 and IPv6 addresses, subnets and ranges.N)AddrFormatErrorAddrConversionError DictDotLookupNOHOST INET_ATON INET_PTONZEROFILL)ipv4ipv6ceZdZdZdZdZdZededZdZ d Z d Z d Z d Z d ZdZdZdZdZdZdZdZdZdZdZedZedZdS)BaseIPzi An abstract base class for common operations shared between various IP related subclasses. )_value_module __weakref__c"d|_d|_dS)z Constructor.N)rrselfs S/var/www/html/netbox-4.1.3/venv/lib/python3.11/site-packages/netaddr/ip/__init__.py__init__zBaseIP.__init__ s  ct|tstdt|zd|cxkr|jjksnt d|jjz||_dS)Nint argument expected, not %srz&value out of bounds for an %s address!) isinstanceint TypeErrortypermax_intr family_namerrvalues r _set_valuezBaseIP._set_value%s%%% K;d5kkIJJ JE1111T\11111!84<;SS  rc|jSNrrs rzBaseIP./sT[rz?a positive integer representing the value of IP address/subnet.docctSzP :return: a key tuple that uniquely identifies this IP address. NotImplementedrs rkeyz BaseIP.key4s rctS)zg :return: A key tuple used to compare and sort this `IPAddress` correctly. r*rs rsort_keyzBaseIP.sort_key:s rcDt|S)zL :return: A hash value uniquely identifying this IP object. )hashr,rs r__hash__zBaseIP.__hash__AsDHHJJrc ||kS#ttf$r tcYSwxYw)z :param other: an `IPAddress` or `IPNetwork` object. :return: ``True`` if this `IPAddress` or `IPNetwork` object is equivalent to ``other``, ``False`` otherwise. r,AttributeErrorrr+rothers r__eq__z BaseIP.__eq__GN "88::, , * " " "! ! ! ! "),AAc ||kS#ttf$r tcYSwxYw)z :param other: an `IPAddress` or `IPNetwork` object. :return: ``True`` if this `IPAddress` or `IPNetwork` object is not equivalent to ``other``, ``False`` otherwise. r3r5s r__ne__z BaseIP.__ne__Sr8r9c ||kS#ttf$r tcYSwxYw)z :param other: an `IPAddress` or `IPNetwork` object. :return: ``True`` if this `IPAddress` or `IPNetwork` object is less than ``other``, ``False`` otherwise. r.r4rr+r5s r__lt__z BaseIP.__lt___P "==??U^^%5%55 5 * " " "! ! ! ! "r9c ||kS#ttf$r tcYSwxYw)z :param other: an `IPAddress` or `IPNetwork` object. :return: ``True`` if this `IPAddress` or `IPNetwork` object is less than or equal to ``other``, ``False`` otherwise. r=r5s r__le__z BaseIP.__le__kP "==??enn&6&66 6 * " " "! ! ! ! "r9c ||kS#ttf$r tcYSwxYw)z :param other: an `IPAddress` or `IPNetwork` object. :return: ``True`` if this `IPAddress` or `IPNetwork` object is greater than ``other``, ``False`` otherwise. r=r5s r__gt__z BaseIP.__gt__wr?r9c ||kS#ttf$r tcYSwxYw)z :param other: an `IPAddress` or `IPNetwork` object. :return: ``True`` if this `IPAddress` or `IPNetwork` object is greater than or equal to ``other``, ``False`` otherwise. r=r5s r__ge__z BaseIP.__ge__rBr9c,| S)z<:return: ``True`` if this IP is unicast, ``False`` otherwise) is_multicastrs r is_unicastzBaseIP.is_unicasts$$&&&&rcj|jtkr |tvS|jtkr |tvSdS)z>:return: ``True`` if this IP is multicast, ``False`` otherwiseN)r_ipv4IPV4_MULTICAST_ipv6IPV6_MULTICASTrs rrHzBaseIP.is_multicasts: <5 >) ) \U " ">) )# "rcj|jjdkr |tvS|jjdkr |tvSdS)z :return: ``True`` if this IP is loopback address (not for network transmission), ``False`` otherwise. References: RFC 3330 and 4291. .. note:: |ipv4_in_ipv6_handling| N)rversion IPV4_LOOPBACK IPV6_LOOPBACKrs r is_loopbackzBaseIP.is_loopbacksB < 1 $ $=( ( \ !Q & &=( (' &rcj|jjdkr |tvS|jjdkr |tvSdS)z :return: ``True`` if this IP is link-local address ``False`` otherwise. Reference: RFCs 3927 and 4291. .. note:: |ipv4_in_ipv6_handling| rPrQN)rrRIPV4_LINK_LOCALIPV6_LINK_LOCALrs r is_link_localzBaseIP.is_link_localsB < 1 $ $?* * \ !Q & &?* *' &rc|jjdkrtD] }||vrdS n!|jjdkrtD] }||vrdS dS)z :return: ``True`` if this IP is in IANA reserved range, ``False`` otherwise. Reference: RFCs 3330 and 3171. .. note:: |ipv4_in_ipv6_handling| rPTrQF)rrR IPV4_RESERVED IPV6_RESERVED)rcidrs r is_reservedzBaseIP.is_reservedsx < 1 $ $%  4<<44  \ !Q & &%  4<<44 urc>|jjdko |jdz dkS)zl :return: ``True`` if this IP is IPv4-mapped IPv6 address, ``False`` otherwise. rQ irrRrrs ris_ipv4_mappedzBaseIP.is_ipv4_mappeds% |#q(JdkR.?F-JJrc>|jjdko |jdz dkS)zp :return: ``True`` if this IP is IPv4-compatible IPv6 address, ``False`` otherwise. rQr`rrars ris_ipv4_compatzBaseIP.is_ipv4_compats% |#q(EdkR.?A-EErc>ddlm}t||S)z~ A record dict containing IANA registration details for this IP address if available, None otherwise. r)query)netaddr.ip.ianarfr)rrfs rinfoz BaseIP.infos, *)))))UU4[[)))rc|jjS)z6the IP protocol version represented by this IP object.)rrRrs rrRzBaseIP.versions|##rN)__name__ __module__ __qualname____doc__ __slots__rr!propertyr r,r.r1r7r;r>rArDrFrIrHrUrYr^rbrdrhrRrrr r s 5I  H   M   E     " " " " " " " " " " " " " " " " " "'''*** ) ) ) + + +"KKKFFF**X*$$X$$$rr cDeZdZdZdZd*fd ZdZdZdZd Z d Z d Z d Z d Z e ZdZdZdZdZdZdZdZd+dZedZedZedZedZdZd,dZd+dZdZdZ d Z!d!Z"d"Z#d#Z$d$Z%d%Z&d&Z'd'Z(d(Z)d)Z*xZ+S)- IPAddressz An individual IPv4 or IPv6 address without a net mask or subnet prefix. To support these and other network based operations, see `IPNetwork`. rpNrc&tt||ttzt zzrt d||t zr|tzrt dt|tr;|||j j krt d|j |_ |j |_ dS|8|dkr t|_ n%|dkr t|_ nt d|zt|tr d|vrt d |jjz|j  t|t"r d t#|cxkrtjkr$nn!t#||_ t|_ nQtjt#|cxkrtjkr#nn t#||_ t|_ nU#t $rYnIwxYwttfD]6} ||||_ ||_ n#t($rY3wxYw|j t)d |zdSt|trO |j |||_ dS#t($rt)d ||j j fzwxYwd t#|cxkr|j jkrnnt#||_ dSt)d |)u Constructor. :param addr: an IPv4 or IPv6 address which may be represented in an accepted string format, as an unsigned integer or as another IPAddress object (copy construction). :param version: (optional) optimizes version detection if specified and distinguishes between IPv4 and IPv6 for addresses with an equivalent integer value. :param flags: (optional) decides which rules are applied to the interpretation of the addr value if passed as a string. Matters only in IPv4 context. Allowed flag values: * :data:`INET_ATON`. Follows `inet_aton semantics `_ and allows all kinds of weird-looking addresses to be parsed. For example: >>> IPAddress('1', flags=INET_ATON) IPAddress('0.0.0.1') >>> IPAddress('1.0xf', flags=INET_ATON) IPAddress('1.0.0.15') >>> IPAddress('010.020.030.040', flags=INET_ATON) IPAddress('8.16.24.32') * ``INET_ATON | ZEROFILL`` or :data:`ZEROFILL` – like ``INET_ATON``, except leading zeros are discarded: >>> IPAddress('010', flags=INET_ATON | ZEROFILL) IPAddress('0.0.0.10') * The default (``0``) or :data:`INET_PTON` – requires four decimal octets: >>> IPAddress('10.0.0.1', flags=INET_PTON) IPAddress('10.0.0.1') Leading zeros may be ignored or rejected, depending on the platform. * ``INET_PTON | ZEROFILL`` – like the default :data:`INET_PTON`, except leading zeros are discarded: >>> IPAddress('010.020.030.040', flags=INET_PTON | ZEROFILL) IPAddress('10.20.30.40') .. versionchanged:: 1.0.0 Changed the default IPv4 parsing mode from :data:`INET_ATON` to :data:`INET_PTON`. $Unrecognized IPAddress flags value: z.INET_ATON and INET_PTON are mutually exclusiveNz1cannot switch IP versions using copy constructor!rPrQ%r is an invalid IP version!/zQ%s() does not support netmasks or subnet prefixes! See documentation for details.rz+failed to detect a valid IP address from %rzbase address %r is not IPv%dzbad address format: )superrrrrr r ValueErrorrr rrRrrKrMstr __class__rjrr str_to_intr)raddrrRflagsmodulerzs rrzIPAddress.__init__s^f i''))) Y)I56 6 R*PQQ Q 9  O!2 OMNN N dF # #; R"w$,2F'F'F !WXXX+DK>)T\-ABB BDEEErct|j|z }d|cxkr|jjkr#nn |||jjSt d)a Subtract the numerical value of this IP address from num providing the result as a new IPAddress object. :param num: size of IP address decrease. :return: a new IPAddress object with its numerical value decreased by num. rrrrs r__sub__zIPAddress.__sub__rrct||jz }d|cxkr|jjkr#nn |||jjSt d)a Subtract num (lvalue) from the numerical value of this IP address (rvalue) providing the result as a new IPAddress object. :param num: size of IP address decrease. :return: a new IPAddress object with its numerical value decreased by num. rrrrs r__rsub__zIPAddress.__rsub__sgdk)** 1 1 1 1T\1 1 1 1 1 1>>)T\-ABB BDEEErc(|jj|jfSr)rars rr,z IPAddress.keys|#T[00rc>|jj|j|jjfS)zI:return: A key tuple used to compare and sort this `IPAddress` correctly.)rrRrrrs rr.zIPAddress.sort_keys|#T[$,2DDDrc|jS)z<:return: the value of this IP address as an unsigned integerr$rs r__int__zIPAddress.__int__s {rc|jS)zG :return: return the integer value of this IP address. r$rs r __index__zIPAddress.__index__s {rcR|j|jjdzdS)zw :return: a bytes object equivalent to this IP address. In network byte order, big-endian. big)rto_bytesrrrs r __bytes__zIPAddress.__bytes__s& {##DL$6!$;UCCCrcB|j|j|S)z :param word_sep: (optional) the separator to insert between words. Default: None - use default separator for address type. :return: the value of this IP address as a binary digit string.)r int_to_bitsr)rword_seps rbitszIPAddress.bits s |'' X>>>rc@|j|jS)z7The value of this IP address as a packed binary string.)r int_to_packedrrs rpackedzIPAddress.packeds|))$+666rc@|j|jS)zx A list of unsigned integer words (octets for IPv4, hextets for IPv6) found in this IP address. )r int_to_wordsrrs rwordszIPAddress.wordss |((555rc@|j|jS)z The value of this IP address in standard Python binary representational form (0bxxx). A back port of the format provided by the builtin bin() function found in Python 2.6.x and higher. )r int_to_binrrs rbinz IPAddress.bin"s|&&t{333rc@|j|jS)z1The reverse DNS lookup record for this IP address)r int_to_arparrs r reverse_dnszIPAddress.reverse_dns+s|'' 444rcjd}|j}|jjdkr||jd}n|jjdkrwd|jcxkrtjkrnn||jd}nFtj|jcxkrdkrnn||jdz d}nt d|z|S)z Raises an `AddrConversionError` if IPv6 address cannot be converted to IPv4. :return: A numerically equivalent version 4 `IPAddress` object. NrPrQr2IPv6 address %s unsuitable for conversion to IPv4!)rzrrRrrKrr)ripklasss rr zIPAddress.ipv40s < 1 $ $t{A&&BB \ !Q & &DK00005=00000U4;**$+?????????U4;7;;)KdR rFc"d}|j}|jjdkr>|r*d|jcxkrdkrnn||jdz d}nI||jd}n7|jjdkr'||jd}|s|d|jzd}|S)a .. note:: The IPv4-compatible IPv6 address format is now considered deprecated. See RFC 4291 or later for details. :param ipv4_compatible: If ``True`` returns an IPv4-compatible address (::x.x.x.x), an IPv4-mapped (::ffff:x.x.x.x) address otherwise. Default: False (IPv4-mapped). :return: A numerically equivalent version 6 `IPAddress` object. NrQrrrP)rzrrRrripv4_compatiblerrs rr zIPAddress.ipv6Gs < 1 $ $ +Ndk$S$S$S$S^$S$S$S$S$SU4;7;;U4;** \ !Q & &t{A&&B" <U>DK7;; rc|t|dstd|j|j|S)z Only relevant for IPv6 addresses. Has no effect for IPv4. :param dialect: One of the :ref:`ipv6_formatting_dialects`. :return: an alternate string representation for this IP address. Nword_fmtz-custom dialects should subclass ipv6_verbose!)dialect)hasattrrr int_to_strr)rrs rformatzIPAddress.formatcsI  7J// Q OPPP|&&t{G&DDDrcl||jt|z|jjS)z :param other: An `IPAddress` object (or other int-like object). :return: bitwise OR (x | y) between the integer value of this IP address and ``other``. rzrrrrRr5s r__or__zIPAddress.__or__p*~~dkCJJ6 8LMMMrcl||jt|z|jjS)z :param other: An `IPAddress` object (or other int-like object). :return: bitwise AND (x & y) between the integer value of this IP address and ``other``. rr5s r__and__zIPAddress.__and__yrrcl||jt|z |jjS)z :param other: An `IPAddress` object (or other int-like object). :return: bitwise exclusive OR (x ^ y) between the integer value of this IP address and ``other``. rr5s r__xor__zIPAddress.__xor__rrcR||j|z|jjS)z :param numbits: size of bitwise shift. :return: an `IPAddress` object based on this one with its integer value left shifted by ``numbits``. rzrrrRrrs r __lshift__zIPAddress.__lshift__$~~dkW4dl6JKKKrcR||j|z |jjS)z :param numbits: size of bitwise shift. :return: an `IPAddress` object based on this one with its integer value right shifted by ``numbits``. rrs r __rshift__zIPAddress.__rshift__rrc*t|jS)zi:return: ``True`` if the numerical value of this IP address is not zero, ``False`` otherwise.)boolrrs r__bool__zIPAddress.__bool__sDK   rc@|j|jS)z,:return: IP address in presentational format)rrrrs r__str__zIPAddress.__str__s|&&t{333rc&|jjd|dS8:return: Python statement to create an equivalent object('')rzrjrs r__repr__zIPAddress.__repr__!^444ddd;;rcV|s|S|S)aB Converts the address to IPv4 if it is an IPv4-mapped IPv6 address (`RFC 4291 Section 2.5.5.2 `_), otherwise returns the address as-is. >>> # IPv4-mapped IPv6 >>> IPAddress('::ffff:10.0.0.1').to_canonical() IPAddress('10.0.0.1') >>> >>> # Everything else >>> IPAddress('::1').to_canonical() IPAddress('::1') >>> IPAddress('10.0.0.1').to_canonical() IPAddress('10.0.0.1') .. versionadded:: 0.10.0 )rbr rs r to_canonicalzIPAddress.to_canonicals+$""$$ Kyy{{rcjjdkrt}t}nt}t }t fd|D pt fd|DS)a Returns ``True`` if this address is considered globally reachable, ``False`` otherwise. An address is considered globally reachable if it's not a special-purpose address or it's a special-purpose address listed as globally reachable in the relevant registries: * |iana_special_ipv4| * |iana_special_ipv6| Addresses for which the ``Globally Reachable`` value is ``N/A`` are not considered globally reachable. Address blocks with set termination date are not taken into consideration. Whether or not an address can actually be reached in any local or global context will depend on the network configuration and may differ from what this method returns. Examples: >>> IPAddress('1.1.1.1').is_global() True >>> IPAddress('::1').is_global() False .. note:: |ipv4_in_ipv6_handling| rPc3 K|]}|vV dSr#rp.0netrs r z&IPAddress.is_global..s'<.s@D D DCKD D D D D D r)rrRIPV4_NOT_GLOBALLY_REACHABLE&IPV4_NOT_GLOBALLY_REACHABLE_EXCEPTIONSIPV6_NOT_GLOBALLY_REACHABLE&IPV6_NOT_GLOBALLY_REACHABLE_EXCEPTIONSany)r not_reachable exceptionss` r is_globalzIPAddress.is_globals8 < 1 $ $7M?JJ7M?J<<<.s'0[0[$0[0[0[0[0[0[r)rrRrIPV4_PRIVATE_USErs`ris_ipv4_private_usezIPAddress.is_ipv4_private_uses8|#q([S0[0[0[0[JZ0[0[0[-[-[[rc4|jjdko|tvS)z Returns ``True`` if this address is an IPv6 unique local address as defined in :rfc:`4193` and listed in |iana_special_ipv6|. The IPv6 unique local address block: ``fc00::/7``. .. versionadded:: 0.10.0 rQ)rrRIPV6_UNIQUE_LOCALrs ris_ipv6_unique_localzIPAddress.is_ipv6_unique_locals|#q(FT5F-FFrNrr#F),rjrkrlrmrnrrrrrrrrr__radd__rrr,r.rrrrrorrrrr r rrrrrrrrrrrrr __classcell__rzs@rrrrrsIvRvRvRvRvRvRp111TTT <,,,,,, F F F F F F F F FH F F F F F F111EEE DDD????77X766X644X455X5.8 E E E ENNNNNNNNNLLLLLL!!! 444<<<,% % % N\\\" G G G G G G GrrrcJeZdZdZdZdZedZdZdZ dZ dZ d S) IPListMixinzu A mixin class providing shared list-like functionality to classes representing groups of IP addresses. rpct|j|jj}t|j|jj}t ||S)z :return: An iterator providing access to all `IPAddress` objects within range represented by this ranged IP object. )rrfirstrrRlast iter_iprange)rstart_ipend_ips r__iter__zIPListMixin.__iter__ s@ TZ)=>>49dl&:;;Hf---rc@t|j|jz dzS)zP The total number of IP addresses within this ranged IP object. r)rr r rs rsizezIPListMixin.sizes 49tz)A-...rcl|j}|tjkrtdtjz|S)z :return: the number of IP addresses in this ranged IP object. Raises an `IndexError` if size > system max int (a Python 2.x limitation). Use the .size property for subnets of any size. zWrange contains more than %d (sys.maxsize) IP addresses! Use the .size property instead.)r_sysmaxsizer)rrs r__len__zIPListMixin.__len__sB y $,  DFJlS   rcTd}t|dr|jjdkrtd||j\}}}||zdks||kr/t t|j|jjg}nt|j|z|jj}||dkrdndz}t|j|z|jj}t|||}n t|}|j |cxkrdkr)nn&t|j |zdz|jj}nJd|cxkr|jdz kr&nn#t|j|z|jj}ntdn #t$rtd |zwxYw|S) z :return: The IP address(es) in this `IPNetwork` object referenced by index or slice. As slicing can produce large sequences of objects an iterator is returned instead of the more usual `list`. NindicesrQzIPv6 slices are not supported!rrz'index out range for address range size!zunsupported index type %r!)rrrRrrriterrrr r rr rrx) rindexitemstartstopstepr one_before_stoprs r __getitem__zIPListMixin.__getitem__-s  5) $ $ F|#q(( @AAA"'-- ":": UD$ q  dTkkYtz4<3GHHIJJ$TZ%%79MNN#'taxx!!R"@"4:#?AUVV#Hfd;; FE YJ5,,,,1,,,,,$TY%6%:DL>!"58J"JKK KyU,,,,fn,,,,!"G&J\"\]] ]Y....&,....!"@6CU"UVV V/ D#  #H $;;C++JD$$DD  70066D tV^9 = = =  RD II ) ) )|"L  R R RT6>CCCD   R"4T[A !!## R"5dkB %&ID&PQQQ RI--------!"BVEW"WXX X.9DJJFGGG v~ *95 ) sD F=5BF=<F=ceZdZdZdZd)ddfd ZdZd Zd Ze d ed Z e dZ e dZ e dZ e dZe dZe dZejdZe dZe dZe dZe dZdZdZdZdZdZdZd*dZd+d!Zd+d"Zd,d#Zd-d$Z d%Z!d&Z"d'Z#d(Z$xZ%S). IPNetworka An IPv4 or IPv6 network or subnet. A combination of an IP address and a network mask. Accepts CIDR and several related variants : a) Standard CIDR:: x.x.x.x/y -> 192.0.2.0/24 x::/y -> fe80::/10 b) Hybrid CIDR format (netmask address instead of prefix), where 'y' address represent a valid netmask:: x.x.x.x/y.y.y.y -> 192.0.2.0/255.255.255.0 x::/y:: -> fe80::/ffc0:: c) ACL hybrid CIDR format (hostmask address instead of prefix like Cisco's ACL bitmasks), where 'y' address represent a valid netmask:: x.x.x.x/y.y.y.y -> 192.0.2.0/0.0.0.255 x::/y:: -> fe80::/3f:ffff:ffff:ffff:ffff:ffff:ffff:ffff .. versionchanged:: 1.0.0 Removed the ``implicit_prefix`` switch that used to enable the abbreviated CIDR format support, use :func:`cidr_abbrev_to_verbose` if you need this behavior. .. versionchanged:: 1.1.0 Removed partial IPv4 address support accidentally left when making 1.0.0 release. Use :func:`expand_partial_ipv4_address` if you need this behavior. .. versionchanged:: 1.3.0 Added the expand_partial flag, which restores the previous behavior to expand partial IPv4 address  _prefixlenNrFr%c>tt||tzrt d|d\}}}t |dr2|j}|j}|j}|tzr|j |}||z}nt |dr|j}|j}|j }n|dkr#tt|||\}}t}n|dkr!tt||\}}t}n|t d |z t}t||||\}}nQ#t$rD t}t|||\}}n#t$rYnwxYw|td |YnwxYw||_||_||_dS) ai Constructor. :param addr: an IPv4 or IPv6 address with optional CIDR prefix, netmask or hostmask. May be an IP address in presentation (string) format, an tuple containing and integer address and a network prefix, or another IPAddress/IPNetwork object (copy construction). :param version: (optional) optimizes version detection if specified and distinguishes between IPv4 and IPv6 for addresses with an equivalent integer value. :param flags: (optional) decides which rules are applied to the interpretation of the addr value. Currently only supports the :data:`NOHOST` option. :param expand_partial: (optional) decides whether partial address is expanded. Currently this is only effective for IPv4 address. >>> IPNetwork('1.2.3.4/24') IPNetwork('1.2.3.4/24') >>> IPNetwork('1.2.3.4/24', flags=NOHOST) IPNetwork('1.2.3.0/24') >>> IPNetwork('10/24', expand_partial=True) IPNetwork('10.0.0.0/24') rt)NNNr:rrPr%rQNruzinvalid IPNetwork )rwr8rrrxrrrr:r0rr6rKrMr) rr|rRr}r&r r1r~r5rzs rrzIPNetwork.__init__s8 i''))) F7? R*PQQ Q#3 y& 4 & &# LKE\FIv~ ( 29= T8 $ $ LKE\F II \\/tUSabbb E9FF \\/tUCC E9FF" !?'!IJJJ L#3D%$$$ yy# L L L"F'7e'L'L$E99&D=)/DD*JKKK!= L # s6D77 FEF E+(F*E++FFc4|j|j|jjfS)z0:return: Pickled state of an `IPNetwork` object.)rr:rrRrs rrzIPNetwork.__getstate__s{DOT\-AAArc|\}}}||_|dkr t|_n%|dkr t|_nt d|d|cxkr|jjkr nn ||_dSt d|)zT :param state: data used to unpickle a pickled `IPNetwork` object. rPrQz#unpickling failed for object state rN)rrKrrMrxrr:)rrr r1rRs rrzIPNetwork.__setstate__s %*!y' a<< DLL \\ DLL*OPP P / / / /T\/ / / / / /'DOOO*OPP Prct|tstdt|zd|cxkr|jjksnt d|jjz||_dS)Nrrz!invalid prefix for an %s address!) rrrrrrrrr:rs r_set_prefixlenzIPNetwork._set_prefixlen4sw%%% K;d5kkIJJ JE////T\/////!"E H`"`aa arc|jSr#r9rs rr%zIPNetwork.<sT_rzCsize of the bitmask used to separate the network from the host bitsr&c@t|j|jjS)z The IP address of this `IPNetwork` object. This is may or may not be the same as the network IP address which varies according to the value of the CIDR subnet prefix. )rrrrrRrs rrz IPNetwork.ipAsdl&:;;;rcPt|j|jz|jjS)z/The network address of this `IPNetwork` object.)rrr _netmask_intrrRrs rnetworkzIPNetwork.networkJs#t'88$,:NOOOrc|jj|jz dkrdSt|j|jz|jjS)z1The broadcast address of this `IPNetwork` object.rN)rrr:rrr _hostmask_intrRrs r broadcastzIPNetwork.broadcastOs? L  0Q 6 64T[4+==t|?STT Trc:|j|jj|jz zS)ze The integer value of first IP address found within this `IPNetwork` object. )rrrrFrs rr zIPNetwork.firstWs {dl2T5GGHHrcJd|jj|jz zdz }|j|zS)zd The integer value of last IP address found within this `IPNetwork` object. r)rrr:rrhostmasks rr zIPNetwork.last_s, $,,t>?1D{X%%rc^|jj|jz }t||jjS)z+The subnet mask of this `IPNetwork` object.)rrrFrrrR)rr5s rr5zIPNetwork.netmaskhs+,&);;$,"6777rct|}|j|jkrtd|d||stdt |z||_dS)z%Set the prefixlen using a subnet maskzIP version mismatch: z and z!Invalid subnet mask specified: %sN)rrrRrxrryrr1)rr rs rr5zIPNetwork.netmaskns{u   : % %*TTJKK K}} O@3u::MNN N**rc*|jj|jz S)z+Same as self.netmask, but in integer format)rrrFrs rrCzIPNetwork._netmask_int{s|#d&888rcjd|jj|jz zdz }t||jjS)z)The host mask of this `IPNetwork` object.r)rrr:rrrRrJs rrKzIPNetwork.hostmasks4$,,t>?1D4<#7888rc6d|jj|jz zdz S)z,Same as self.hostmask, but in integer formatr)rrr:rs rrFzIPNetwork._hostmask_ints dl(4?:;q@@rc`t|j|jz|jf|jjS)z The true CIDR address for this `IPNetwork` object which omits any host bits to the right of the CIDR subnet prefix. rR)r8rrCr:rrRrs rr]zIPNetwork.cidrs6  [4, ,do > H\    rct|j|j|zz}||jdz z|jjkrt d|dkrt d||_|S)aP Increases the value of this `IPNetwork` object by the current size multiplied by ``num``. An `IndexError` is raised if result exceeds maximum IP address value or is less than zero. :param num: (optional) number of `IPNetwork` blocks to increment this IPNetwork's value by. rz#increment exceeds address boundary!rzincrement is less than zero!)rrDrrrrrrs rrzIPNetwork.__iadd__sl %%S9 Q '4<+? ? ?BCC C q==;<< <  rct|j|j|zz }|dkrtd||jdz z|jjkrtd||_|S)aP Decreases the value of this `IPNetwork` object by the current size multiplied by ``num``. An `IndexError` is raised if result is less than zero or exceeds maximum IP address value. :param num: (optional) number of `IPNetwork` blocks to decrement this IPNetwork's value by. rzdecrement is less than zero!rz#decrement exceeds address boundary!)rrDrrrrrrs rrzIPNetwork.__isub__sl %%S9 q==;<< < Q '4<+? ? ?BCC C  rct|tr|jj|jjkrdS|jj|jz }|j|z }t|tr)||z|jjko|dz|z|j jkS|j|z }t|tr||kSt|tr||ko|j|jkSt||vS)r"Fr) rr rrRrr:rIPRange_start_endrrr8)rr6 shiftwidthself_net other_nets rr#zIPNetwork.__contains__s eV $ $ U|#u}'<<<u+do=J{j0H%)) !J.5<3FFlz1UZ5FF 2I%++ - H,,%++ U9,TEDT1TT4''rc4|jj|j|jfS)zR :return: A key tuple used to uniquely identify this `IPNetwork`. rrRr r rs rr,z IPNetwork.key|#TZ::rc|jdz }|j|jj|jz z}|j|z }|jj|||fS)z[ :return: A key tuple used to compare and sort this `IPNetwork` correctly. r)r:rrrrFrR)r net_size_bitsr  host_bitss rr.zIPNetwork.sort_keysI!+  t|3d6HHIK%' |#UM9DDrcd}|j}|jjdkr|d|j|jfz}n|jjdkrd|jcxkrt jkr5nn2t j|j}|d||jdz fz}nft j|jcxkrdkr8nn5t j|jdz }|d||jdz fz}ntd |z|S) z :return: A numerically equivalent version 4 `IPNetwork` object. Raises an `AddrConversionError` if IPv6 address cannot be converted to IPv4. NrP%s/%drQr`rrr) rzrrRrr1rrKrrr)rrrr|s rr zIPNetwork.ipv4s)  < 1 $ $w$'4>!::;;BB \ !Q & &DK00005=00000' 44U7dDNR,?%@@AA$+?????????' n(DEEU7dDNR,?%@@AA)KdR rcpd}|j}|jjdkrN|r2d|jcxkrdkr nn||jdz |jfd}nh||j|jfd}nN|jjdkr>|r||j|jdzfd}n|d|jz|jdzfd}|S)a .. note:: the IPv4-mapped IPv6 address format is now considered deprecated. See RFC 4291 or later for details. :param ipv4_compatible: If ``True`` returns an IPv4-compatible address (::x.x.x.x), an IPv4-mapped (::ffff:x.x.x.x) address otherwise. Default: False (IPv4-mapped). :return: A numerically equivalent version 6 `IPNetwork` object. NrQrrrRrPrd)rzrrRrr:rs rr zIPNetwork.ipv6s < 1 $ $ FNdk$S$S$S$S^$S$S$S$S$SUDK.8$/JTUVVVUDK91EEE \ !Q & & \UDK2)=>JJJUNT[8$/B:NOYZ[[[ rrcn|d|j|jfz|jj}||z}|S)z :param step: the number of IP subnets between this `IPNetwork` object and the expected subnet. Default: 1 (the previous IP subnet). :return: The adjacent subnet preceding this `IPNetwork` object. rcrzrDr1rrRrrip_copys rpreviouszIPNetwork.previous"8..DL$.+I!I4>#':> |#q((&*i!m##'+i#(*=> > J * *rcX|j|j}|d|jS)z&:return: this IPNetwork in CIDR formatrv)rrrr1)rr|s rrzIPNetwork.__str__s,|&&t{33$$//rc&|jjd|dSrrrs rrzIPNetwork.__repr__rrrrrr)NN)&rjrkrlrmrnrrrr?ror1rrDrGr r r5setterrCrKrFr]rrr#r,r.r r rjrmrrryrr{rrrrs@rr8r8s##J IJeJJJJJJJXBBBQQQ*   $$ QI <<X<PPXPUUXUIIXI&&X&88X8  ^ + +^ +99X999X9 AAXA  X **(((>;;; EEE0:        0''''R   (+++"000 <<<<<<NRWR^>^^%)) K&%,*==> (EJ,==%++ ["]053CC $|z9jH '1 ?;a? {)[8ZTY=MQZ=ZZ4''rc*t|jS)z?The integer value of first IP address in this `IPRange` object.)rrWrs rr z IPRange.firsts4;rc*t|jS)z>The integer value of last IP address in this `IPRange` object.)rrXrs rr z IPRange.lasts49~~rc4|jj|j|jfS)zP :return: A key tuple used to uniquely identify this `IPRange`. r]rs rr,z IPRange.keyr^rc|jj|jz }|jj|jj|fS)zY :return: A key tuple used to compare and sort this `IPRange` correctly. )rrr bit_lengthrRrWr)rskeys rr.zIPRange.sort_keys8|!DI$8$8$:$::|#T[%7==rc6t|j|jS)zx The list of CIDR addresses found within the lower and upper bound addresses of this `IPRange`. )iprange_to_cidrsrWrXrs rcidrsz IPRange.cidrss   TY777rc$|jd|jS)z<:return: this `IPRange` in a common representational format.-rrs rrzIPRange.__str__ s+++tyy11rc@|jjd|jd|jdS)rrz', 'r)rzrjrWrXrs rrzIPRange.__repr__s&#'>#:#:#:DKKKSSrNr)rjrkrlrmrnrrrr#ror r r,r.rrrrprrrVrVs#INNNN*HHH,,,(((*  X X;;; >>>888222TTTTTrrVc'@Kt|D] }|D]}|V dS)z :param args: A list of IP addresses and subnets passed in as arguments. :return: A generator that flattens out IP subnets, yielding unique individual IP addresses (no duplicates). N) cidr_merge)argsr]rs riter_unique_ipsrsH4    BHHHH rcd}t|tr d|vs|dkr|S t|}|d||S#t$rd|vr^|dd\}} dt|cxkrdksntd |d n#t$r|cYcYSwxYw|}d }|d }t |d kr|cYSt d t |z D]}|d|' ||d}n#t$r|cYcYSwxYwd |d|cYSttf$r|cYSwxYw)a A function that converts abbreviated IPv4 CIDRs to their more verbose equivalent. :param abbrev_cidr: an abbreviated CIDR. Uses the old-style classful IP address rules to decide on a default subnet prefix if one is not explicitly provided. Only supports IPv4 addresses. Examples :: 10 - 10.0.0.0/8 10/16 - 10.0.0.0/16 128 - 128.0.0.0/16 128/8 - 128.0.0.0/8 192.168 - 192.168.0.0/16 :return: A verbose CIDR from an abbreviated CIDR or old-style classful network address. The original value if it was not recognised as a supported abbreviation. ct|}d|cxkrdksntd|zd|cxkrdkrnndSd|cxkrdkrnndSd |cxkrd krnnd Sd |cxkrd krnndSdS)NrzInvalid octet: %r!rrPr`)rr)octets rclassful_prefixz/cidr_abbrev_to_verbose..classful_prefix:sE E    S    1E9:: :          1 E S 2 E S 2 E S 1rr:z.0.0.0/rvrrr`zprefixlen in address z out of range for IPv4!N.rP0) rryrrxr,r+rangerpjoinrr) abbrev_cidrrrx part_addrprefixtokenss rcidr_abbrev_to_verbosers.6   +s## +  !2!2 %    !??1#5#5#566 444 +   + 1 1#q 9 9 Iv #CKK----2----$*OZ{{\. # # #"""""" #$IF%% v;;??   q3v;;''  A MM#     > #(33 # # #"""""" #((6****FF3333 z "seA(E3./BE3 B/*E3.B//1E3"9E3D.-E3. D?:E3>D??E3E32E3c0t|dstdg}|D]X}t|ttfr|}nt|}||j|j|j|fY| t|dz }|dkr||d||dz dkrs||ddz ||dz dkrO||d||dt||dz d||df||dz <||=|dz}|dkg}|D]}t|dkr[|d}t|tr(| | Z||p|d}t|d|} t|d|} | t| | |S) a A function that accepts an iterable sequence of IP addresses and subnets merging them into the smallest possible list of CIDRs. It merges adjacent subnets where possible, those contained within others and also removes any duplicates. :param ip_addrs: an iterable sequence of IP addresses, subnets or ranges. :return: a summarized list of `IPNetwork` objects. rz#A sequence or iterator is expected!rrr(rPrR)rrxrr8rVrprRr r sortr+minextendrrrr) ip_addrsrangesrrrxmerged range_tupleoriginalrR range_start range_stops rrrts% 8Z ( (@>??? F?? b9g. / / CCB--C s{CHci=>>>> KKMMM F aA a%% !9Q<6!a%=+ + +q ! q0@F1q5MRSDT0T0T#AYq\6!9Q<VAE]1=MvVWyYZ|9\9\]F1q5Mq  Q a%% F E E {  q "1~H(G,, ( hnn..//// h''''!!nG#KNGDDDK";q>7CCCJ MM*; CC D D D D Mrc4t||\}}}||zS)a Removes an exclude IP address or subnet from target IP subnet. :param target: the target IP address or subnet to be divided up. :param exclude: the IP address or subnet to be removed from target. :return: list of `IPNetwork` objects remaining after exclusion. )cidr_partition)targetexcludeleft_rights r cidr_excluders#$FG44ND!U %<rctt|}t|}|j|jkr gg|jgfS|j|jkr |jgggfS|j|jkrg|ggfSg}g}|jdz}|jj}|j}|j}|}|d||z zz} |j|kr|j| kr)|t||f|| } n(|t| |f||} |dz }||krn| }| d||z zz} |j|k||g|dddfS)ac Partitions a target IP subnet on an exclude IP address. :param target: the target IP address or subnet to be divided up. :param exclude: the IP address or subnet to partition on :return: list of `IPNetwork` objects before, the partition and after, sorted. Adding the three lists returns the equivalent of the original subnet. rr(rRNr) r8r r r]r1rrrRrp) rrrr new_prefixlentarget_module_width target_firstrRi_loweri_uppermatcheds rrrsv  F  G|fl""2 }$$ w} $ $ }b"$$ 7,,,F8R D E$q(M ..z*smallest_matching_cidr..:::D $:::r)rrrrsortedrDrrmatchr]s rsmallest_matching_cidrrrs E 5* % %Si%%%QRRR 2B::E:::;; ::EE T\%>%> Lrcd}t|dstd|dt|}td|DD] }||vr|}n |S)ab Matches an IP address or subnet against a given sequence of IP addresses and subnets. :param ip: a single IP address or subnet. :param cidrs: a sequence of IP addresses and/or subnets. :return: the largest (least specific) matching IPAddress or IPNetwork object from the provided sequence, None if there was no match. Nrrrc,g|]}t|Srprrs rrz)largest_matching_cidr..rr)rrrrrrs rlargest_matching_cidrrs E 5* % %Si%%%QRRR 2B::E:::;; ::E E  Lrcg}t|dstd|dt|}td|DD]/}||vr|||r|j|dvrn0|S)aM Matches an IP address or subnet against a given sequence of IP addresses and subnets. :param ip: a single IP address. :param cidrs: a sequence of IP addresses and/or subnets. :return: all matching IPAddress and/or IPNetwork objects from the provided sequence, an empty list if there was no match. rrrc,g|]}t|Srprrs rrz&all_matching_cidrs..rrr)rrrrrrprD)rrmatchesr]s rall_matching_cidrsrsG 5* % %Si%%%QRRR 2B::E:::;; :: NN4  4rs @?:9999999I$I$I$I$I$VI$I$I$X^G^G^G^G^G^G^G^GBhhhhh&hhhV5e55555p~<~<~<~<~< ~<~<~ -(( Il Io I ),--=)) I& ' ' Ik In Im I   I I GK*++ GK*++ I  ***?***& )$$ Ij)))K((:&&Ik If Ij Ij Ij Ij Ij Ij Ij Ij Ij Ij Ij Ij Ij Ij! &  * * * * *&&&r