# Copyright 2007 Google Inc.

# Licensed to PSF under a Contributor Agreement.

"""A fast, lightweight IPv4/IPv6 manipulation library in Python.

This library is used to create/poke/manipulate IPv4 and IPv6 addresses

and networks.

"""

__version__ = '1.0'

import functools

IPV4LENGTH = 32

IPV6LENGTH = 128

class AddressValueError(ValueError):

"""A Value Error related to the address."""

class NetmaskValueError(ValueError):

"""A Value Error related to the netmask."""

def ip_address(address):

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

Args:

address: A string or integer, the IP address. Either IPv4 or

IPv6 addresses may be supplied; integers less than 2**32 will

be considered to be IPv4 by default.

Returns:

An IPv4Address or IPv6Address object.

Raises:

ValueError: if the *address* passed isn't either a v4 or a v6

address

"""

try:

return IPv4Address(address)

except (AddressValueError, NetmaskValueError):

pass

try:

return IPv6Address(address)

except (AddressValueError, NetmaskValueError):

pass

raise ValueError(f'{address!r} does not appear to be an IPv4 or IPv6 address')

def ip_network(address, strict=True):

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

Args:

address: A string or integer, the IP network. Either IPv4 or

IPv6 networks may be supplied; integers less than 2**32 will

be considered to be IPv4 by default.

Returns:

An IPv4Network or IPv6Network object.

Raises:

ValueError: if the string passed isn't either a v4 or a v6

address. Or if the network has host bits set.

"""

try:

return IPv4Network(address, strict)

except (AddressValueError, NetmaskValueError):

pass

try:

return IPv6Network(address, strict)

except (AddressValueError, NetmaskValueError):

pass

raise ValueError(f'{address!r} does not appear to be an IPv4 or IPv6 network')

def ip_interface(address):

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

Args:

address: A string or integer, the IP address. Either IPv4 or

IPv6 addresses may be supplied; integers less than 2**32 will

be considered to be IPv4 by default.

Returns:

An IPv4Interface or IPv6Interface object.

Raises:

ValueError: if the string passed isn't either a v4 or a v6

address.

Notes:

The IPv?Interface classes describe an Address on a particular

Network, so they're basically a combination of both the Address

and Network classes.

"""

try:

return IPv4Interface(address)

except (AddressValueError, NetmaskValueError):

pass

try:

return IPv6Interface(address)

except (AddressValueError, NetmaskValueError):

pass

raise ValueError(f'{address!r} does not appear to be an IPv4 or IPv6 interface')

def v4_int_to_packed(address):

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

Args:

address: An integer representation of an IPv4 IP address.

Returns:

The integer address packed as 4 bytes in network (big-endian) order.

Raises:

ValueError: If the integer is negative or too large to be an

IPv4 IP address.

"""

try:

return address.to_bytes(4) # big endian

except OverflowError:

raise ValueError("Address negative or too large for IPv4")

def v6_int_to_packed(address):

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

Args:

address: An integer representation of an IPv6 IP address.

Returns:

The integer address packed as 16 bytes in network (big-endian) order.

"""

try:

return address.to_bytes(16) # big endian

except OverflowError:

raise ValueError("Address negative or too large for IPv6")

def _split_optional_netmask(address):

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

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

if len(addr) > 2:

raise AddressValueError(f"Only one '/' permitted in {address!r}")

return addr

def _find_address_range(addresses):

"""Find a sequence of sorted deduplicated IPv#Address.

Args:

addresses: a list of IPv#Address objects.

Yields:

A tuple containing the first and last IP addresses in the sequence.

"""

it = iter(addresses)

first = last = next(it)

for ip in it:

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

yield first, last

first = ip

last = ip

yield first, last

def _count_righthand_zero_bits(number, bits):

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

Args:

number: an integer.

bits: maximum number of bits to count.

Returns:

The number of zero bits on the right hand side of the number.

"""

if number == 0:

return bits

return min(bits, (~number & (number-1)).bit_length())

def summarize_address_range(first, last):

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

Example:

>>> list(summarize_address_range(IPv4Address('192.0.2.0'),

... IPv4Address('192.0.2.130')))

... #doctest: +NORMALIZE_WHITESPACE

[IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'),

IPv4Network('192.0.2.130/32')]

Args:

first: the first IPv4Address or IPv6Address in the range.

last: the last IPv4Address or IPv6Address in the range.

Returns:

An iterator of the summarized IPv(4|6) network objects.

Raise:

TypeError:

If the first and last objects are not IP addresses.

If the first and last objects are not the same version.

ValueError:

If the last object is not greater than the first.

If the version of the first address is not 4 or 6.

"""

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((first_int, ip_bits - nbits))

yield net

first_int += 1 << nbits

if first_int - 1 == ip._ALL_ONES:

break

def _collapse_addresses_internal(addresses):

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

Example:

ip1 = IPv4Network('192.0.2.0/26')

ip2 = IPv4Network('192.0.2.64/26')

ip3 = IPv4Network('192.0.2.128/26')

ip4 = IPv4Network('192.0.2.192/26')

_collapse_addresses_internal([ip1, ip2, ip3, ip4]) ->

[IPv4Network('192.0.2.0/24')]

This shouldn't be called directly; it is called via

collapse_addresses([]).

Args:

addresses: A list of IPv4Network's or IPv6Network's

Returns:

A list of IPv4Network's or IPv6Network's depending on what we were

passed.

"""

# First merge

to_merge = list(addresses)

subnets = {}

while to_merge:

net = to_merge.pop()

supernet = net.supernet()

existing = subnets.get(supernet)

if existing is None:

subnets[supernet] = net

elif existing != net:

# Merge consecutive subnets

del subnets[supernet]

to_merge.append(supernet)

# Then iterate over resulting networks, skipping subsumed subnets

last = None

for net in sorted(subnets.values()):

if last is not None:

# Since they are sorted, last.network_address <= net.network_address

# is a given.

if last.broadcast_address >= net.broadcast_address:

continue

yield net

last = net

def collapse_addresses(addresses):

"""Collapse a list of IP objects.

Example:

collapse_addresses([IPv4Network('192.0.2.0/25'),

IPv4Network('192.0.2.128/25')]) ->

[IPv4Network('192.0.2.0/24')]

Args:

addresses: An iterable of IPv4Network or IPv6Network objects.

Returns:

An iterator of the collapsed IPv(4|6)Network objects.

Raises:

TypeError: If passed a list of mixed version objects.

"""

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))

# find consecutive address ranges in the sorted sequence and summarize them

if ips:

for first, last in _find_address_range(ips):

addrs.extend(summarize_address_range(first, last))

return _collapse_addresses_internal(addrs + nets)

def get_mixed_type_key(obj):

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

Address and Network objects are not sortable by default; they're

fundamentally different so the expression

IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')

doesn't make any sense. There are some times however, where you may wish

to have ipaddress sort these for you anyway. If you need to do this, you

can use this function as the key= argument to sorted().

Args:

obj: either a Network or Address object.

Returns:

appropriate key.

"""

if isinstance(obj, _BaseNetwork):

return obj._get_networks_key()

elif isinstance(obj, _BaseAddress):

return obj._get_address_key()

return NotImplemented

class _IPAddressBase:

"""The mother class."""

__slots__ = ()

@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 reverse_pointer(self):

"""The name of the reverse DNS pointer for the IP address, e.g.:

>>> ipaddress.ip_address("127.0.0.1").reverse_pointer

'1.0.0.127.in-addr.arpa'

>>> ipaddress.ip_address("2001:db8::1").reverse_pointer

'1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa'

"""

return self._reverse_pointer()

@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))

@classmethod

def _ip_int_from_prefix(cls, prefixlen):

"""Turn the prefix length into a bitwise netmask

Args:

prefixlen: An integer, the prefix length.

Returns:

An integer.

"""

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

@classmethod

def _prefix_from_ip_int(cls, ip_int):

"""Return prefix length from the bitwise netmask.

Args:

ip_int: An integer, the netmask in expanded bitwise format

Returns:

An integer, the prefix length.

Raises:

ValueError: If the input intermingles zeroes & ones

"""

trailing_zeroes = _count_righthand_zero_bits(ip_int,

cls._max_prefixlen)

prefixlen = cls._max_prefixlen - trailing_zeroes

leading_ones = ip_int >> trailing_zeroes

all_ones = (1 << prefixlen) - 1

if leading_ones != all_ones:

byteslen = cls._max_prefixlen // 8

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

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

raise ValueError(msg % details)

return prefixlen

@classmethod

def _report_invalid_netmask(cls, netmask_str):

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

raise NetmaskValueError(msg) from None

@classmethod

def _prefix_from_prefix_string(cls, prefixlen_str):

"""Return prefix length from a numeric string

Args:

prefixlen_str: The string to be converted

Returns:

An integer, the prefix length.

Raises:

NetmaskValueError: If the input is not a valid netmask

"""

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

# so we ensure that isn't the case

if not (prefixlen_str.isascii() and prefixlen_str.isdigit()):

cls._report_invalid_netmask(prefixlen_str)

try:

prefixlen = int(prefixlen_str)

except ValueError:

cls._report_invalid_netmask(prefixlen_str)

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

cls._report_invalid_netmask(prefixlen_str)

return prefixlen

@classmethod

def _prefix_from_ip_string(cls, ip_str):

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

Args:

ip_str: The netmask/hostmask to be converted

Returns:

An integer, the prefix length.

Raises:

NetmaskValueError: If the input is not a valid netmask/hostmask

"""

# Parse the netmask/hostmask like an IP address.

try:

ip_int = cls._ip_int_from_string(ip_str)

except AddressValueError:

cls._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 cls._prefix_from_ip_int(ip_int)

except ValueError:

pass

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

ip_int ^= cls._ALL_ONES

try:

return cls._prefix_from_ip_int(ip_int)

except ValueError:

cls._report_invalid_netmask(ip_str)

@classmethod

def _split_addr_prefix(cls, address):

"""Helper function to parse address of Network/Interface.

Arg:

address: Argument of Network/Interface.

Returns:

(addr, prefix) tuple.

"""

# a packed address or integer

if isinstance(address, (bytes, int)):

return address, cls._max_prefixlen

if not isinstance(address, tuple):

# Assume input argument to be string or any object representation

# which converts into a formatted IP prefix string.

address = _split_optional_netmask(address)

# Constructing from a tuple (addr, [mask])

if len(address) > 1:

return address

return address[0], cls._max_prefixlen

def __reduce__(self):

return self.__class__, (str(self),)

_address_fmt_re = None

@functools.total_ordering

class _BaseAddress(_IPAddressBase):

"""A generic IP object.

This IP class contains the version independent methods which are

used by single IP addresses.

"""

__slots__ = ()

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 not isinstance(other, _BaseAddress):

return NotImplemented

if self._version != other._version:

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

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):

return (self._version, self)

def __reduce__(self):

return self.__class__, (self._ip,)

def __format__(self, fmt):

"""Returns an IP address as a formatted string.

Supported presentation types are:

's': returns the IP address as a string (default)

'b': converts to binary and returns a zero-padded string

'X' or 'x': converts to upper- or lower-case hex and returns a zero-padded string

'n': the same as 'b' for IPv4 and 'x' for IPv6

For binary and hex presentation types, the alternate form specifier

'#' and the grouping option '_' are supported.

"""

# Support string formatting

if not fmt or fmt[-1] == 's':

return format(str(self), fmt)

# From here on down, support for 'bnXx'

global _address_fmt_re

if _address_fmt_re is None:

import re

_address_fmt_re = re.compile('(#?)(_?)([xbnX])')

m = _address_fmt_re.fullmatch(fmt)

if not m:

return super().__format__(fmt)

alternate, grouping, fmt_base = m.groups()

# Set some defaults

if fmt_base == 'n':

if self._version == 4:

fmt_base = 'b' # Binary is default for ipv4

else:

fmt_base = 'x' # Hex is default for ipv6

if fmt_base == 'b':

padlen = self._max_prefixlen

else:

padlen = self._max_prefixlen // 4

if grouping:

padlen += padlen // 4 - 1

if alternate:

padlen += 2 # 0b or 0x

return format(int(self), f'{alternate}0{padlen}{grouping}{fmt_base}')

@functools.total_ordering

class _BaseNetwork(_IPAddressBase):

"""A generic IP network object.

This IP class contains the version independent methods which are

used by networks.

"""

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.

This is like __iter__ except it doesn't return the network

or broadcast addresses.

"""

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('address out of range')

return self._address_class(network + n)

else:

n += 1

if broadcast + n < network:

raise IndexError('address out of range')

return self._address_class(broadcast + n)

def __lt__(self, other):

if not isinstance(other, _BaseNetwork):

return NotImplemented

if self._version != other._version:

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

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 other._ip & self.netmask._ip == self.network_address._ip

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)))

@functools.cached_property

def broadcast_address(self):

return self._address_class(int(self.network_address) |

int(self.hostmask))

@functools.cached_property

def hostmask(self):

return self._address_class(int(self.netmask) ^ self._ALL_ONES)

@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.

For example:

addr1 = ip_network('192.0.2.0/28')

addr2 = ip_network('192.0.2.1/32')

list(addr1.address_exclude(addr2)) =

[IPv4Network('192.0.2.0/32'), IPv4Network('192.0.2.2/31'),

IPv4Network('192.0.2.4/30'), IPv4Network('192.0.2.8/29')]

or IPv6:

addr1 = ip_network('2001:db8::1/32')

addr2 = ip_network('2001:db8::1/128')

list(addr1.address_exclude(addr2)) =

[ip_network('2001:db8::1/128'),

ip_network('2001:db8::2/127'),

ip_network('2001:db8::4/126'),

ip_network('2001:db8::8/125'),

...

ip_network('2001:db8:8000::/33')]

Args:

other: An IPv4Network or IPv6Network object of the same type.

Returns:

An iterator of the IPv(4|6)Network objects which is self

minus other.

Raises:

TypeError: If self and other are of differing address

versions, or if other is not a network object.

ValueError: If other is not completely contained by self.

"""

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.subnet_of(self):

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

if other == self:

return

# 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.subnet_of(s1):

yield s2

s1, s2 = s1.subnets()

elif other.subnet_of(s2):

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.

This is only concerned about the comparison of the integer

representation of the network addresses. This means that the

host bits aren't considered at all in this method. If you want

to compare host bits, you can easily enough do a

'HostA._ip < HostB._ip'

Args:

other: An IP object.

Returns:

If the IP versions of self and other are the same, returns:

-1 if self < other:

eg: IPv4Network('192.0.2.0/25') < IPv4Network('192.0.2.128/25')

IPv6Network('2001:db8::1000/124') <

IPv6Network('2001:db8::2000/124')

0 if self == other

eg: IPv4Network('192.0.2.0/24') == IPv4Network('192.0.2.0/24')

IPv6Network('2001:db8::1000/124') ==

IPv6Network('2001:db8::1000/124')

1 if self > other

eg: IPv4Network('192.0.2.128/25') > IPv4Network('192.0.2.0/25')

IPv6Network('2001:db8::2000/124') >

IPv6Network('2001:db8::1000/124')

Raises:

TypeError if the IP versions are different.

"""

# 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.

Returns an object that identifies this address' network and

netmask. This function is a suitable "key" argument for sorted()

and list.sort().

"""

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.

In the case that self contains only one IP

(self._prefixlen == 32 for IPv4 or self._prefixlen == 128

for IPv6), yield an iterator with just ourself.

Args:

prefixlen_diff: An integer, the amount the prefix length

should be increased by. This should not be set if

new_prefix is also set.

new_prefix: The desired new prefix length. This must be a

larger number (smaller prefix) than the existing prefix.

This should not be set if prefixlen_diff is also set.

Returns:

An iterator of IPv(4|6) objects.

Raises:

ValueError: The prefixlen_diff is too small or too large.

OR

prefixlen_diff and new_prefix are both set or new_prefix

is a smaller number than the current prefix (smaller

number means a larger network)

"""

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))

start = int(self.network_address)

end = int(self.broadcast_address) + 1

step = (int(self.hostmask) + 1) >> prefixlen_diff

for new_addr in range(start, end, step):

current = self.__class__((new_addr, new_prefixlen))

yield current

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

"""The supernet containing the current network.

Args:

prefixlen_diff: An integer, the amount the prefix length of

the network should be decreased by. For example, given a

/24 network and a prefixlen_diff of 3, a supernet with a

/21 netmask is returned.

Returns:

An IPv4 network object.

Raises:

ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have

a negative prefix length.

OR

If prefixlen_diff and new_prefix are both set or new_prefix is a

larger number than the current prefix (larger number means a

smaller network)