ó
®‹EYc@sˆdZd
dl
Zd
dlmZmZmZmZmZm	Z	
d
dl
mZmZm
Z

d„Zd„Zdef
d„ƒYZdS(	s2Set based operations for IP addresses and subnets.iÿÿÿÿN(t	IPNetworkt	IPAddresstIPRanget
cidr_mergetcidr_excludetiprange_to_cidrs(t_sys_maxintt
_dict_keyst	_int_typec
Cs
|jj
}|
|}|j|jkrK|j||j|jd
fƒ

n|d
7}|}x}|t|
ƒ
krÚ|
|}||krŠPn|jd
|jkr£n$|j||jd
|jd
fƒ

|d
7}|}q^W|jd
}|j}	||	k
r
|j|||	fƒ

n|S(s®
Calculate IPSet([supernet]) - IPSet(subnets).

    Assumptions: subnets is sorted, subnet_idx points to the first
    element in subnets that is a subnet of supernet.

    Results are appended to the ranges parameter as tuples of in format
    (version, first, last). Return value is the first subnet_idx that
    does not point to a subnet of supernet (or len(subnets) if all
    subsequents items are a subnet of supernet).
    i
(t_moduletversiontfirsttappendtlentlast(
tsupernettsubnetst
subnet_idxtrangesR
tsubnettprev_subnett
cur_subnetRR((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt	_subtracts(



#






$




	

c
cs³|s
d
S|d\}
}}xr|dD]f\}}}||dkr_||
kr_|}q(nt||
ƒt||
ƒfV
|}|}|}
q(Wt||
ƒt||
ƒfV
d
S(sq
Iterate over sorted_ranges, merging where possible

    Sorted ranges must be a sorted iterable of (version, first, last) tuples.
    Merging occurs for pairs like [(4, 10, 42), (4, 43, 100)] which is merged
    into (4, 10, 100), and leads to return value
    ( IPAddress(10, 4), IPAddress(100, 4) ), which is suitable input for the
    iprange_to_cidrs function.
    Nii
(
R
(t
sorted_rangestcurrent_versiont
current_starttcurrent_stoptnext_versiont
next_startt	next_stop((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt_iter_merged_ranges8s	









tIPSetcBs‚
eZ
dZd$Zd%dd„Zd„Zd„Zd„Zd„Z	d„Z
d	„Zd
„ZeZ
d„Zd„Zdd
„
Zdd„
Zd„Zd„Zd„Zdd„
Zd„Zd„Zd„Zd„Zd„ZeZd„Zd„ZeZd„ZeZ d„Z!e!Z"d„Z#e#Z$d„Z%e%Z&d„Z'e(d„ƒ
Z)d „Z*e*Z+d!„Z,d"„Z-d#„Z.RS(&s[
    Represents an unordered collection (set) of unique IP addresses and
    subnets.

    t_cidrsicCs
t|
t
ƒr%i
t|
j6|_nét|
tƒr]tjt|
d
|
dƒtƒ|_n±t|
t	ƒrŠtj|
j
ƒtƒ|_n„i|_|
dk	r
g}x?|
D]7}t|tƒrÖt
|d|ƒ

}n|j|ƒ

q¬Wx$t|ƒ
D]}t|j|<qôWndS(sE

        Constructor.

        :param iterable: (optional) an iterable containing IP addresses and
            subnets.

        :param flags: decides which rules are applied to the interpretation
            of the addr value. See the netaddr.core namespace documentation
            for supported constant values.

        iiÿÿÿÿtflagsN(t
isinstanceRtTruetcidrR RtdicttfromkeysRRt
iter_cidrstNoneRR
RR(tselftiterableR!t	mergeabletaddrR$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__init__]s 



#

	







c
Cs&tg|j
D]}
|
jƒ^q
ƒ
S(
s.:return: Pickled state of an ``IPSet`` object.(ttupleR t__getstate__(R)R$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyR/|scCs#tj
d
„|
Dƒ
tƒ|_dS(sR
        :param state: data used to unpickle a pickled ``IPSet`` object.

        c
ss0|]&\}
}}t|
|fd|ƒ

V
qd
S(R
N(
R(t.0tvaluet	prefixlenR
((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pys	<genexpr>†s
N(R%R&R#R (R)tstate((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__setstate__€s


cCsí
|
j}|
j
}|
j}|
j|
jjkrgxú|
jƒD]#}||jkr=|j|
=d
Sq=WnÆg}x¢|jD]—}|jj|ksw||
kr¡qwn|j}|j
}	||krÛ|	|k
rÛ|j|ƒ

qw||k
rw|	|krw|j|
=|s

t	‚
d
SqwWx|D]}
|j|
=q
W|
jj|
j
}x¦|
j
dkrè
|
j|?d@}|rx
|
jƒ}
n|
j
ƒ}
|
|jkr—
d
S|j|
=|j|
=|
j
d8_
|d7}|
j|?|>|
_t|j|
<qC
Wd
S(s

        Same as compact(), but assume that added_network is the only change and
        that this IPSet was properly compacted before added_network was added.
        This allows to perform compaction much faster. added_network must
        already be present in self._cidrs.
        Nii
(RRR
t
_prefixlenR	twidthRR RtAssertionErrorR2t_valuetprevioustnextR#(R)t
added_networktadded_firstt
added_lastt
added_versiontpotential_supernett	to_removeR$RRtitemtshift_widthtthe_bitt	candidate((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt_compact_single_networkŠsH	
	
	






	
	

















c
Cs(t|j
ƒ
}
tj|
tƒ|_
d
S(sR
        Compact internal list of `IPNetwork` objects using a CIDR merge.
        N(RR R%R&R#(R)tcidrs((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytcompactÔs
c

Cstd
ƒ
‚
dS(sÁ
        Raises ``TypeError`` if this method is called.

        .. note:: IPSet objects are not hashable and cannot be used as             dictionary keys or as members of other sets.         sIP sets are unhashable!N(
t	TypeError(
R)((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__hash__ÛscCsUt|
ƒ
}||j
krtSx/|jrP|jd
8_||j
kr"tSq"WtS(s„
        :param ip: An IP address or subnet.

        :return: ``True`` if IP address or subnet is a member of this IP set.
        i
(RR R#R5tFalse(R)tipR((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__contains__äs







c

Cs
t|j
ƒ
S(
s9Return True if IPSet contains at least one IP, else False(tboolR (
R)((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__nonzero__÷sc

Cstj
t|jƒ
ŒS(
sP
        :return: an iterator over the IP addresses within this IP set.
        (t
_itertoolstchaintsortedR (
R)((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__iter__ýsc

Cs
t|j
ƒ
S(
sU
        :return: an iterator over individual IP subnets within this IP set.
        (RQR (
R)((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyR'
scCs¿t|
t
ƒrPtjt|
d
|
dƒtƒ}|jj|ƒ

|jƒ
dSt|
t	ƒrk|
j
}
n6t|
tƒr•t	t|
d|ƒ

ƒ
}
nt	|
ƒ
}
t|j|
<|j
|
ƒ

dS(s<
        Adds an IP address or subnet or IPRange to this IP set. Has no effect if
        it is already present.

        Note that where possible the IP address or subnet is merged with other
        members of the set to form more concise CIDR blocks.

        :param addr: An IP address or subnet in either string or object form, or
            an IPRange object.

        :param flags: decides which rules are applied to the interpretation
            of the addr value. See the netaddr.core namespace documentation
            for supported constant values.

        iiÿÿÿÿNR!(R"RR%R&RR#R tupdateRGRR$RR
RE(R)R,R!t	new_cidrs((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytadd	
s










cCs
t|
t
ƒrHt|
d
|
dƒ}x|D]}|j|ƒ

q-WdSt|
tƒrlt|
d|ƒ

}
nt|
ƒ
}
|j|
ƒ

d}d}x6|j	D]+}|
|kr›t
||
ƒ}|}Pq›q›W|dk	r

|j	|=x|D]}t|j	|<qçWndS(s

        Removes an IP address or subnet or IPRange from this IP set. Does
        nothing if it is not already a member.

        Note that this method behaves more like discard() found in regular
        Python sets because it doesn't raise KeyError exceptions if the
        IP address or subnet is question does not exist. It doesn't make sense
        to fully emulate that behaviour here as IP sets contain groups of
        individual IP addresses as individual set members using IPNetwork
        objects.

        :param addr: An IP address or subnet, or an IPRange.

        :param flags: decides which rules are applied to the interpretation
            of the addr value. See the netaddr.core namespace documentation
            for supported constant values.

        iiÿÿÿÿNR!(R"RRtremoveRR
RRUR(R RR#(R)R,R!RFR$t	remaindert
matching_cidr((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyRV*
s(
















c

Cs|jj
ƒd
S(sŒ
        Removes and returns an arbitrary IP address or subnet from this IP
        set.

        :return: An IP address or subnet.
        i(R tpopitem(
R)((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytpopb
scCs|j|
ƒ
}|S(
sÑ
        :param other: an IP set.

        :return: ``True`` if this IP set has no elements (IP addresses
            or subnets) in common with other. Intersection *must* be an
            empty set.
        (
tintersection(R)tothertresult((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt
isdisjointk
s
c
Cs#|jƒ}
|
j
j|j
ƒ

|
S(
s':return: a shallow copy of this IP set.(t	__class__R RS(R)tobj_copy((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytcopyv
s

cCs
t|
t
ƒrNtjd
„tt|jƒ
t|
jƒ
ƒ
Dƒ
tƒ|_dSt|
tt	fƒrt|j
|
ƒ

dSt|
dƒs’tdƒ
‚
ng}x?|
D]7}t|t
ƒrÉt|d|ƒ

}n|j|ƒ

qŸWx.tt|jƒ
|ƒ
D]}t|j|<qôW|jƒ
dS(sw

        Update the contents of this IP set with the union of itself and
        other IP set.

        :param iterable: an iterable containing IP addresses and subnets.

        :param flags: decides which rules are applied to the interpretation
            of the addr value. See the netaddr.core namespace documentation
            for supported constant values.

        c
ss|]}
|
V
qdS(
N((R0RK((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pys	<genexpr>Š
sNRRsan iterable was expected!R!(R"RR%R&RRR R#RRRUthasattrRHRR
RRG(R)R*R!R+R,R$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyRS|
s$


 










 
c

Cs
i|_d
S(s5Remove all IP addresses and subnets from this IP set.N(
R (
R)((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytclearŸ
scCs-y|j|
jkSWnt
k
r(


tSXd
S(s›
        :param other: an IP set

        :return: ``True`` if this IP set is equivalent to the ``other`` IP set,
            ``False`` otherwise.
        N(R tAttributeErrortNotImplemented(R)R\((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__eq__£
s



cCs-y|j|
jkSWnt
k
r(


tSXd
S(s›
        :param other: an IP set

        :return: ``False`` if this IP set is equivalent to the ``other`` IP set,
            ``True`` otherwise.
        N(R RdRe(R)R\((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__ne__¯
s



cCs2t|
d
ƒst
S|j|
jko1|j|
ƒ
S(s—
        :param other: an IP set

        :return: ``True`` if this IP set is less than the ``other`` IP set,
            ``False`` otherwise.
        R (RbRetsizetissubset(R)R\((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__lt__»
s
cCs(x!|jD]}||
kr
t
Sq
WtS(
sš
        :param other: an IP set.

        :return: ``True`` if every IP address and subnet in this IP set
            is found within ``other``.
        (R RJR#(R)R\R$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyRiÇ
s


cCs2t|
d
ƒst
S|j|
jko1|j|
ƒ
S(s›
        :param other: an IP set.

        :return: ``True`` if this IP set is greater than the ``other`` IP set,
            ``False`` otherwise.
        R (RbReRht
issuperset(R)R\((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__gt__Õ
s
cCs;t|
d
ƒst
Sx!|
jD]}||krtSqWtS(sš
        :param other: an IP set.

        :return: ``True`` if every IP address and subnet in other IP set
            is found within this one.
        R (RbReR RJR#(R)R\R$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyRká
s



cCs|jƒ}|j
|
ƒ

|S(
s±
        :param other: an IP set.

        :return: the union of this IP set and another as a new IP set
            (combines IP addresses and subnets from both sets).
        (RaRS(R)R\tip_set((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytunionò
s


cCs'
i}t|j
ƒ
}t|
j
ƒ
}d
}d
}t|ƒ
}t|ƒ
}xÆ||kr
||kr
||}	||}
|	|
kr¤t||	<|d7}|d7}qK|	|
krÇt||	<|d7}qK|
|	krêt||
<|d7}qK|	|
kr
|d7}qK|d7}qKWtƒ}||_
|S(sµ
        :param other: an IP set.

        :return: the intersection of this IP set and another as a new IP set.
            (IP addresses and subnets common to both sets).
        ii
(RQR R
R#R(R)R\tresult_cidrstown_netst
other_netstown_idxt	other_idxtown_lent	other_lentown_curt	other_curR]((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyR[ÿ
s4



























	
	
cCsJg}t|j
ƒ
}t|
j
ƒ
}d
}d
}t|ƒ
}t|ƒ
}x
||kr`
||kr`
||}	||}
|	|
krš|d7}|d7}qK|	|
krÈt|
|||ƒ}|d7}qK|
|	kröt|	|||ƒ}|d7}qK|	|
kr1
|j|	jj|	j|	jfƒ

|d7}qK|j|
jj|
j|
jfƒ

|d7}qKWxF||kr©
||}	|j|	jj|	j|	jfƒ

|d7}qd
WxF||krò
||}
|j|
jj|
j|
jfƒ

|d7}q­
Wt	ƒ}xGt
|ƒ
D]9\}}
t||
ƒ}x|D]}t|j
|<q+Wq	W|S(sÜ
        :param other: an IP set.

        :return: the symmetric difference of this IP set and another as a new
            IP set (all IP addresses and subnets that are in exactly one
            of the sets).
        ii
(
RQR R
RRR	R
RRRRRR#(R)R\t
result_rangesRpRqRrRsRtRuRvRwR]tstarttstopRFR$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytsymmetric_difference+sT





































	





cCsš
g}i}t|j
ƒ
}t|
j
ƒ
}d
}d
}t|ƒ
}t|ƒ
}	xÇ||kr
||	kr
||}
||}|
|kr |d7}|d7}qQ|
|kr¹|d7}qQ||
krçt|
|||ƒ}|d7}qQ|
|kr

t||
<|d7}qQ|d7}qQWx(||krB
t|||<|d7}q
Wx>t|ƒ
D]0\}}
x!t||
ƒD]}t||<ql
WqP
Wtƒ}||_
|S(sæ
        :param other: an IP set.

        :return: the difference between this IP set and another as a new IP
            set (all IP addresses and subnets that are in this IP set but
            not found in the other.)
        ii
(RQR R
RR#RRR(R)R\RxRoRpRqRrRsRtRuRvRwRyRzR$R]((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt
differenceosB




















	









	
	
c
Cs,|j}
|
t
kr(td
t
ƒ
‚
n|
S(sæ
        :return: the cardinality of this IP set (i.e. sum of individual IP             addresses). Raises ``IndexError`` if size > maxint (a Python             limitation). Use the .size property for subnets of any size.
        sUrange contains more than %d (sys.maxint) IP addresses!Use the .size property instead.(RhRt
IndexError(R)Rh((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__len__¥s	





c
Cs#tg|j
D]}
|
j^q
ƒ
S(
s˜
        The cardinality of this IP set (based on the number of individual IP
        addresses including those implicitly defined in subnets).
        (tsumR Rh(R)R$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyRh²sc
Cs*d
gt|j
ƒ
D]}
t|
ƒ
^qS(s8:return: Python statement to create an equivalent objects	IPSet(%r)(RQR tstr(R)t
c((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt__repr__ºsc
Csf|jƒ}
t
|
ƒ
d
krb|
dd}x3|
D](}|d|krMtS|dd
}q3WntS(sÆ
        Returns True if the members of the set form a contiguous IP
        address range (with no gaps), False otherwise.

        :return: ``True`` if the ``IPSet`` object is contiguous.
        i
iiÿÿÿÿ(R'R
RJR#(R)RFR9R$((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytiscontiguousÀs







c
CsO|jƒr?|j
ƒ}
|
s"dSt|
d
d
|
ddƒStdƒ
‚
dS(sì
        Generates an IPRange for this IPSet, if all its members
        form a single contiguous sequence.

        Raises ``ValueError`` if the set is not contiguous.

        :return: An ``IPRange`` for all IPs in the IPSet.
        iiÿÿÿÿsIPSet is not contiguousN(RƒR'R(Rt
ValueError(R)RF((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pytiprangeÐs	



c
cscg|jƒD]!}
|
j
j|
j|
jf^q
}x(t|ƒ
D]\}}t||ƒV
qAWd
S(sùGenerate the merged IPRanges for this IPSet.

        In contrast to self.iprange(), this will work even when the IPSet is
        not contiguous. Adjacent IPRanges will be merged together, so you
        get the minimal number of IPRanges.
        N(R'R	R
RRRR(R)R$RRyRz((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt
iter_iprangesás
1
(
s_cidrsN(/t__name__t
__module__t__doc__t	__slots__R(R-R/R4RERGRIRLRNt__bool__RRR'RURVRZR^RaRSRcRfRgRjRit__le__RlRkt__ge__Rnt__or__R[t__and__R{t__xor__R|t__sub__R~tpropertyRhR‚t__str__RƒR…R†(((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyRUsV
		
	J							!8				#									*	B	4	
			(R‰t	itertoolsROt
netaddr.ipRR
RRRRtnetaddr.compatRRRRRtobjectR(((sD/home/tvault/.virtenv/lib/python2.7/site-packages/netaddr/ip/sets.pyt<module>s.	(