"""Take an IP string/int and return an object of the correct type.

try:

return IPv4Address(address)

except (AddressValueError, NetmaskValueError):

pass

try:

return IPv6Address(address)

except (AddressValueError, NetmaskValueError):

pass

raise ValueError('%r does not appear to be an IPv4 or IPv6 address' %

"""Take an IP string/int and return an object of the correct type.

try:

return IPv4Network(address, strict)

except (AddressValueError, NetmaskValueError):

pass

try:

return IPv6Network(address, strict)

except (AddressValueError, NetmaskValueError):

pass

raise ValueError('%r does not appear to be an IPv4 or IPv6 network' %

"""Take an IP string/int and return an object of the correct type.

try:

return IPv4Interface(address)

except (AddressValueError, NetmaskValueError):

pass

try:

return IPv6Interface(address)

except (AddressValueError, NetmaskValueError):

pass

raise ValueError('%r does not appear to be an IPv4 or IPv6 interface' %

"""Represent an address as 4 packed bytes in network (big-endian) order.

try:

return address.to_bytes(4, 'big')

except:

"""Represent an address as 16 packed bytes in network (big-endian) order.

try:

return address.to_bytes(16, 'big')

except:

"""Helper to split the netmask and raise AddressValueError if needed"""

addr = str(address).split('/')

if len(addr) > 2:

raise AddressValueError("Only one '/' permitted in %r" % address)

"""Find a sequence of IPv#Address.

first = last = addresses[0]

for ip in addresses[1:]:

if ip._ip == last._ip + 1:

last = ip

else:

break

"""Count the number of zero bits on the right hand side.

if number == 0:

return bits

for i in range(bits):

if (number >> i) & 1:

return i

# All bits of interest were zero, even if there are more in the number

"""Summarize a network range given the first and last IP addresses.

if (not (isinstance(first, _BaseAddress) and

isinstance(last, _BaseAddress))):

raise TypeError('first and last must be IP addresses, not networks')

if first.version != last.version:

raise TypeError("%s and %s are not of the same version" % (

first, last))

if first > last:

raise ValueError('last IP address must be greater than first')

if first.version == 4:

ip = IPv4Network

elif first.version == 6:

ip = IPv6Network

else:

raise ValueError('unknown IP version')

ip_bits = first._max_prefixlen

first_int = first._ip

last_int = last._ip

while first_int <= last_int:

nbits = min(_count_righthand_zero_bits(first_int, ip_bits),

(last_int - first_int + 1).bit_length() - 1)

net = ip('%s/%d' % (first, ip_bits - nbits))

yield net

first_int += 1 << nbits

if first_int - 1 == ip._ALL_ONES:

break

"""Loops through the addresses, collapsing concurrent netblocks.

while True:

last_addr = None

ret_array = []

optimized = False

for cur_addr in addresses:

if not ret_array:

last_addr = cur_addr

ret_array.append(cur_addr)

elif (cur_addr.network_address >= last_addr.network_address and

cur_addr.broadcast_address <= last_addr.broadcast_address):

optimized = True

elif cur_addr == list(last_addr.supernet().subnets())[1]:

ret_array[-1] = last_addr = last_addr.supernet()

optimized = True

else:

last_addr = cur_addr

ret_array.append(cur_addr)

addresses = ret_array

if not optimized:

"""Collapse a list of IP objects.

i = 0

addrs = []

ips = []

nets = []

# split IP addresses and networks

for ip in addresses:

if isinstance(ip, _BaseAddress):

if ips and ips[-1]._version != ip._version:

raise TypeError("%s and %s are not of the same version" % (

ip, ips[-1]))

ips.append(ip)

elif ip._prefixlen == ip._max_prefixlen:

if ips and ips[-1]._version != ip._version:

raise TypeError("%s and %s are not of the same version" % (

ip, ips[-1]))

try:

ips.append(ip.ip)

except AttributeError:

ips.append(ip.network_address)

else:

if nets and nets[-1]._version != ip._version:

raise TypeError("%s and %s are not of the same version" % (

ip, nets[-1]))

nets.append(ip)

# sort and dedup

ips = sorted(set(ips))

nets = sorted(set(nets))

while i < len(ips):

(first, last) = _find_address_range(ips[i:])

i = ips.index(last) + 1

addrs.extend(summarize_address_range(first, last))

return iter(_collapse_addresses_recursive(sorted(

"""Return a key suitable for sorting between networks and addresses.

if isinstance(obj, _BaseNetwork):

return obj._get_networks_key()

elif isinstance(obj, _BaseAddress):

return obj._get_address_key()

# Helper that derives the other comparison operations from

# __lt__ and __eq__

# We avoid functools.total_ordering because it doesn't handle

# NotImplemented correctly yet (http://bugs.python.org/issue10042)

def __eq__(self, other):

raise NotImplementedError

def __ne__(self, other):

equal = self.__eq__(other)

if equal is NotImplemented:

return NotImplemented

return not equal

def __lt__(self, other):

raise NotImplementedError

def __le__(self, other):

less = self.__lt__(other)

if less is NotImplemented or not less:

return self.__eq__(other)

return less

def __gt__(self, other):

less = self.__lt__(other)

if less is NotImplemented:

return NotImplemented

equal = self.__eq__(other)

if equal is NotImplemented:

return NotImplemented

return not (less or equal)

def __ge__(self, other):

less = self.__lt__(other)

if less is NotImplemented:

return NotImplemented

"""The mother class."""

@property

def exploded(self):

"""Return the longhand version of the IP address as a string."""

return self._explode_shorthand_ip_string()

@property

def compressed(self):

"""Return the shorthand version of the IP address as a string."""

return str(self)

@property

def version(self):

msg = '%200s has no version specified' % (type(self),)

raise NotImplementedError(msg)

def _check_int_address(self, address):

if address < 0:

msg = "%d (< 0) is not permitted as an IPv%d address"

raise AddressValueError(msg % (address, self._version))

if address > self._ALL_ONES:

msg = "%d (>= 2**%d) is not permitted as an IPv%d address"

raise AddressValueError(msg % (address, self._max_prefixlen,

self._version))

def _check_packed_address(self, address, expected_len):

address_len = len(address)

if address_len != expected_len:

msg = "%r (len %d != %d) is not permitted as an IPv%d address"

raise AddressValueError(msg % (address, address_len,

expected_len, self._version))

def _ip_int_from_prefix(self, prefixlen):

"""Turn the prefix length into a bitwise netmask

return self._ALL_ONES ^ (self._ALL_ONES >> prefixlen)

def _prefix_from_ip_int(self, ip_int):

"""Return prefix length from the bitwise netmask.

trailing_zeroes = _count_righthand_zero_bits(ip_int,

self._max_prefixlen)

prefixlen = self._max_prefixlen - trailing_zeroes

leading_ones = ip_int >> trailing_zeroes

all_ones = (1 << prefixlen) - 1

if leading_ones != all_ones:

byteslen = self._max_prefixlen // 8

details = ip_int.to_bytes(byteslen, 'big')

msg = 'Netmask pattern %r mixes zeroes & ones'

raise ValueError(msg % details)

return prefixlen

def _report_invalid_netmask(self, netmask_str):

msg = '%r is not a valid netmask' % netmask_str

raise NetmaskValueError(msg) from None

def _prefix_from_prefix_string(self, prefixlen_str):

"""Return prefix length from a numeric string

# int allows a leading +/- as well as surrounding whitespace,

# so we ensure that isn't the case

if not _BaseV4._DECIMAL_DIGITS.issuperset(prefixlen_str):

self._report_invalid_netmask(prefixlen_str)

try:

prefixlen = int(prefixlen_str)

except ValueError:

self._report_invalid_netmask(prefixlen_str)

if not (0 <= prefixlen <= self._max_prefixlen):

self._report_invalid_netmask(prefixlen_str)

return prefixlen

def _prefix_from_ip_string(self, ip_str):

"""Turn a netmask/hostmask string into a prefix length

# Parse the netmask/hostmask like an IP address.

try:

ip_int = self._ip_int_from_string(ip_str)

except AddressValueError:

self._report_invalid_netmask(ip_str)

# Try matching a netmask (this would be /1*0*/ as a bitwise regexp).

# Note that the two ambiguous cases (all-ones and all-zeroes) are

# treated as netmasks.

try:

return self._prefix_from_ip_int(ip_int)

except ValueError:

pass

# Invert the bits, and try matching a /0+1+/ hostmask instead.

ip_int ^= self._ALL_ONES

try:

return self._prefix_from_ip_int(ip_int)

except ValueError:

"""A generic IP object.

def __init__(self, address):

if (not isinstance(address, bytes)

and '/' in str(address)):

raise AddressValueError("Unexpected '/' in %r" % address)

def __int__(self):

return self._ip

def __eq__(self, other):

try:

return (self._ip == other._ip

and self._version == other._version)

except AttributeError:

return NotImplemented

def __lt__(self, other):

if self._version != other._version:

raise TypeError('%s and %s are not of the same version' % (

self, other))

if not isinstance(other, _BaseAddress):

raise TypeError('%s and %s are not of the same type' % (

self, other))

if self._ip != other._ip:

return self._ip < other._ip

return False

# Shorthand for Integer addition and subtraction. This is not

# meant to ever support addition/subtraction of addresses.

def __add__(self, other):

if not isinstance(other, int):

return NotImplemented

return self.__class__(int(self) + other)

def __sub__(self, other):

if not isinstance(other, int):

return NotImplemented

return self.__class__(int(self) - other)

def __repr__(self):

return '%s(%r)' % (self.__class__.__name__, str(self))

def __str__(self):

return str(self._string_from_ip_int(self._ip))

def __hash__(self):

return hash(hex(int(self._ip)))

def _get_address_key(self):

"""A generic IP network object.

def __init__(self, address):

self._cache = {}

def __repr__(self):

return '%s(%r)' % (self.__class__.__name__, str(self))

def __str__(self):

return '%s/%d' % (self.network_address, self.prefixlen)

def hosts(self):

"""Generate Iterator over usable hosts in a network.

network = int(self.network_address)

broadcast = int(self.broadcast_address)

for x in range(network + 1, broadcast):

yield self._address_class(x)

def __iter__(self):

network = int(self.network_address)

broadcast = int(self.broadcast_address)

for x in range(network, broadcast + 1):

yield self._address_class(x)

def __getitem__(self, n):

network = int(self.network_address)

broadcast = int(self.broadcast_address)

if n >= 0:

if network + n > broadcast:

raise IndexError

return self._address_class(network + n)

else:

n += 1

if broadcast + n < network:

raise IndexError

return self._address_class(broadcast + n)

def __lt__(self, other):

if self._version != other._version:

raise TypeError('%s and %s are not of the same version' % (

self, other))

if not isinstance(other, _BaseNetwork):

raise TypeError('%s and %s are not of the same type' % (

self, other))

if self.network_address != other.network_address:

return self.network_address < other.network_address

if self.netmask != other.netmask:

return self.netmask < other.netmask

return False

def __eq__(self, other):

try:

return (self._version == other._version and

self.network_address == other.network_address and

int(self.netmask) == int(other.netmask))

except AttributeError:

return NotImplemented

def __hash__(self):

return hash(int(self.network_address) ^ int(self.netmask))

def __contains__(self, other):

# always false if one is v4 and the other is v6.

if self._version != other._version:

return False

# dealing with another network.

if isinstance(other, _BaseNetwork):

return False

# dealing with another address

else:

# address

return (int(self.network_address) <= int(other._ip) <=

int(self.broadcast_address))

def overlaps(self, other):

"""Tell if self is partly contained in other."""

return self.network_address in other or (

self.broadcast_address in other or (

other.network_address in self or (

other.broadcast_address in self)))

@property

def broadcast_address(self):

x = self._cache.get('broadcast_address')

if x is None:

x = self._address_class(int(self.network_address) |

int(self.hostmask))

self._cache['broadcast_address'] = x

return x

@property

def hostmask(self):

x = self._cache.get('hostmask')

if x is None:

x = self._address_class(int(self.netmask) ^ self._ALL_ONES)

self._cache['hostmask'] = x

return x

@property

def with_prefixlen(self):

return '%s/%d' % (self.network_address, self._prefixlen)

@property

def with_netmask(self):

return '%s/%s' % (self.network_address, self.netmask)

@property

def with_hostmask(self):

return '%s/%s' % (self.network_address, self.hostmask)

@property

def num_addresses(self):

"""Number of hosts in the current subnet."""

return int(self.broadcast_address) - int(self.network_address) + 1

@property

def _address_class(self):

# Returning bare address objects (rather than interfaces) allows for

# more consistent behaviour across the network address, broadcast

# address and individual host addresses.

msg = '%200s has no associated address class' % (type(self),)

raise NotImplementedError(msg)

@property

def prefixlen(self):

return self._prefixlen

def address_exclude(self, other):

"""Remove an address from a larger block.

if not self._version == other._version:

raise TypeError("%s and %s are not of the same version" % (

self, other))

if not isinstance(other, _BaseNetwork):

raise TypeError("%s is not a network object" % other)

if not (other.network_address >= self.network_address and

other.broadcast_address <= self.broadcast_address):

raise ValueError('%s not contained in %s' % (other, self))

if other == self:

raise StopIteration

# Make sure we're comparing the network of other.

other = other.__class__('%s/%s' % (other.network_address,

other.prefixlen))

s1, s2 = self.subnets()

while s1 != other and s2 != other:

if (other.network_address >= s1.network_address and

other.broadcast_address <= s1.broadcast_address):

yield s2

s1, s2 = s1.subnets()

elif (other.network_address >= s2.network_address and

other.broadcast_address <= s2.broadcast_address):

yield s1

s1, s2 = s2.subnets()

else:

# If we got here, there's a bug somewhere.

raise AssertionError('Error performing exclusion: '

's1: %s s2: %s other: %s' %

(s1, s2, other))

if s1 == other:

yield s2

elif s2 == other:

yield s1

else:

# If we got here, there's a bug somewhere.

raise AssertionError('Error performing exclusion: '

's1: %s s2: %s other: %s' %

(s1, s2, other))

def compare_networks(self, other):

"""Compare two IP objects.

# does this need to raise a ValueError?

if self._version != other._version:

raise TypeError('%s and %s are not of the same type' % (

self, other))

# self._version == other._version below here:

if self.network_address < other.network_address:

return -1

if self.network_address > other.network_address:

return 1

# self.network_address == other.network_address below here:

if self.netmask < other.netmask:

return -1

if self.netmask > other.netmask:

return 1

return 0

def _get_networks_key(self):

"""Network-only key function.

return (self._version, self.network_address, self.netmask)

def subnets(self, prefixlen_diff=1, new_prefix=None):

"""The subnets which join to make the current subnet.

if self._prefixlen == self._max_prefixlen:

yield self

return

if new_prefix is not None:

if new_prefix < self._prefixlen:

raise ValueError('new prefix must be longer')

if prefixlen_diff != 1:

raise ValueError('cannot set prefixlen_diff and new_prefix')

prefixlen_diff = new_prefix - self._prefixlen

if prefixlen_diff < 0:

raise ValueError('prefix length diff must be > 0')

new_prefixlen = self._prefixlen + prefixlen_diff

if new_prefixlen > self._max_prefixlen:

raise ValueError(

'prefix length diff %d is invalid for netblock %s' % (

new_prefixlen, self))

first = self.__class__('%s/%s' %

(self.network_address,

self._prefixlen + prefixlen_diff))

yield first

current = first

while True:

broadcast = current.broadcast_address

if broadcast == self.broadcast_address:

return

new_addr = self._address_class(int(broadcast) + 1)

current = self.__class__('%s/%s' % (new_addr,

new_prefixlen))

yield current

def supernet(self, prefixlen_diff=1, new_prefix=None):

"""The supernet containing the current network.

if self._prefixlen == 0:

return self

if new_prefix is not None:

if new_prefix > self._prefixlen:

raise ValueError('new prefix must be shorter')

if prefixlen_diff != 1:

raise ValueError('cannot set prefixlen_diff and new_prefix')

prefixlen_diff = self._prefixlen - new_prefix

if self.prefixlen - prefixlen_diff < 0:

raise ValueError(

'current prefixlen is %d, cannot have a prefixlen_diff of %d' %

(self.prefixlen, prefixlen_diff))

# TODO (pmoody): optimize this.

t = self.__class__('%s/%d' % (self.network_address,

self.prefixlen - prefixlen_diff),

strict=False)

return t.__class__('%s/%d' % (t.network_address, t.prefixlen))

@property

def is_multicast(self):

"""Test if the address is reserved for multicast use.