File ipaddress-update-pr60.patch of Package python3.39617
---
Lib/functools.py | 76 ++++
Lib/ipaddress.py | 373 ++++++++-------------
Lib/test/test_ipaddress.py | 791 +++++++++++++++++++++++++++++----------------
3 files changed, 743 insertions(+), 497 deletions(-)
Index: Python-3.6.15/Lib/functools.py
===================================================================
--- Python-3.6.15.orig/Lib/functools.py 2025-06-14 16:53:15.411403786 +0200
+++ Python-3.6.15/Lib/functools.py 2025-06-14 17:13:06.220214685 +0200
@@ -11,7 +11,7 @@
__all__ = ['update_wrapper', 'wraps', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_UPDATES',
'total_ordering', 'cmp_to_key', 'lru_cache', 'reduce', 'partial',
- 'partialmethod', 'singledispatch']
+ 'partialmethod', 'singledispatch', 'cached_property']
try:
from _functools import reduce
@@ -814,3 +814,77 @@
wrapper._clear_cache = dispatch_cache.clear
update_wrapper(wrapper, func)
return wrapper
+
+################################################################################
+### for ipaddress
+### copied from https://github.com/penguinolog/backports.cached_property
+################################################################################
+"""Backport of python 3.8 functools.cached_property.
+
+cached_property() - computed once per instance, cached as attribute
+"""
+# noinspection PyPep8Naming
+_NOT_FOUND = object()
+
+class cached_property: # NOSONAR # pylint: disable=invalid-name # noqa: N801
+ """Cached property implementation.
+
+ Transform a method of a class into a property whose value is computed once
+ and then cached as a normal attribute for the life of the instance.
+ Similar to property(), with the addition of caching.
+ Useful for expensive computed properties of instances
+ that are otherwise effectively immutable.
+ """
+
+ def __init__(self, func) -> None:
+ """Cached property implementation."""
+ self.func = func
+ self.attrname = None
+ self.__doc__ = func.__doc__
+ self.lock = RLock()
+
+ def __set_name__(self, owner, name):
+ """Assign attribute name and owner."""
+ if self.attrname is None:
+ self.attrname = name
+ elif name != self.attrname:
+ raise TypeError(
+ "Cannot assign the same cached_property to two different names "
+ f"({self.attrname!r} and {name!r})."
+ )
+
+ def __get__(self, instance, owner = None):
+ """Property-like getter implementation.
+
+ :return: property instance if requested on class or value/cached value if requested on instance.
+ :rtype: Union[cached_property[self._T], self._T]
+ :raises TypeError: call without calling __set_name__ or no '__dict__' attribute
+ """
+ if instance is None:
+ return self
+ if self.attrname is None:
+ raise TypeError("Cannot use cached_property instance without calling __set_name__ on it.")
+ try:
+ cache = instance.__dict__
+ except AttributeError: # not all objects have __dict__ (e.g. class defines slots)
+ msg = (
+ f"No '__dict__' attribute on {type(instance).__name__!r} "
+ f"instance to cache {self.attrname!r} property."
+ )
+ raise TypeError(msg) from None
+ val = cache.get(self.attrname, _NOT_FOUND)
+ if val is _NOT_FOUND:
+ with self.lock:
+ # check if another thread filled cache while we awaited lock
+ val = cache.get(self.attrname, _NOT_FOUND)
+ if val is _NOT_FOUND:
+ val = self.func(instance)
+ try:
+ cache[self.attrname] = val
+ except TypeError:
+ msg = (
+ f"The '__dict__' attribute on {type(instance).__name__!r} instance "
+ f"does not support item assignment for caching {self.attrname!r} property."
+ )
+ raise TypeError(msg) from None
+ return val
Index: Python-3.6.15/Lib/ipaddress.py
===================================================================
--- Python-3.6.15.orig/Lib/ipaddress.py 2025-06-14 16:53:15.411403786 +0200
+++ Python-3.6.15/Lib/ipaddress.py 2025-06-14 18:04:37.744525235 +0200
@@ -8,8 +8,8 @@
"""
-__version__ = '1.0'
+__version__ = '1.0.23-openSUSE36'
import functools
@@ -50,6 +50,12 @@
except (AddressValueError, NetmaskValueError):
pass
+ if isinstance(address, bytes):
+ raise AddressValueError(
+ '%r does not appear to be an IPv4 or IPv6 address. '
+ 'Did you pass in a bytes (str in Python 2) instead of'
+ ' a unicode object?' % address)
+
raise ValueError('%r does not appear to be an IPv4 or IPv6 address' %
address)
@@ -80,6 +86,12 @@
except (AddressValueError, NetmaskValueError):
pass
+ if isinstance(address, bytes):
+ raise AddressValueError(
+ '%r does not appear to be an IPv4 or IPv6 network. '
+ 'Did you pass in a bytes (str in Python 2) instead of'
+ ' a unicode object?' % address)
+
raise ValueError('%r does not appear to be an IPv4 or IPv6 network' %
address)
@@ -424,11 +436,11 @@
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))
+ if len(address) != expected_len:
+ raise AddressValueError(
+ "%r (len %d != %d) is not a valid"
+ " L%d address" % (address, len(address),
+ expected_len, self._version))
@classmethod
def _ip_int_from_prefix(cls, prefixlen):
@@ -532,6 +544,28 @@
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),)
@@ -646,7 +680,10 @@
def __lt__(self, other):
if not isinstance(other, _BaseNetwork):
+ if isinstance(other, _BaseAddress):
+ raise TypeError("Cannot compare network and address objects")
return NotImplemented
+
if self._version != other._version:
raise TypeError('%s and %s are not of the same version' % (
self, other))
@@ -677,8 +714,7 @@
# dealing with another address
else:
# address
- return (int(self.network_address) <= int(other._ip) <=
- int(self.broadcast_address))
+ return other._ip & self.netmask._ip == self.network_address._ip
def overlaps(self, other):
"""Tell if self is partly contained in other."""
@@ -687,7 +723,7 @@
other.network_address in self or (
other.broadcast_address in self)))
- @property
+ @functools.cached_property
def broadcast_address(self):
x = self._cache.get('broadcast_address')
if x is None:
@@ -696,7 +732,7 @@
self._cache['broadcast_address'] = x
return x
- @property
+ @functools.cached_property
def hostmask(self):
x = self._cache.get('hostmask')
if x is None:
@@ -776,8 +812,7 @@
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):
+ if not other.subnet_of(self):
raise ValueError('%s not contained in %s' % (other, self))
if other == self:
return
@@ -788,12 +823,10 @@
s1, s2 = self.subnets()
while s1 != other and s2 != other:
- if (other.network_address >= s1.network_address and
- other.broadcast_address <= s1.broadcast_address):
+ if other.subnet_of(s1):
yield s2
s1, s2 = s1.subnets()
- elif (other.network_address >= s2.network_address and
- other.broadcast_address <= s2.broadcast_address):
+ elif other.subnet_of(s2):
yield s1
s1, s2 = s2.subnets()
else:
@@ -975,6 +1008,27 @@
return (self.network_address.is_multicast and
self.broadcast_address.is_multicast)
+ @staticmethod
+ def _is_subnet_of(a, b):
+ try:
+ # Always false if one is v4 and the other is v6.
+ if a._version != b._version:
+ raise TypeError(
+ "%s and %s are not of the same version" % (a, b))
+ return (b.network_address <= a.network_address and
+ b.broadcast_address >= a.broadcast_address)
+ except AttributeError:
+ raise TypeError("Unable to test subnet containment "
+ "between %s and %s" % (a, b))
+
+ def subnet_of(self, other):
+ """Return True if this network is a subnet of other."""
+ return self._is_subnet_of(self, other)
+
+ def supernet_of(self, other):
+ """Return True if this network is a supernet of other."""
+ return self._is_subnet_of(other, self)
+
@property
def is_reserved(self):
"""Test if the address is otherwise IETF reserved.
@@ -1062,7 +1116,7 @@
_DECIMAL_DIGITS = frozenset('0123456789')
# the valid octets for host and netmasks. only useful for IPv4.
- _valid_mask_octets = frozenset({255, 254, 252, 248, 240, 224, 192, 128, 0})
+ _valid_mask_octets = frozenset([255, 254, 252, 248, 240, 224, 192, 128, 0])
_max_prefixlen = IPV4LENGTH
# There are only a handful of valid v4 netmasks, so we cache them all
@@ -1084,6 +1138,8 @@
if arg not in cls._netmask_cache:
if isinstance(arg, int):
prefixlen = arg
+ if not (0 <= prefixlen <= cls._max_prefixlen):
+ cls._report_invalid_netmask(prefixlen)
else:
try:
# Check for a netmask in prefix length form
@@ -1149,12 +1205,10 @@
raise ValueError(msg % octet_str)
# Convert to integer (we know digits are legal)
octet_int = int(octet_str, 10)
- # Any octets that look like they *might* be written in octal,
- # and which don't look exactly the same in both octal and
- # decimal are rejected as ambiguous
- if octet_int > 7 and octet_str[0] == '0':
- msg = "Ambiguous (octal/decimal) value in %r not permitted"
- raise ValueError(msg % octet_str)
+ # The last clause is a hack to allow for the-in-addr.arpa
+ # form of an IP address. This is not to be confused with
+ # the common C library interpretation of a single leading
+ # zero to mean an octal number.
if octet_int > 255:
raise ValueError("Octet %d (> 255) not permitted" % octet_int)
return octet_int
@@ -1172,37 +1226,6 @@
"""
return '.'.join(map(str, ip_int.to_bytes(4, 'big')))
- def _is_valid_netmask(self, netmask):
- """Verify that the netmask is valid.
-
- Args:
- netmask: A string, either a prefix or dotted decimal
- netmask.
-
- Returns:
- A boolean, True if the prefix represents a valid IPv4
- netmask.
-
- """
- mask = netmask.split('.')
- if len(mask) == 4:
- try:
- for x in mask:
- if int(x) not in self._valid_mask_octets:
- return False
- except ValueError:
- # Found something that isn't an integer or isn't valid
- return False
- for idx, y in enumerate(mask):
- if idx > 0 and y > mask[idx - 1]:
- return False
- return True
- try:
- netmask = int(netmask)
- except ValueError:
- return False
- return 0 <= netmask <= self._max_prefixlen
-
def _is_hostmask(self, ip_str):
"""Test if the IP string is a hostmask (rather than a netmask).
@@ -1273,7 +1296,8 @@
# Constructing from a packed address
if isinstance(address, bytes):
self._check_packed_address(address, 4)
- self._ip = int.from_bytes(address, 'big')
+ bvs = address
+ self._ip = int.from_bytes(bvs, 'big')
return
# Assume input argument to be string or any object representation
@@ -1283,6 +1307,7 @@
raise AddressValueError("Unexpected '/' in %r" % address)
self._ip = self._ip_int_from_string(addr_str)
+
@property
def packed(self):
"""The binary representation of this address."""
@@ -1302,42 +1327,21 @@
@property
@functools.lru_cache()
def is_private(self):
- """``True`` if the address is defined as not globally reachable by
- iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
- (for IPv6) with the following exceptions:
-
- * ``is_private`` is ``False`` for ``100.64.0.0/10``
- * For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
- semantics of the underlying IPv4 addresses and the following condition holds
- (see :attr:`IPv6Address.ipv4_mapped`)::
+ """Test if this address is allocated for private networks.
- address.is_private == address.ipv4_mapped.is_private
+ Returns:
+ A boolean, True if the address is reserved per
+ iana-ipv4-special-registry.
- ``is_private`` has value opposite to :attr:`is_global`, except for the ``100.64.0.0/10``
- IPv4 range where they are both ``False``.
"""
- return (
- any(self in net for net in self._constants._private_networks)
- and all(self not in net for net in self._constants._private_networks_exceptions)
- )
+ return any(self in net for net in self._constants._private_networks)
@property
@functools.lru_cache()
def is_global(self):
- """``True`` if the address is defined as globally reachable by
- iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
- (for IPv6) with the following exception:
-
- For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
- semantics of the underlying IPv4 addresses and the following condition holds
- (see :attr:`IPv6Address.ipv4_mapped`)::
-
- address.is_global == address.ipv4_mapped.is_global
-
- ``is_global`` has value opposite to :attr:`is_private`, except for the ``100.64.0.0/10``
- IPv4 range where they are both ``False``.
- """
- return self not in self._constants._public_network and not self.is_private
+ return (
+ self not in self._constants._public_network and
+ not self.is_private)
@property
def is_multicast(self):
@@ -1385,36 +1389,20 @@
class IPv4Interface(IPv4Address):
def __init__(self, address):
- if isinstance(address, (bytes, int)):
- IPv4Address.__init__(self, address)
- self.network = IPv4Network(self._ip)
- self._prefixlen = self._max_prefixlen
- return
-
- if isinstance(address, tuple):
- IPv4Address.__init__(self, address[0])
- if len(address) > 1:
- self._prefixlen = int(address[1])
- else:
- self._prefixlen = self._max_prefixlen
-
- self.network = IPv4Network(address, strict=False)
- self.netmask = self.network.netmask
- self.hostmask = self.network.hostmask
- return
-
- addr = _split_optional_netmask(address)
- IPv4Address.__init__(self, addr[0])
-
- self.network = IPv4Network(address, strict=False)
+ addr_raw, mask = self._split_addr_prefix(address)
+ IPv4Address.__init__(self, addr_raw)
+ self.netmask, self._prefixlen = self._make_netmask(mask)
+ self.network = IPv4Network((self._ip, self._prefixlen), strict=False)
+ self.netmask = self.network.netmask
self._prefixlen = self.network._prefixlen
- self.netmask = self.network.netmask
- self.hostmask = self.network.hostmask
+ @functools.cached_property
+ def hostmask(self):
+ return self.network.hostmask
def __str__(self):
return '%s/%d' % (self._string_from_ip_int(self._ip),
- self.network.prefixlen)
+ self._prefixlen)
def __eq__(self, other):
address_equal = IPv4Address.__eq__(self, other)
@@ -1441,7 +1429,8 @@
return False
def __hash__(self):
- return hash((self._ip, self._prefixlen, int(self.network.network_address)))
+ return hash((self._ip, self._prefixlen,
+ int(self.network.network_address)))
__reduce__ = _IPAddressBase.__reduce__
@@ -1488,7 +1477,7 @@
address: A string or integer representing the IP [& network].
'192.0.2.0/24'
'192.0.2.0/255.255.255.0'
- '192.0.0.2/0.0.0.255'
+ '192.0.2.0/0.0.0.255'
are all functionally the same in IPv4. Similarly,
'192.0.2.1'
'192.0.2.1/255.255.255.255'
@@ -1519,20 +1508,7 @@
"""
_BaseNetwork.__init__(self, address)
- # Constructing from a packed address or integer
- if isinstance(address, (int, bytes)):
- addr = address
- mask = self._max_prefixlen
- # Constructing from a tuple (addr, [mask])
- elif isinstance(address, tuple):
- addr = address[0]
- mask = address[1] if len(address) > 1 else self._max_prefixlen
- # Assume input argument to be string or any object representation
- # which converts into a formatted IP prefix string.
- else:
- args = _split_optional_netmask(address)
- addr = self._ip_int_from_string(args[0])
- mask = args[1] if len(args) == 2 else self._max_prefixlen
+ addr, mask = self._split_addr_prefix(address)
self.network_address = IPv4Address(addr)
self.netmask, self._prefixlen = self._make_netmask(mask)
@@ -1558,11 +1534,12 @@
"""
return (not (self.network_address in IPv4Network('100.64.0.0/10') and
- self.broadcast_address in IPv4Network('100.64.0.0/10')) and
+ self.broadcast_address in IPv4Network('100.64.0.0/10')) and
not self.is_private)
class _IPv4Constants:
+
_linklocal_network = IPv4Network('169.254.0.0/16')
_loopback_network = IPv4Network('127.0.0.0/8')
@@ -1571,15 +1548,13 @@
_public_network = IPv4Network('100.64.0.0/10')
- # Not globally reachable address blocks listed on
- # https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml
_private_networks = [
IPv4Network('0.0.0.0/8'),
IPv4Network('10.0.0.0/8'),
IPv4Network('127.0.0.0/8'),
IPv4Network('169.254.0.0/16'),
IPv4Network('172.16.0.0/12'),
- IPv4Network('192.0.0.0/24'),
+ IPv4Network('192.0.0.0/29'),
IPv4Network('192.0.0.170/31'),
IPv4Network('192.0.2.0/24'),
IPv4Network('192.168.0.0/16'),
@@ -1588,11 +1563,6 @@
IPv4Network('203.0.113.0/24'),
IPv4Network('240.0.0.0/4'),
IPv4Network('255.255.255.255/32'),
- ]
-
- _private_networks_exceptions = [
- IPv4Network('192.0.0.9/32'),
- IPv4Network('192.0.0.10/32'),
]
_reserved_network = IPv4Network('240.0.0.0/4')
@@ -1614,7 +1584,7 @@
__slots__ = ()
_version = 6
- _ALL_ONES = (2**IPV6LENGTH) - 1
+ _ALL_ONES = (2 ** IPV6LENGTH) - 1
_HEXTET_COUNT = 8
_HEX_DIGITS = frozenset('0123456789ABCDEFabcdef')
_max_prefixlen = IPV6LENGTH
@@ -1635,6 +1605,8 @@
if arg not in cls._netmask_cache:
if isinstance(arg, int):
prefixlen = arg
+ if not (0 <= prefixlen <= cls._max_prefixlen):
+ cls._report_invalid_netmask(prefixlen)
else:
prefixlen = cls._prefix_from_prefix_string(arg)
netmask = IPv6Address(cls._ip_int_from_prefix(prefixlen))
@@ -1680,7 +1652,7 @@
# leading or trailing zero part.
_max_parts = cls._HEXTET_COUNT + 1
if len(parts) > _max_parts:
- msg = "At most %d colons permitted in %r" % (_max_parts-1, ip_str)
+ msg = "At most %d colons permitted in %r" % (_max_parts - 1, ip_str)
raise AddressValueError(msg)
# Disregarding the endpoints, find '::' with nothing in between.
@@ -1911,7 +1883,7 @@
"""Represent and manipulate single IPv6 Addresses."""
- __slots__ = ('_ip', '_scope_id', '__weakref__')
+ __slots__ = ('_ip', 'scope_id', '__weakref__')
def __init__(self, address):
"""Instantiate a new IPv6 address object.
@@ -1934,14 +1906,15 @@
if isinstance(address, int):
self._check_int_address(address)
self._ip = address
- self._scope_id = None
+ self.scope_id = None
return
# Constructing from a packed address
if isinstance(address, bytes):
self._check_packed_address(address, 16)
- self._ip = int.from_bytes(address, 'big')
- self._scope_id = None
+ bvs = address
+ self.scope_id = None
+ self._ip = int.from_bytes(bvs, 'big')
return
# Assume input argument to be string or any object representation
@@ -1949,9 +1922,10 @@
addr_str = str(address)
if '/' in addr_str:
raise AddressValueError("Unexpected '/' in %r" % address)
- addr_str, self._scope_id = self._split_scope_id(addr_str)
- self._ip = self._ip_int_from_string(addr_str)
+ # Now that addr_str is confirmed to be a string, process scope ID
+ addr_only, self.scope_id = self._split_scope_id(addr_str)
+ self._ip = self._ip_int_from_string(addr_only)
@property
def packed(self):
@@ -2007,42 +1981,23 @@
@property
@functools.lru_cache()
def is_private(self):
- """``True`` if the address is defined as not globally reachable by
- iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
- (for IPv6) with the following exceptions:
-
- * ``is_private`` is ``False`` for ``100.64.0.0/10``
- * For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
- semantics of the underlying IPv4 addresses and the following condition holds
- (see :attr:`IPv6Address.ipv4_mapped`)::
-
- address.is_private == address.ipv4_mapped.is_private
-
- ``is_private`` has value opposite to :attr:`is_global`, except for the ``100.64.0.0/10``
- IPv4 range where they are both ``False``.
- """
- ipv4_mapped = self.ipv4_mapped
- if ipv4_mapped is not None:
- return ipv4_mapped.is_private
- return (
- any(self in net for net in self._constants._private_networks)
- and all(self not in net for net in self._constants._private_networks_exceptions)
- )
+ """Test if this address is allocated for private networks.
+
+ Returns:
+ A boolean, True if the address is reserved per
+ iana-ipv6-special-registry.
+
+ """
+ return any(self in net for net in self._constants._private_networks)
@property
def is_global(self):
- """``True`` if the address is defined as globally reachable by
- iana-ipv4-special-registry_ (for IPv4) or iana-ipv6-special-registry_
- (for IPv6) with the following exception:
-
- For IPv4-mapped IPv6-addresses the ``is_private`` value is determined by the
- semantics of the underlying IPv4 addresses and the following condition holds
- (see :attr:`IPv6Address.ipv4_mapped`)::
+ """Test if this address is allocated for public networks.
- address.is_global == address.ipv4_mapped.is_global
+ Returns:
+ A boolean, true if the address is not reserved per
+ iana-ipv6-special-registry.
- ``is_global`` has value opposite to :attr:`is_private`, except for the ``100.64.0.0/10``
- IPv4 range where they are both ``False``.
"""
return not self.is_private
@@ -2113,32 +2068,29 @@
class IPv6Interface(IPv6Address):
def __init__(self, address):
- if isinstance(address, (bytes, int)):
- IPv6Address.__init__(self, address)
- self.network = IPv6Network(self._ip)
- self._prefixlen = self._max_prefixlen
- return
- if isinstance(address, tuple):
- IPv6Address.__init__(self, address[0])
- if len(address) > 1:
- self._prefixlen = int(address[1])
- else:
- self._prefixlen = self._max_prefixlen
- self.network = IPv6Network(address, strict=False)
- self.netmask = self.network.netmask
- self.hostmask = self.network.hostmask
- return
+ # An IPv6Interface object has both an address and a network mask.
+ # It acts like an address, but its network properties are based on the mask.
+ # First, parse the address and potential mask part from the input.
+ addr_raw, mask = self._split_addr_prefix(address)
+
+ # Initialize the IPv6Address base with the raw address part.
+ # This call will also correctly set self.scope_id if present in addr_raw (if it's a string).
+ IPv6Address.__init__(self, addr_raw)
- addr = _split_optional_netmask(address)
- IPv6Address.__init__(self, addr[0])
- self.network = IPv6Network(address, strict=False)
- self.netmask = self.network.netmask
- self._prefixlen = self.network._prefixlen
- self.hostmask = self.network.hostmask
+ # Now, determine the interface's netmask and prefixlen from the mask part.
+ self.netmask, self._prefixlen = self._make_netmask(mask)
+
+ # The 'network' property is an IPv6Network object based on this interface's address and prefixlen.
+ self.network = IPv6Network((self._ip, self._prefixlen), strict=False)
+
+
+ @functools.cached_property
+ def hostmask(self):
+ return self.network.hostmask
def __str__(self):
return '%s/%d' % (self._string_from_ip_int(self._ip),
- self.network.prefixlen)
+ self._prefixlen)
def __eq__(self, other):
address_equal = IPv6Address.__eq__(self, other)
@@ -2247,20 +2199,7 @@
"""
_BaseNetwork.__init__(self, address)
- # Constructing from a packed address or integer
- if isinstance(address, (int, bytes)):
- addr = address
- mask = self._max_prefixlen
- # Constructing from a tuple (addr, [mask])
- elif isinstance(address, tuple):
- addr = address[0]
- mask = address[1] if len(address) > 1 else self._max_prefixlen
- # Assume input argument to be string or any object representation
- # which converts into a formatted IP prefix string.
- else:
- args = _split_optional_netmask(address)
- addr = self._ip_int_from_string(args[0])
- mask = args[1] if len(args) == 2 else self._max_prefixlen
+ addr, mask = self._split_addr_prefix(address)
self.network_address = IPv6Address(addr)
self.netmask, self._prefixlen = self._make_netmask(mask)
@@ -2309,29 +2248,17 @@
_multicast_network = IPv6Network('ff00::/8')
- # Not globally reachable address blocks listed on
- # https://www.iana.org/assignments/iana-ipv6-special-registry/iana-ipv6-special-registry.xhtml
_private_networks = [
IPv6Network('::1/128'),
IPv6Network('::/128'),
IPv6Network('::ffff:0:0/96'),
- IPv6Network('64:ff9b:1::/48'),
IPv6Network('100::/64'),
IPv6Network('2001::/23'),
+ IPv6Network('2001:2::/48'),
IPv6Network('2001:db8::/32'),
- # IANA says N/A, let's consider it not globally reachable to be safe
- IPv6Network('2002::/16'),
+ IPv6Network('2001:10::/28'),
IPv6Network('fc00::/7'),
IPv6Network('fe80::/10'),
- ]
-
- _private_networks_exceptions = [
- IPv6Network('2001:1::1/128'),
- IPv6Network('2001:1::2/128'),
- IPv6Network('2001:3::/32'),
- IPv6Network('2001:4:112::/48'),
- IPv6Network('2001:20::/28'),
- IPv6Network('2001:30::/28'),
]
_reserved_networks = [
Index: Python-3.6.15/Lib/test/test_ipaddress.py
===================================================================
--- Python-3.6.15.orig/Lib/test/test_ipaddress.py 2025-06-14 16:56:40.276480652 +0200
+++ Python-3.6.15/Lib/test/test_ipaddress.py 2025-06-14 18:05:21.404942454 +0200
@@ -3,14 +3,16 @@
"""Unittest for ipaddress module."""
+from __future__ import unicode_literals
-import unittest
-import re
import contextlib
import functools
import operator
import pickle
import ipaddress
+import re
+import sys
+import unittest
import weakref
@@ -49,9 +51,11 @@
cm = self.assertRaisesRegex(exc_type, details)
with cm as exc:
yield exc
- # Ensure we produce clean tracebacks on failure
- if exc.exception.__context__ is not None:
- self.assertTrue(exc.exception.__suppress_context__)
+
+ # Commented out - this is not easily possible in 2.x
+ # # Ensure we produce clean tracebacks on failure
+ # if exc.exception.__context__ is not None:
+ # self.assertTrue(exc.exception.__suppress_context__)
def assertAddressError(self, details, *args):
"""Ensure a clean AddressValueError"""
@@ -81,9 +85,12 @@
def test_not_an_index_issue15559(self):
# Implementing __index__ makes for a very nasty interaction with the
# bytes constructor. Thus, we disallow implicit use as an integer
- self.assertRaises(TypeError, operator.index, self.factory(1))
- self.assertRaises(TypeError, hex, self.factory(1))
- self.assertRaises(TypeError, bytes, self.factory(1))
+ with self.assertRaises(TypeError):
+ operator.index(self.factory(1))
+ with self.assertRaises(TypeError):
+ operator.index(self.factory(1))
+ with self.assertRaises(TypeError):
+ hex(self.factory(1))
def pickle_test(self, addr):
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -96,8 +103,17 @@
class CommonTestMixin_v4(CommonTestMixin):
def test_leading_zeros(self):
- self.assertInstancesEqual("000.000.000.000", "0.0.0.0")
- self.assertInstancesEqual("192.168.000.001", "192.168.0.1")
+ # For Address objects, they should compress. For Interface/Network, they display with prefix.
+ if "Address" in self.factory.__name__:
+ self.assertEqual(str(self.factory("000.000.000.000")), "0.0.0.0")
+ self.assertEqual(str(self.factory("192.168.000.001")), "192.168.0.1")
+ self.assertEqual(str(self.factory("016.016.016.016")), "16.16.16.16")
+ self.assertEqual(str(self.factory("001.000.008.016")), "1.0.8.16")
+ else:
+ self.assertEqual(str(self.factory("000.000.000.000")), "0.0.0.0/32")
+ self.assertEqual(str(self.factory("192.168.000.001")), "192.168.0.1/32")
+ self.assertEqual(str(self.factory("016.016.016.016")), "16.16.16.16/32")
+ self.assertEqual(str(self.factory("001.000.008.016")), "1.0.8.16/32")
def test_int(self):
self.assertInstancesEqual(0, "0.0.0.0")
@@ -115,12 +131,12 @@
def test_large_ints_rejected(self):
msg = "%d (>= 2**32) is not permitted as an IPv4 address"
with self.assertAddressError(re.escape(msg % 2**32)):
- self.factory(2**32)
+ self.factory(2 ** 32)
def test_bad_packed_length(self):
def assertBadLength(length):
addr = b'\0' * length
- msg = "%r (len %d != 4) is not permitted as an IPv4 address"
+ msg = "%r (len %d != 4) is not a valid L4 address"
with self.assertAddressError(re.escape(msg % (addr, length))):
self.factory(addr)
@@ -131,8 +147,13 @@
class CommonTestMixin_v6(CommonTestMixin):
def test_leading_zeros(self):
- self.assertInstancesEqual("0000::0000", "::")
- self.assertInstancesEqual("000::c0a8:0001", "::c0a8:1")
+ # For Address objects, they should compress. For Interface/Network, they display with prefix.
+ if "Address" in self.factory.__name__:
+ self.assertEqual(str(self.factory("0000::0000")), "::")
+ self.assertEqual(str(self.factory("000::c0a8:0001")), "::c0a8:1")
+ else:
+ self.assertEqual(str(self.factory("0000::0000")), "::/128")
+ self.assertEqual(str(self.factory("000::c0a8:0001")), "::c0a8:1/128")
def test_int(self):
self.assertInstancesEqual(0, "::")
@@ -154,15 +175,14 @@
def test_large_ints_rejected(self):
msg = "%d (>= 2**128) is not permitted as an IPv6 address"
with self.assertAddressError(re.escape(msg % 2**128)):
- self.factory(2**128)
+ self.factory(2 ** 128)
def test_bad_packed_length(self):
def assertBadLength(length):
addr = b'\0' * length
- msg = "%r (len %d != 16) is not permitted as an IPv6 address"
+ msg = "%r (len %d != 16) is not a valid L6 address"
with self.assertAddressError(re.escape(msg % (addr, length))):
self.factory(addr)
- self.factory(addr)
assertBadLength(15)
assertBadLength(17)
@@ -230,15 +250,6 @@
assertBadOctet("1.2.3.4::", "4::")
assertBadOctet("1.a.2.3", "a")
- def test_octal_decimal_ambiguity(self):
- def assertBadOctet(addr, octet):
- msg = "Ambiguous (octal/decimal) value in %r not permitted in %r"
- with self.assertAddressError(re.escape(msg % (octet, addr))):
- ipaddress.IPv4Address(addr)
-
- assertBadOctet("016.016.016.016", "016")
- assertBadOctet("001.000.008.016", "008")
-
def test_octet_length(self):
def assertBadOctet(addr, octet):
msg = "At most 3 characters permitted in %r in %r"
@@ -263,6 +274,14 @@
def test_weakref(self):
weakref.ref(self.factory('192.0.2.1'))
+ def test_bytes_message(self):
+ # Test the specific AddressValueError from IPv4Address(bytes) constructor.
+ with self.assertAddressError(re.escape(r"b'192.0.2.1' (len 9 != 4) is not a valid L4 address")):
+ self.factory(b'192.0.2.1')
+ # Test the generic AddressValueError from ip_address() factory for bytes input.
+ with self.assertAddressError(re.escape(r"b'192.0.2.1' does not appear to be an IPv4 or IPv6 address. Did you pass in a bytes (str in Python 2) instead of a unicode object?")):
+ ipaddress.ip_address(b'192.0.2.1')
+
class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6):
factory = ipaddress.IPv6Address
@@ -274,9 +293,9 @@
def test_bad_address_split_v6_not_enough_parts(self):
def assertBadSplit(addr):
- msg = "At least 3 parts expected in %r"
- with self.assertAddressError(msg, addr):
- ipaddress.IPv6Address(addr)
+ msg_format = "At least %d parts expected in %r"
+ with self.assertAddressError(msg_format, 3, addr):
+ self.factory(addr)
assertBadSplit(":")
assertBadSplit(":1")
@@ -284,8 +303,8 @@
def test_bad_address_split_v6_too_many_colons(self):
def assertBadSplit(addr):
- msg = "At most 8 colons permitted in %r"
- with self.assertAddressError(msg, addr):
+ msg = r"At most 8 colons permitted in '.*?'"
+ with self.assertAddressError(msg):
ipaddress.IPv6Address(addr)
assertBadSplit("9:8:7:6:5:4:3::2:1")
@@ -297,8 +316,8 @@
def test_bad_address_split_v6_too_many_parts(self):
def assertBadSplit(addr):
- msg = "Exactly 8 parts expected without '::' in %r"
- with self.assertAddressError(msg, addr):
+ msg = r"Exactly \d+ parts expected without '::' in '.*?'"
+ with self.assertAddressError(msg):
ipaddress.IPv6Address(addr)
assertBadSplit("3ffe:0:0:0:0:0:0:0:1")
@@ -310,16 +329,16 @@
def test_bad_address_split_v6_too_many_parts_with_double_colon(self):
def assertBadSplit(addr):
- msg = "Expected at most 7 other parts with '::' in %r"
- with self.assertAddressError(msg, addr):
+ msg = "Expected at most 7 other parts with '::' in '.*'"
+ with self.assertAddressError(msg):
ipaddress.IPv6Address(addr)
assertBadSplit("1:2:3:4::5:6:7:8")
def test_bad_address_split_v6_repeated_double_colon(self):
def assertBadSplit(addr):
- msg = "At most one '::' permitted in %r"
- with self.assertAddressError(msg, addr):
+ msg = "At most one '::' permitted in '.*'"
+ with self.assertAddressError(msg):
ipaddress.IPv6Address(addr)
assertBadSplit("3ffe::1::1")
@@ -335,8 +354,8 @@
def test_bad_address_split_v6_leading_colon(self):
def assertBadSplit(addr):
- msg = "Leading ':' only permitted as part of '::' in %r"
- with self.assertAddressError(msg, addr):
+ msg = "Leading ':' only permitted as part of '::' in '.*'"
+ with self.assertAddressError(msg):
ipaddress.IPv6Address(addr)
assertBadSplit(":2001:db8::1")
@@ -346,8 +365,8 @@
def test_bad_address_split_v6_trailing_colon(self):
def assertBadSplit(addr):
- msg = "Trailing ':' only permitted as part of '::' in %r"
- with self.assertAddressError(msg, addr):
+ msg = "Trailing ':' only permitted as part of '::' in '.*'"
+ with self.assertAddressError(msg):
ipaddress.IPv6Address(addr)
assertBadSplit("2001:db8::1:")
@@ -360,16 +379,16 @@
with self.assertAddressError("%s in %r", v4_error, addr):
ipaddress.IPv6Address(addr)
- assertBadAddressPart("3ffe::1.net", "Expected 4 octets in '1.net'")
+ assertBadAddressPart("3ffe::1.net", "Expected 4 octets in u?'1.net'")
assertBadAddressPart("3ffe::127.0.1",
- "Expected 4 octets in '127.0.1'")
+ "Expected 4 octets in u?'127.0.1'")
assertBadAddressPart("::1.2.3",
- "Expected 4 octets in '1.2.3'")
+ "Expected 4 octets in u?'1.2.3'")
assertBadAddressPart("::1.2.3.4.5",
- "Expected 4 octets in '1.2.3.4.5'")
+ "Expected 4 octets in u?'1.2.3.4.5'")
assertBadAddressPart("3ffe::1.1.1.net",
- "Only decimal digits permitted in 'net' "
- "in '1.1.1.net'")
+ "Only decimal digits permitted in u?'net' "
+ "in u?'1.1.1.net'")
def test_invalid_characters(self):
def assertBadPart(addr, part):
@@ -401,12 +420,26 @@
def test_weakref(self):
weakref.ref(self.factory('2001:db8::'))
+ def test_bytes_message(self):
+ # Test the specific AddressValueError from IPv6Address(bytes) constructor.
+ with self.assertAddressError(re.escape(r"b'::123' (len 5 != 16) is not a valid L6 address")):
+ self.factory(b'::123')
+ # Test the generic AddressValueError from ip_address() factory for bytes input.
+ with self.assertAddressError(re.escape(r"b'::123' does not appear to be an IPv4 or IPv6 address. Did you pass in a bytes (str in Python 2) instead of a unicode object?")):
+ ipaddress.ip_address(b'::123')
+
class NetmaskTestMixin_v4(CommonTestMixin_v4):
"""Input validation on interfaces and networks is very similar"""
def test_no_mask(self):
- self.assertEqual(str(self.factory('1.2.3.4')), '1.2.3.4/32')
+ for address in ('1.2.3.4', 0x01020304, b'\x01\x02\x03\x04'):
+ net = self.factory(address)
+ self.assertEqual(str(net), '1.2.3.4/32')
+ self.assertEqual(str(net.netmask), '255.255.255.255')
+ self.assertEqual(str(net.hostmask), '0.0.0.0')
+ # IPv4Network has prefixlen, but IPv4Interface doesn't.
+ # Should we add it to IPv4Interface too? (bpo-36392)
def test_split_netmask(self):
addr = "1.2.3.4/32/24"
@@ -467,6 +500,14 @@
assertBadNetmask("1.1.1.1", "pudding")
assertBadNetmask("1.1.1.1", "::")
+ def test_netmask_in_tuple_errors(self):
+ def assertBadNetmask(addr, netmask):
+ msg = "%r is not a valid netmask" % netmask
+ with self.assertNetmaskError(re.escape(msg)):
+ self.factory((addr, netmask))
+ assertBadNetmask("1.1.1.1", -1)
+ assertBadNetmask("1.1.1.1", 33)
+
def test_pickle(self):
self.pickle_test('192.0.2.0/27')
self.pickle_test('192.0.2.0/31') # IPV4LENGTH - 1
@@ -480,10 +521,80 @@
class NetworkTestCase_v4(BaseTestCase, NetmaskTestMixin_v4):
factory = ipaddress.IPv4Network
+ def test_subnet_of(self):
+ # containee left of container
+ self.assertFalse(
+ self.factory('10.0.0.0/30').subnet_of(
+ self.factory('10.0.1.0/24')))
+ # containee inside container
+ self.assertTrue(
+ self.factory('10.0.0.0/30').subnet_of(
+ self.factory('10.0.0.0/24')))
+ # containee right of container
+ self.assertFalse(
+ self.factory('10.0.0.0/30').subnet_of(
+ self.factory('10.0.1.0/24')))
+ # containee larger than container
+ self.assertFalse(
+ self.factory('10.0.1.0/24').subnet_of(
+ self.factory('10.0.0.0/30')))
+
+ def test_supernet_of(self):
+ # containee left of container
+ self.assertFalse(
+ self.factory('10.0.0.0/30').supernet_of(
+ self.factory('10.0.1.0/24')))
+ # containee inside container
+ self.assertFalse(
+ self.factory('10.0.0.0/30').supernet_of(
+ self.factory('10.0.0.0/24')))
+ # containee right of container
+ self.assertFalse(
+ self.factory('10.0.0.0/30').supernet_of(
+ self.factory('10.0.1.0/24')))
+ # containee larger than container
+ self.assertTrue(
+ self.factory('10.0.0.0/24').supernet_of(
+ self.factory('10.0.0.0/30')))
+
+ def test_subnet_of_mixed_types(self):
+ self.assertRaises(
+ TypeError,
+ ipaddress.IPv4Network('10.0.0.0/30').supernet_of,
+ ipaddress.IPv6Network('::1/128'),
+ )
+ self.assertRaises(
+ TypeError,
+ ipaddress.IPv6Network('::1/128').subnet_of,
+ ipaddress.IPv4Network('10.0.0.0/30'),
+ )
+ self.assertRaises(
+ TypeError,
+ ipaddress.IPv4Network('10.0.0.0/30').subnet_of,
+ ipaddress.IPv6Network('::1/128'),
+ )
+ self.assertRaises(
+ TypeError,
+ ipaddress.IPv6Network('::1/128').subnet_of,
+ ipaddress.IPv4Network('10.0.0.0/30'),
+ )
+
class NetmaskTestMixin_v6(CommonTestMixin_v6):
"""Input validation on interfaces and networks is very similar"""
+ def test_no_mask(self):
+ for address in ('::1', 1, b'\x00'*15 + b'\x01'):
+ net = self.factory(address)
+ self.assertEqual(str(net), '::1/128')
+ self.assertEqual(
+ str(net.netmask),
+ 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+ )
+ self.assertEqual(str(net.hostmask), '::')
+ # IPv6Network has prefixlen, but IPv6Interface doesn't.
+ # Should we add it to IPv4Interface too? (bpo-36392)
+
def test_split_netmask(self):
addr = "cafe:cafe::/128/190"
with self.assertAddressError("Only one '/' permitted in %r" % addr):
@@ -530,6 +641,14 @@
assertBadNetmask("::1", "pudding")
assertBadNetmask("::", "::")
+ def test_netmask_in_tuple_errors(self):
+ def assertBadNetmask(addr, netmask):
+ msg = "%r is not a valid netmask" % netmask
+ with self.assertNetmaskError(re.escape(msg)):
+ self.factory((addr, netmask))
+ assertBadNetmask("::1", -1)
+ assertBadNetmask("::1", 129)
+
def test_pickle(self):
self.pickle_test('2001:db8::1000/124')
self.pickle_test('2001:db8::1000/127') # IPV6LENGTH - 1
@@ -543,6 +662,42 @@
class NetworkTestCase_v6(BaseTestCase, NetmaskTestMixin_v6):
factory = ipaddress.IPv6Network
+ def test_subnet_of(self):
+ # containee left of container
+ self.assertFalse(
+ self.factory('2000:999::/56').subnet_of(
+ self.factory('2000:aaa::/48')))
+ # containee inside container
+ self.assertTrue(
+ self.factory('2000:aaa::/56').subnet_of(
+ self.factory('2000:aaa::/48')))
+ # containee right of container
+ self.assertFalse(
+ self.factory('2000:bbb::/56').subnet_of(
+ self.factory('2000:aaa::/48')))
+ # containee larger than container
+ self.assertFalse(
+ self.factory('2000:aaa::/48').subnet_of(
+ self.factory('2000:aaa::/56')))
+
+ def test_supernet_of(self):
+ # containee left of container
+ self.assertFalse(
+ self.factory('2000:999::/56').supernet_of(
+ self.factory('2000:aaa::/48')))
+ # containee inside container
+ self.assertFalse(
+ self.factory('2000:aaa::/56').supernet_of(
+ self.factory('2000:aaa::/48')))
+ # containee right of container
+ self.assertFalse(
+ self.factory('2000:bbb::/56').supernet_of(
+ self.factory('2000:aaa::/48')))
+ # containee larger than container
+ self.assertTrue(
+ self.factory('2000:aaa::/48').supernet_of(
+ self.factory('2000:aaa::/56')))
+
class FactoryFunctionErrors(BaseTestCase):
@@ -567,6 +722,7 @@
class LargestObject:
def __eq__(self, other):
return isinstance(other, LargestObject)
+
def __lt__(self, other):
return False
@@ -574,8 +730,10 @@
class SmallestObject:
def __eq__(self, other):
return isinstance(other, SmallestObject)
- def __gt__(self, other):
- return False
+
+ def __lt__(self, other):
+ return True
+
class ComparisonTests(unittest.TestCase):
@@ -658,10 +816,14 @@
for rhs in self.objects:
if isinstance(lhs, type(rhs)) or isinstance(rhs, type(lhs)):
continue
- self.assertRaises(TypeError, lambda: lhs < rhs)
- self.assertRaises(TypeError, lambda: lhs > rhs)
- self.assertRaises(TypeError, lambda: lhs <= rhs)
- self.assertRaises(TypeError, lambda: lhs >= rhs)
+ with self.assertRaises(TypeError):
+ lhs < rhs
+ with self.assertRaises(TypeError):
+ lhs > rhs
+ with self.assertRaises(TypeError):
+ lhs <= rhs
+ with self.assertRaises(TypeError):
+ lhs >= rhs
def test_foreign_type_ordering(self):
other = object()
@@ -724,7 +886,6 @@
self.ipv4_address = ipaddress.IPv4Address('1.2.3.4')
self.ipv4_interface = ipaddress.IPv4Interface('1.2.3.4/24')
self.ipv4_network = ipaddress.IPv4Network('1.2.3.0/24')
- #self.ipv4_hostmask = ipaddress.IPv4Interface('10.0.0.1/0.255.255.255')
self.ipv6_address = ipaddress.IPv6Interface(
'2001:658:22a:cafe:200:0:0:1')
self.ipv6_interface = ipaddress.IPv6Interface(
@@ -732,10 +893,10 @@
self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64')
def testRepr(self):
- self.assertEqual("IPv4Interface('1.2.3.4/32')",
- repr(ipaddress.IPv4Interface('1.2.3.4')))
- self.assertEqual("IPv6Interface('::1/128')",
- repr(ipaddress.IPv6Interface('::1')))
+ self.assertTrue(re.match(r"IPv4Interface\(u?'1.2.3.4/32'\)",
+ repr(ipaddress.IPv4Interface('1.2.3.4'))))
+ self.assertTrue(re.match(r"IPv6Interface\(u?'::1/128'\)",
+ repr(ipaddress.IPv6Interface('::1'))))
# issue #16531: constructing IPv4Network from an (address, mask) tuple
def testIPv4Tuple(self):
@@ -808,7 +969,7 @@
self.assertEqual(ipaddress.IPv6Network(('2001:db8::', '128')),
net)
self.assertEqual(ipaddress.IPv6Network(
- (42540766411282592856903984951653826560, 128)),
+ (42540766411282592856903984951653826560, 128)),
net)
self.assertEqual(ipaddress.IPv6Network((ip, '128')),
net)
@@ -816,39 +977,41 @@
net = ipaddress.IPv6Network('2001:db8::/96')
self.assertEqual(ipaddress.IPv6Network(('2001:db8::', '96')),
net)
- self.assertEqual(ipaddress.IPv6Network(
+ self.assertEqual(
+ ipaddress.IPv6Network(
(42540766411282592856903984951653826560, 96)),
- net)
+ net)
self.assertEqual(ipaddress.IPv6Network((ip, '96')),
net)
# strict=True and host bits set
ip = ipaddress.IPv6Address('2001:db8::1')
- with self.assertRaises(ValueError):
- ipaddress.IPv6Network(('2001:db8::1', 96))
- with self.assertRaises(ValueError):
- ipaddress.IPv6Network((
- 42540766411282592856903984951653826561, 96))
- with self.assertRaises(ValueError):
- ipaddress.IPv6Network((ip, 96))
+ self.assertRaises(
+ ValueError, ipaddress.IPv6Network, ('2001:db8::1', 96))
+ self.assertRaises(
+ ValueError, ipaddress.IPv6Network,
+ (42540766411282592856903984951653826561, 96))
+ self.assertRaises(ValueError, ipaddress.IPv6Network, (ip, 96))
# strict=False and host bits set
net = ipaddress.IPv6Network('2001:db8::/96')
self.assertEqual(ipaddress.IPv6Network(('2001:db8::1', 96),
strict=False),
net)
- self.assertEqual(ipaddress.IPv6Network(
- (42540766411282592856903984951653826561, 96),
- strict=False),
- net)
- self.assertEqual(ipaddress.IPv6Network((ip, 96), strict=False),
- net)
+ self.assertEqual(
+ ipaddress.IPv6Network(
+ (42540766411282592856903984951653826561, 96), strict=False),
+ net)
+ self.assertEqual(
+ ipaddress.IPv6Network((ip, 96), strict=False),
+ net)
# /96
self.assertEqual(ipaddress.IPv6Interface(('2001:db8::1', '96')),
ipaddress.IPv6Interface('2001:db8::1/96'))
- self.assertEqual(ipaddress.IPv6Interface(
+ self.assertEqual(
+ ipaddress.IPv6Interface(
(42540766411282592856903984951653826561, '96')),
- ipaddress.IPv6Interface('2001:db8::1/96'))
+ ipaddress.IPv6Interface('2001:db8::1/96'))
# issue57
def testAddressIntMath(self):
@@ -856,9 +1019,9 @@
ipaddress.IPv4Address('1.1.2.0'))
self.assertEqual(ipaddress.IPv4Address('1.1.1.1') - 256,
ipaddress.IPv4Address('1.1.0.1'))
- self.assertEqual(ipaddress.IPv6Address('::1') + (2**16 - 2),
+ self.assertEqual(ipaddress.IPv6Address('::1') + (2 ** 16 - 2),
ipaddress.IPv6Address('::ffff'))
- self.assertEqual(ipaddress.IPv6Address('::ffff') - (2**16 - 2),
+ self.assertEqual(ipaddress.IPv6Address('::ffff') - (2 ** 16 - 2),
ipaddress.IPv6Address('::1'))
def testInvalidIntToBytes(self):
@@ -880,7 +1043,16 @@
self.assertEqual(list(ipaddress._find_address_range([ip1, ip2, ip3])),
[(ip1, ip3)])
self.assertEqual(128, ipaddress._count_righthand_zero_bits(0, 128))
- self.assertEqual("IPv4Network('1.2.3.0/24')", repr(self.ipv4_network))
+ self.assertTrue(
+ re.match(r"IPv4Network\(u?'1.2.3.0/24'\)",
+ repr(self.ipv4_network)))
+
+ def testMissingAddressVersion(self):
+ class Broken(ipaddress._BaseAddress):
+ pass
+ broken = Broken()
+ with self.assertRaisesRegex(NotImplementedError, "Broken.*version"):
+ broken.version
def testMissingNetworkVersion(self):
class Broken(ipaddress._BaseNetwork):
@@ -898,7 +1070,9 @@
def testGetNetwork(self):
self.assertEqual(int(self.ipv4_network.network_address), 16909056)
- self.assertEqual(str(self.ipv4_network.network_address), '1.2.3.0')
+ self.assertEqual(
+ str(self.ipv4_network.network_address),
+ '1.2.3.0')
self.assertEqual(int(self.ipv6_network.network_address),
42540616829182469433403647294022090752)
@@ -931,13 +1105,15 @@
ipaddress.ip_interface(b'\x01\x02\x03\x04')._ip)
self.assertEqual(address('255.254.253.252'),
address(b'\xff\xfe\xfd\xfc'))
- self.assertEqual(self.ipv6_interface.ip,
- ipaddress.ip_interface(
- b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
+ self.assertEqual(
+ self.ipv6_interface.ip,
+ ipaddress.ip_interface(
+ b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
b'\x02\x00\x00\x00\x00\x00\x00\x01').ip)
- self.assertEqual(address('ffff:2:3:4:ffff::'),
- address(b'\xff\xff\x00\x02\x00\x03\x00\x04' +
- b'\xff\xff' + b'\x00' * 6))
+ self.assertEqual(
+ address('ffff:2:3:4:ffff::'),
+ address(b'\xff\xff\x00\x02\x00\x03\x00\x04' +
+ b'\xff\xff' + b'\x00' * 6))
self.assertEqual(address('::'),
address(b'\x00' * 16))
@@ -952,7 +1128,9 @@
def testGetNetmask(self):
self.assertEqual(int(self.ipv4_network.netmask), 4294967040)
- self.assertEqual(str(self.ipv4_network.netmask), '255.255.255.0')
+ self.assertEqual(
+ str(self.ipv4_network.netmask),
+ '255.255.255.0')
self.assertEqual(int(self.ipv6_network.netmask),
340282366920938463444927863358058659840)
self.assertEqual(self.ipv6_network.prefixlen, 64)
@@ -961,9 +1139,7 @@
ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0')
self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0)
self.assertEqual(ipv4_zero_netmask._prefix_from_prefix_string('0'), 0)
- self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0'))
- self.assertTrue(ipv4_zero_netmask._is_valid_netmask('0.0.0.0'))
- self.assertFalse(ipv4_zero_netmask._is_valid_netmask('invalid'))
+ # Removed all _is_valid_netmask tests - the method was unused upstream
ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0')
self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0)
@@ -971,12 +1147,7 @@
def testIPv4NetAndHostmasks(self):
net = self.ipv4_network
- self.assertFalse(net._is_valid_netmask('invalid'))
- self.assertTrue(net._is_valid_netmask('128.128.128.128'))
- self.assertFalse(net._is_valid_netmask('128.128.128.127'))
- self.assertFalse(net._is_valid_netmask('128.128.128.255'))
- self.assertTrue(net._is_valid_netmask('255.128.128.128'))
-
+ # Removed all _is_valid_netmask tests - the method was unused upstream
self.assertFalse(net._is_hostmask('invalid'))
self.assertTrue(net._is_hostmask('128.255.255.255'))
self.assertFalse(net._is_hostmask('255.255.255.255'))
@@ -987,7 +1158,9 @@
def testGetBroadcast(self):
self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311)
- self.assertEqual(str(self.ipv4_network.broadcast_address), '1.2.3.255')
+ self.assertEqual(
+ str(self.ipv4_network.broadcast_address),
+ '1.2.3.255')
self.assertEqual(int(self.ipv6_network.broadcast_address),
42540616829182469451850391367731642367)
@@ -1000,26 +1173,31 @@
def testGetSupernet(self):
self.assertEqual(self.ipv4_network.supernet().prefixlen, 23)
- self.assertEqual(str(self.ipv4_network.supernet().network_address),
- '1.2.2.0')
+ self.assertEqual(
+ str(self.ipv4_network.supernet().network_address),
+ '1.2.2.0')
self.assertEqual(
ipaddress.IPv4Interface('0.0.0.0/0').network.supernet(),
ipaddress.IPv4Network('0.0.0.0/0'))
self.assertEqual(self.ipv6_network.supernet().prefixlen, 63)
- self.assertEqual(str(self.ipv6_network.supernet().network_address),
- '2001:658:22a:cafe::')
- self.assertEqual(ipaddress.IPv6Interface('::0/0').network.supernet(),
- ipaddress.IPv6Network('::0/0'))
+ self.assertEqual(
+ str(self.ipv6_network.supernet().network_address),
+ '2001:658:22a:cafe::')
+ self.assertEqual(
+ ipaddress.IPv6Interface('::0/0').network.supernet(),
+ ipaddress.IPv6Network('::0/0'))
def testGetSupernet3(self):
self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21)
- self.assertEqual(str(self.ipv4_network.supernet(3).network_address),
- '1.2.0.0')
+ self.assertEqual(
+ str(self.ipv4_network.supernet(3).network_address),
+ '1.2.0.0')
self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61)
- self.assertEqual(str(self.ipv6_network.supernet(3).network_address),
- '2001:658:22a:caf8::')
+ self.assertEqual(
+ str(self.ipv6_network.supernet(3).network_address),
+ '2001:658:22a:caf8::')
def testGetSupernet4(self):
self.assertRaises(ValueError, self.ipv4_network.supernet,
@@ -1045,8 +1223,12 @@
ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/120')
hosts = list(ipv6_network.hosts())
self.assertEqual(255, len(hosts))
- self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0])
- self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1])
+ self.assertEqual(
+ ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0]
+ )
+ self.assertEqual(
+ ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1]
+ )
# special case where only 1 bit is left for address
addrs = [ipaddress.IPv4Address('2.0.0.0'),
@@ -1074,23 +1256,23 @@
self.ipv4_network.subnets(new_prefix=23))
self.assertRaises(ValueError, list,
self.ipv4_network.subnets(prefixlen_diff=3,
- new_prefix=27))
+ new_prefix=27))
self.assertEqual(sorted(self.ipv6_network.subnets(prefixlen_diff=4)),
sorted(self.ipv6_network.subnets(new_prefix=68)))
self.assertRaises(ValueError, list,
self.ipv6_network.subnets(new_prefix=63))
self.assertRaises(ValueError, list,
self.ipv6_network.subnets(prefixlen_diff=4,
- new_prefix=68))
+ new_prefix=68))
def testGetSubnets(self):
self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25)
- self.assertEqual(str(list(
- self.ipv4_network.subnets())[0].network_address),
- '1.2.3.0')
- self.assertEqual(str(list(
- self.ipv4_network.subnets())[1].network_address),
- '1.2.3.128')
+ self.assertEqual(
+ str(list(self.ipv4_network.subnets())[0].network_address),
+ '1.2.3.0')
+ self.assertEqual(
+ str(list(self.ipv4_network.subnets())[1].network_address),
+ '1.2.3.128')
self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65)
@@ -1124,19 +1306,23 @@
def testGetSubnets3(self):
subnets = [str(x) for x in self.ipv4_network.subnets(8)]
- self.assertEqual(subnets[:3],
+ self.assertEqual(
+ subnets[:3],
['1.2.3.0/32', '1.2.3.1/32', '1.2.3.2/32'])
- self.assertEqual(subnets[-3:],
+ self.assertEqual(
+ subnets[-3:],
['1.2.3.253/32', '1.2.3.254/32', '1.2.3.255/32'])
self.assertEqual(len(subnets), 256)
ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/120')
subnets = [str(x) for x in ipv6_network.subnets(8)]
- self.assertEqual(subnets[:3],
+ self.assertEqual(
+ subnets[:3],
['2001:658:22a:cafe::/128',
'2001:658:22a:cafe::1/128',
'2001:658:22a:cafe::2/128'])
- self.assertEqual(subnets[-3:],
+ self.assertEqual(
+ subnets[-3:],
['2001:658:22a:cafe::fd/128',
'2001:658:22a:cafe::fe/128',
'2001:658:22a:cafe::ff/128'])
@@ -1181,17 +1367,17 @@
36893488147419103232)
def testContains(self):
- self.assertIn(ipaddress.IPv4Interface('1.2.3.128/25'),
- self.ipv4_network)
- self.assertNotIn(ipaddress.IPv4Interface('1.2.4.1/24'),
+ self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in
+ self.ipv4_network)
+ self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in
self.ipv4_network)
# We can test addresses and string as well.
addr1 = ipaddress.IPv4Address('1.2.3.37')
- self.assertIn(addr1, self.ipv4_network)
+ self.assertTrue(addr1 in self.ipv4_network)
# issue 61, bad network comparison on like-ip'd network objects
# with identical broadcast addresses.
self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__(
- ipaddress.IPv4Network('1.0.0.0/15')))
+ ipaddress.IPv4Network('1.0.0.0/15')))
def testNth(self):
self.assertEqual(str(self.ipv4_network[5]), '1.2.3.5')
@@ -1223,9 +1409,11 @@
self.assertFalse(self.ipv4_interface == [])
self.assertFalse(self.ipv4_interface == 2)
- self.assertTrue(self.ipv6_interface ==
+ self.assertTrue(
+ self.ipv6_interface ==
ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
- self.assertFalse(self.ipv6_interface ==
+ self.assertFalse(
+ self.ipv6_interface ==
ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
self.assertFalse(self.ipv6_interface ==
ipaddress.IPv4Interface('1.2.3.4/23'))
@@ -1245,14 +1433,16 @@
self.assertTrue(self.ipv4_interface != 2)
self.assertTrue(self.ipv4_address !=
- ipaddress.IPv4Address('1.2.3.5'))
+ ipaddress.IPv4Address('1.2.3.5'))
self.assertTrue(self.ipv4_address != '')
self.assertTrue(self.ipv4_address != [])
self.assertTrue(self.ipv4_address != 2)
- self.assertFalse(self.ipv6_interface !=
+ self.assertFalse(
+ self.ipv6_interface !=
ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
- self.assertTrue(self.ipv6_interface !=
+ self.assertTrue(
+ self.ipv6_interface !=
ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
self.assertTrue(self.ipv6_interface !=
ipaddress.IPv4Interface('1.2.3.4/23'))
@@ -1267,16 +1457,19 @@
self.assertTrue(self.ipv6_address != 2)
def testSlash32Constructor(self):
- self.assertEqual(str(ipaddress.IPv4Interface(
- '1.2.3.4/255.255.255.255')), '1.2.3.4/32')
+ self.assertEqual(
+ str(ipaddress.IPv4Interface('1.2.3.4/255.255.255.255')),
+ '1.2.3.4/32')
def testSlash128Constructor(self):
- self.assertEqual(str(ipaddress.IPv6Interface('::1/128')),
- '::1/128')
+ self.assertEqual(
+ str(ipaddress.IPv6Interface('::1/128')),
+ '::1/128')
def testSlash0Constructor(self):
- self.assertEqual(str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')),
- '1.2.3.4/0')
+ self.assertEqual(
+ str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')),
+ '1.2.3.4/0')
def testCollapsing(self):
# test only IP addresses including some duplicates
@@ -1289,18 +1482,17 @@
# check that addresses are subsumed properly.
collapsed = ipaddress.collapse_addresses(
[ip1, ip2, ip3, ip4, ip5, ip6])
- self.assertEqual(list(collapsed),
- [ipaddress.IPv4Network('1.1.1.0/30'),
- ipaddress.IPv4Network('1.1.1.4/32')])
+ self.assertEqual(
+ list(collapsed),
+ [ipaddress.IPv4Network('1.1.1.0/30'),
+ ipaddress.IPv4Network('1.1.1.4/32')])
# test a mix of IP addresses and networks including some duplicates
ip1 = ipaddress.IPv4Address('1.1.1.0')
ip2 = ipaddress.IPv4Address('1.1.1.1')
ip3 = ipaddress.IPv4Address('1.1.1.2')
ip4 = ipaddress.IPv4Address('1.1.1.3')
- #ip5 = ipaddress.IPv4Interface('1.1.1.4/30')
- #ip6 = ipaddress.IPv4Interface('1.1.1.4/30')
- # check that addresses are subsumed properly.
+ # check that addreses are subsumed properly.
collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4])
self.assertEqual(list(collapsed),
[ipaddress.IPv4Network('1.1.1.0/30')])
@@ -1314,9 +1506,11 @@
# stored in no particular order b/c we want CollapseAddr to call
# [].sort
ip6 = ipaddress.IPv4Network('1.1.0.0/22')
- # check that addresses are subsumed properly.
- collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4, ip5,
- ip6])
+
+ # check that addreses are subsumed properly.
+ collapsed = ipaddress.collapse_addresses(
+ [ip1, ip2, ip3, ip4, ip5, ip6])
+
self.assertEqual(list(collapsed),
[ipaddress.IPv4Network('1.1.0.0/22'),
ipaddress.IPv4Network('1.1.4.0/24')])
@@ -1328,15 +1522,15 @@
# test same IP networks
ip_same1 = ip_same2 = ipaddress.IPv4Network('1.1.1.1/32')
- self.assertEqual(list(ipaddress.collapse_addresses(
- [ip_same1, ip_same2])),
- [ip_same1])
+ self.assertEqual(
+ list(ipaddress.collapse_addresses([ip_same1, ip_same2])),
+ [ip_same1])
# test same IP addresses
ip_same1 = ip_same2 = ipaddress.IPv4Address('1.1.1.1')
- self.assertEqual(list(ipaddress.collapse_addresses(
- [ip_same1, ip_same2])),
- [ipaddress.ip_network('1.1.1.1/32')])
+ self.assertEqual(
+ list(ipaddress.collapse_addresses([ip_same1, ip_same2])),
+ [ipaddress.ip_network('1.1.1.1/32')])
ip1 = ipaddress.IPv6Network('2001::/100')
ip2 = ipaddress.IPv6Network('2001::/120')
ip3 = ipaddress.IPv6Network('2001::/96')
@@ -1346,20 +1540,18 @@
# the toejam test
addr_tuples = [
- (ipaddress.ip_address('1.1.1.1'),
- ipaddress.ip_address('::1')),
- (ipaddress.IPv4Network('1.1.0.0/24'),
- ipaddress.IPv6Network('2001::/120')),
- (ipaddress.IPv4Network('1.1.0.0/32'),
- ipaddress.IPv6Network('2001::/128')),
+ (ipaddress.ip_address('1.1.1.1'),
+ ipaddress.ip_address('::1')),
+ (ipaddress.IPv4Network('1.1.0.0/24'),
+ ipaddress.IPv6Network('2001::/120')),
+ (ipaddress.IPv4Network('1.1.0.0/32'),
+ ipaddress.IPv6Network('2001::/128')),
]
for ip1, ip2 in addr_tuples:
self.assertRaises(TypeError, ipaddress.collapse_addresses,
[ip1, ip2])
def testSummarizing(self):
- #ip = ipaddress.ip_address
- #ipnet = ipaddress.ip_network
summarize = ipaddress.summarize_address_range
ip1 = ipaddress.ip_address('1.1.1.0')
ip2 = ipaddress.ip_address('1.1.1.255')
@@ -1525,10 +1717,10 @@
unsorted = [ip4, ip1, ip3, ip2]
unsorted.sort()
self.assertEqual(sorted, unsorted)
- self.assertIs(ip1.__lt__(ipaddress.ip_address('10.10.10.0')),
- NotImplemented)
- self.assertIs(ip2.__lt__(ipaddress.ip_address('10.10.10.0')),
- NotImplemented)
+ self.assertRaises(TypeError, ip1.__lt__,
+ ipaddress.ip_address('10.10.10.0'))
+ self.assertRaises(TypeError, ip2.__lt__,
+ ipaddress.ip_address('10.10.10.0'))
# <=, >=
self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
@@ -1536,7 +1728,7 @@
self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
ipaddress.ip_network('1.1.1.2'))
self.assertFalse(ipaddress.ip_network('1.1.1.2') <=
- ipaddress.ip_network('1.1.1.1'))
+ ipaddress.ip_network('1.1.1.1'))
self.assertTrue(ipaddress.ip_network('::1') <=
ipaddress.ip_network('::1'))
self.assertTrue(ipaddress.ip_network('::1') <=
@@ -1570,10 +1762,10 @@
def testIPv6AddressTooLarge(self):
# RFC4291 2.5.5.2
self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
- ipaddress.ip_address('::FFFF:c000:201'))
+ ipaddress.ip_address('::FFFF:c000:201'))
# RFC4291 2.2 (part 3) x::d.d.d.d
self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
- ipaddress.ip_address('FFFF::c000:201'))
+ ipaddress.ip_address('FFFF::c000:201'))
def testIPVersion(self):
self.assertEqual(self.ipv4_address.version, 4)
@@ -1592,8 +1784,8 @@
b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
b'\x02\x00\x00\x00\x00\x00\x00\x01')
self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed,
- b'\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
- + b'\x00' * 6)
+ b'\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff' +
+ b'\x00' * 6)
self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
b'\x00' * 6 + b'\x00\x01' + b'\x00' * 8)
@@ -1610,39 +1802,40 @@
def testReservedIpv4(self):
# test networks
self.assertEqual(True, ipaddress.ip_interface(
- '224.1.1.1/31').is_multicast)
+ '224.1.1.1/31').is_multicast)
self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast)
self.assertEqual(True, ipaddress.ip_network('240.0.0.0').is_reserved)
self.assertEqual(True, ipaddress.ip_interface(
- '192.168.1.1/17').is_private)
+ '192.168.1.1/17').is_private)
self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private)
self.assertEqual(True, ipaddress.ip_network(
- '10.255.255.255').is_private)
+ '10.255.255.255').is_private)
self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private)
self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_reserved)
self.assertEqual(True, ipaddress.ip_network(
- '172.31.255.255').is_private)
+ '172.31.255.255').is_private)
self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private)
self.assertEqual(True,
ipaddress.ip_network('169.254.1.0/24').is_link_local)
- self.assertEqual(True,
- ipaddress.ip_interface(
- '169.254.100.200/24').is_link_local)
- self.assertEqual(False,
- ipaddress.ip_interface(
- '169.255.100.200/24').is_link_local)
+ self.assertEqual(
+ True,
+ ipaddress.ip_interface('169.254.100.200/24').is_link_local)
+ self.assertEqual(
+ False,
+ ipaddress.ip_interface('169.255.100.200/24').is_link_local)
- self.assertEqual(True,
- ipaddress.ip_network(
- '127.100.200.254/32').is_loopback)
+ self.assertEqual(
+ True,
+ ipaddress.ip_network('127.100.200.254/32').is_loopback)
self.assertEqual(True, ipaddress.ip_network(
- '127.42.0.0/16').is_loopback)
+ '127.42.0.0/16').is_loopback)
self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback)
self.assertEqual(False,
ipaddress.ip_network('100.64.0.0/10').is_private)
- self.assertEqual(False, ipaddress.ip_network('100.64.0.0/10').is_global)
+ self.assertEqual(
+ False, ipaddress.ip_network('100.64.0.0/10').is_global)
self.assertEqual(True,
ipaddress.ip_network('192.0.2.128/25').is_private)
@@ -1660,15 +1853,11 @@
self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private)
self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private)
self.assertEqual(True, ipaddress.ip_address(
- '10.255.255.255').is_private)
+ '10.255.255.255').is_private)
self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private)
self.assertEqual(True, ipaddress.ip_address(
- '172.31.255.255').is_private)
+ '172.31.255.255').is_private)
self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
- self.assertFalse(ipaddress.ip_address('192.0.0.0').is_global)
- self.assertTrue(ipaddress.ip_address('192.0.0.9').is_global)
- self.assertTrue(ipaddress.ip_address('192.0.0.10').is_global)
- self.assertFalse(ipaddress.ip_address('192.0.0.255').is_global)
self.assertEqual(True,
ipaddress.ip_address('169.254.100.200').is_link_local)
@@ -1679,70 +1868,36 @@
self.assertFalse(ipaddress.ip_address('203.0.113.1').is_global)
self.assertEqual(True,
- ipaddress.ip_address('127.100.200.254').is_loopback)
+ ipaddress.ip_address('127.100.200.254').is_loopback)
self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback)
self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback)
self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified)
- def testPrivateNetworks(self):
- self.assertEqual(True, ipaddress.ip_network("0.0.0.0/0").is_private)
- self.assertEqual(False, ipaddress.ip_network("1.0.0.0/8").is_private)
-
- self.assertEqual(True, ipaddress.ip_network("0.0.0.0/8").is_private)
- self.assertEqual(True, ipaddress.ip_network("10.0.0.0/8").is_private)
- self.assertEqual(True, ipaddress.ip_network("127.0.0.0/8").is_private)
- self.assertEqual(True, ipaddress.ip_network("169.254.0.0/16").is_private)
- self.assertEqual(True, ipaddress.ip_network("172.16.0.0/12").is_private)
- self.assertEqual(True, ipaddress.ip_network("192.0.0.0/29").is_private)
- self.assertEqual(False, ipaddress.ip_network("192.0.0.9/32").is_private)
- self.assertEqual(True, ipaddress.ip_network("192.0.0.170/31").is_private)
- self.assertEqual(True, ipaddress.ip_network("192.0.2.0/24").is_private)
- self.assertEqual(True, ipaddress.ip_network("192.168.0.0/16").is_private)
- self.assertEqual(True, ipaddress.ip_network("198.18.0.0/15").is_private)
- self.assertEqual(True, ipaddress.ip_network("198.51.100.0/24").is_private)
- self.assertEqual(True, ipaddress.ip_network("203.0.113.0/24").is_private)
- self.assertEqual(True, ipaddress.ip_network("240.0.0.0/4").is_private)
- self.assertEqual(True, ipaddress.ip_network("255.255.255.255/32").is_private)
-
- self.assertEqual(False, ipaddress.ip_network("::/0").is_private)
- self.assertEqual(False, ipaddress.ip_network("::ff/128").is_private)
-
- self.assertEqual(True, ipaddress.ip_network("::1/128").is_private)
- self.assertEqual(True, ipaddress.ip_network("::/128").is_private)
- self.assertEqual(True, ipaddress.ip_network("::ffff:0:0/96").is_private)
- self.assertEqual(True, ipaddress.ip_network("100::/64").is_private)
- self.assertEqual(True, ipaddress.ip_network("2001:2::/48").is_private)
- self.assertEqual(False, ipaddress.ip_network("2001:3::/48").is_private)
- self.assertEqual(True, ipaddress.ip_network("2001:db8::/32").is_private)
- self.assertEqual(True, ipaddress.ip_network("2001:10::/28").is_private)
- self.assertEqual(True, ipaddress.ip_network("fc00::/7").is_private)
- self.assertEqual(True, ipaddress.ip_network("fe80::/10").is_private)
-
def testReservedIpv6(self):
self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast)
- self.assertEqual(True, ipaddress.ip_network(2**128 - 1).is_multicast)
+ self.assertEqual(True, ipaddress.ip_network(2 ** 128 - 1).is_multicast)
self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast)
self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local)
self.assertEqual(True, ipaddress.ip_network(
- 'feff:ffff:ffff:ffff::').is_site_local)
+ 'feff:ffff:ffff:ffff::').is_site_local)
self.assertEqual(False, ipaddress.ip_network(
- 'fbf:ffff::').is_site_local)
+ 'fbf:ffff::').is_site_local)
self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local)
self.assertEqual(True, ipaddress.ip_network('fc00::').is_private)
self.assertEqual(True, ipaddress.ip_network(
- 'fc00:ffff:ffff:ffff::').is_private)
+ 'fc00:ffff:ffff:ffff::').is_private)
self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private)
self.assertEqual(False, ipaddress.ip_network('fe00::').is_private)
self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local)
self.assertEqual(True, ipaddress.ip_network(
- 'febf:ffff::').is_link_local)
+ 'febf:ffff::').is_link_local)
self.assertEqual(False, ipaddress.ip_network(
- 'fe7f:ffff::').is_link_local)
+ 'fe7f:ffff::').is_link_local)
self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local)
self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback)
@@ -1760,28 +1915,28 @@
ipaddress.ip_network('200::1/128').is_global)
# test addresses
self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast)
- self.assertEqual(True, ipaddress.ip_address(2**128 - 1).is_multicast)
+ self.assertEqual(True, ipaddress.ip_address(2 ** 128 - 1).is_multicast)
self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast)
self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local)
self.assertEqual(True, ipaddress.ip_address(
- 'feff:ffff:ffff:ffff::').is_site_local)
+ 'feff:ffff:ffff:ffff::').is_site_local)
self.assertEqual(False, ipaddress.ip_address(
- 'fbf:ffff::').is_site_local)
+ 'fbf:ffff::').is_site_local)
self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local)
self.assertEqual(True, ipaddress.ip_address('fc00::').is_private)
self.assertEqual(True, ipaddress.ip_address(
- 'fc00:ffff:ffff:ffff::').is_private)
+ 'fc00:ffff:ffff:ffff::').is_private)
self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private)
self.assertEqual(False, ipaddress.ip_address('fe00::').is_private)
self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local)
self.assertEqual(True, ipaddress.ip_address(
- 'febf:ffff::').is_link_local)
+ 'febf:ffff::').is_link_local)
self.assertEqual(False, ipaddress.ip_address(
- 'fe7f:ffff::').is_link_local)
+ 'fe7f:ffff::').is_link_local)
self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local)
self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback)
@@ -1791,28 +1946,14 @@
self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified)
self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified)
- self.assertFalse(ipaddress.ip_address('64:ff9b:1::').is_global)
- self.assertFalse(ipaddress.ip_address('2001::').is_global)
- self.assertTrue(ipaddress.ip_address('2001:1::1').is_global)
- self.assertTrue(ipaddress.ip_address('2001:1::2').is_global)
- self.assertFalse(ipaddress.ip_address('2001:2::').is_global)
- self.assertTrue(ipaddress.ip_address('2001:3::').is_global)
- self.assertFalse(ipaddress.ip_address('2001:4::').is_global)
- self.assertTrue(ipaddress.ip_address('2001:4:112::').is_global)
- self.assertFalse(ipaddress.ip_address('2001:10::').is_global)
- self.assertTrue(ipaddress.ip_address('2001:20::').is_global)
- self.assertTrue(ipaddress.ip_address('2001:30::').is_global)
- self.assertFalse(ipaddress.ip_address('2001:40::').is_global)
- self.assertFalse(ipaddress.ip_address('2002::').is_global)
-
# some generic IETF reserved addresses
self.assertEqual(True, ipaddress.ip_address('100::').is_reserved)
self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved)
def testIpv4Mapped(self):
self.assertEqual(
- ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
- ipaddress.ip_address('192.168.1.1'))
+ ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
+ ipaddress.ip_address('192.168.1.1'))
self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None)
self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped,
ipaddress.ip_address('192.168.1.1'))
@@ -1849,9 +1990,10 @@
self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')),
hash(ipaddress.ip_address('10.1.1.0')))
# i70
- self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')),
- hash(ipaddress.ip_address(
- int(ipaddress.ip_address('1.2.3.4')._ip))))
+ self.assertEqual(
+ hash(ipaddress.ip_address('1.2.3.4')),
+ hash(ipaddress.ip_address(
+ int(ipaddress.ip_address('1.2.3.4')._ip))))
ip1 = ipaddress.ip_address('10.1.1.0')
ip2 = ipaddress.ip_address('1::')
dummy = {}
@@ -1859,14 +2001,14 @@
dummy[self.ipv6_address] = None
dummy[ip1] = None
dummy[ip2] = None
- self.assertIn(self.ipv4_address, dummy)
- self.assertIn(ip2, dummy)
+ self.assertTrue(self.ipv4_address in dummy)
+ self.assertTrue(ip2 in dummy)
def testIPBases(self):
net = self.ipv4_network
self.assertEqual('1.2.3.0/24', net.compressed)
net = self.ipv6_network
- self.assertRaises(ValueError, net._string_from_ip_int, 2**128 + 1)
+ self.assertRaises(ValueError, net._string_from_ip_int, 2 ** 128 + 1)
def testIPv6NetworkHelpers(self):
net = self.ipv6_network
@@ -1918,7 +2060,7 @@
'::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128',
'7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128',
'0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
- }
+ }
for uncompressed, compressed in list(test_addresses.items()):
self.assertEqual(compressed, str(ipaddress.IPv6Interface(
uncompressed)))
@@ -1944,7 +2086,7 @@
addr2 = ipaddress.IPv6Address('2001:db8::1')
self.assertEqual('1.0.0.127.in-addr.arpa', addr1.reverse_pointer)
self.assertEqual('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',
+ 'b.d.0.1.0.0.2.ip6.arpa',
addr2.reverse_pointer)
def testIntRepresentation(self):
@@ -1974,9 +2116,9 @@
def testNetworkElementCaching(self):
# V4 - make sure we're empty
- self.assertNotIn('network_address', self.ipv4_network._cache)
- self.assertNotIn('broadcast_address', self.ipv4_network._cache)
- self.assertNotIn('hostmask', self.ipv4_network._cache)
+ self.assertFalse('network_address' in self.ipv4_network._cache)
+ self.assertFalse('broadcast_address' in self.ipv4_network._cache)
+ self.assertFalse('hostmask' in self.ipv4_network._cache)
# V4 - populate and test
self.assertEqual(self.ipv4_network.network_address,
@@ -1987,12 +2129,12 @@
ipaddress.IPv4Address('0.0.0.255'))
# V4 - check we're cached
- self.assertIn('broadcast_address', self.ipv4_network._cache)
- self.assertIn('hostmask', self.ipv4_network._cache)
+ self.assertTrue('broadcast_address' in self.ipv4_network._cache)
+ self.assertTrue('hostmask' in self.ipv4_network._cache)
# V6 - make sure we're empty
- self.assertNotIn('broadcast_address', self.ipv6_network._cache)
- self.assertNotIn('hostmask', self.ipv6_network._cache)
+ self.assertFalse('broadcast_address' in self.ipv6_network._cache)
+ self.assertFalse('hostmask' in self.ipv6_network._cache)
# V6 - populate and test
self.assertEqual(self.ipv6_network.network_address,
@@ -2012,10 +2154,11 @@
ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
# V6 - check we're cached
- self.assertIn('broadcast_address', self.ipv6_network._cache)
- self.assertIn('hostmask', self.ipv6_network._cache)
- self.assertIn('broadcast_address', self.ipv6_interface.network._cache)
- self.assertIn('hostmask', self.ipv6_interface.network._cache)
+ self.assertTrue('broadcast_address' in self.ipv6_network._cache)
+ self.assertTrue('hostmask' in self.ipv6_network._cache)
+ self.assertTrue(
+ 'broadcast_address' in self.ipv6_interface.network._cache)
+ self.assertTrue('hostmask' in self.ipv6_interface.network._cache)
def testTeredo(self):
# stolen from wikipedia
@@ -2054,5 +2197,107 @@
ipv6_address2 = ipaddress.IPv6Interface("2001:658:22a:cafe:200:0:0:2")
self.assertNotEqual(ipv6_address1.__hash__(), ipv6_address2.__hash__())
+
+# Monkey-patch test runner
+if not hasattr(BaseTestCase, 'assertRaisesRegex'):
+ class _AssertRaisesRegex(object):
+ def __init__(self, expected_exception, expected_regex):
+ self.expected = expected_exception
+ self.expected_regex = re.compile(expected_regex)
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, tb):
+ if exc_type is None:
+ try:
+ exc_name = self.expected.__name__
+ except AttributeError:
+ exc_name = str(self.expected)
+ if self.obj_name:
+ self._raiseFailure("{} not raised by {}".format(
+ exc_name, self.obj_name))
+ else:
+ self._raiseFailure("{} not raised".format(exc_name))
+ if not issubclass(exc_type, self.expected):
+ # let unexpected exceptions pass through
+ return False
+ self.exception = exc_value
+ if self.expected_regex is None:
+ return True
+
+ expected_regex = self.expected_regex
+ if not expected_regex.search(str(exc_value)):
+ raise AssertionError('"{0}" does not match "{1}"'.format(
+ expected_regex.pattern, str(exc_value)))
+ return True
+
+ BaseTestCase.assertRaisesRegex = _AssertRaisesRegex
+ IpaddrUnitTest.assertRaisesRegex = _AssertRaisesRegex
+if not hasattr(BaseTestCase, 'assertIn'):
+ def _assertIn(self, o, iterable):
+ self.assertTrue(o in iterable)
+
+ def _assertNotIn(self, o, iterable):
+ self.assertFalse(o in iterable)
+ BaseTestCase.assertIn = _assertIn
+ BaseTestCase.assertNotIn = _assertNotIn
+ IpaddrUnitTest.assertIn = _assertIn
+ IpaddrUnitTest.assertNotIn = _assertNotIn
+ ComparisonTests.assertIn = _assertIn
+ ComparisonTests.assertNotIn = _assertNotIn
+if not hasattr(BaseTestCase, 'subTest'):
+ class _SubTest(object):
+ def __init__(*a, **kw):
+ pass
+
+ def __enter__(*a):
+ pass
+
+ def __exit__(*a):
+ pass
+ BaseTestCase.subTest = _SubTest
+
+
+# Test for https://github.com/phihag/ipaddress/pull/6
+class Python2RangeTest(unittest.TestCase):
+ def test_network_hosts(self):
+ net = ipaddress.ip_network('::/0')
+ next(net.hosts()) # This should not throw OverflowError
+
+ def test_network_iter(self):
+ net = ipaddress.ip_network('::/0')
+ next(iter(net)) # This should not throw OverflowError
+
+
+class CompatTest(unittest.TestCase):
+ def test_bit_length(self):
+ self.assertEqual((0).bit_length(), 0)
+ self.assertEqual((1).bit_length(), 1)
+ self.assertEqual((2).bit_length(), 2)
+ self.assertEqual((3).bit_length(), 2)
+ self.assertEqual((4).bit_length(), 3)
+
+
+class SingleIssuesTest(BaseTestCase):
+ # https://github.com/phihag/ipaddress/issues/14
+ def test_issue_14(self):
+ self.assertTrue(ipaddress.ip_address('127.0.0.1').is_private)
+
+ def test_issue_18(self):
+ net1 = ipaddress.ip_network("192.0.2.0/24")
+ net2 = ipaddress.ip_network("192.0.2.112/29")
+ self.assertFalse(net1.subnet_of(net2))
+ self.assertTrue(net1.supernet_of(net2))
+ self.assertTrue(net2.subnet_of(net1))
+ self.assertFalse(net2.supernet_of(net1))
+
+ def test_issue_48(self):
+ v6net = ipaddress.ip_network('::/0')
+ v4net = ipaddress.ip_network('1.2.3.0/24')
+ with self.assertRaisesRegex(TypeError, r'are not of the same version'):
+ v6net.subnet_of(v4net)
+
+
if __name__ == '__main__':
unittest.main()
