Initial commit: mwhois with SCION AS support and decimal AS conversion

Based on mwhois by Antonios A. Chariton
Modifications for SCION AS support by Olaf Baumert, Axpo Systems AG

netaddr/LICENSE

@@ -0,0 +1,36 @@
+Here are the licenses applicable to the use of the netaddr library.
+
+-------
+netaddr
+-------
+
+COPYRIGHT AND LICENSE
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright 
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of David P. D. Moss nor the names of contributors
+  may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

netaddr/__init__.py

@@ -0,0 +1,85 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""A Python library for manipulating IP and EUI network addresses."""
+
+#: Version info (major, minor, maintenance, status)
+VERSION = (0, 7, 13)
+STATUS = ''
+__version__ = '%d.%d.%d' % VERSION[0:3] + STATUS
+
+import sys as _sys
+
+if _sys.version_info[0:2] < (2, 4):
+    raise RuntimeError('Python 2.4.x or higher is required!')
+
+from netaddr.core import AddrConversionError, AddrFormatError, \
+    NotRegisteredError, ZEROFILL, Z, INET_PTON, P, NOHOST, N
+
+from netaddr.ip import IPAddress, IPNetwork, IPRange, all_matching_cidrs, \
+    cidr_abbrev_to_verbose, cidr_exclude, cidr_merge, iprange_to_cidrs, \
+    iter_iprange, iter_unique_ips, largest_matching_cidr, \
+    smallest_matching_cidr, spanning_cidr
+
+from netaddr.ip.sets import IPSet
+
+from netaddr.ip.glob import IPGlob, cidr_to_glob, glob_to_cidrs, \
+    glob_to_iprange, glob_to_iptuple, iprange_to_globs, valid_glob
+
+from netaddr.ip.nmap import valid_nmap_range, iter_nmap_range
+
+from netaddr.ip.rfc1924 import base85_to_ipv6, ipv6_to_base85
+
+from netaddr.eui import EUI, IAB, OUI
+
+from netaddr.strategy.ipv4 import valid_str as valid_ipv4
+
+from netaddr.strategy.ipv6 import valid_str as valid_ipv6, ipv6_compact, \
+    ipv6_full, ipv6_verbose
+
+from netaddr.strategy.eui48 import mac_eui48, mac_unix, mac_unix_expanded, \
+        mac_cisco, mac_bare, mac_pgsql, valid_str as valid_mac
+
+__all__ = [
+    #   Constants.
+    'ZEROFILL', 'Z', 'INET_PTON', 'P', 'NOHOST', 'N',
+
+    #   Custom Exceptions.
+    'AddrConversionError', 'AddrFormatError', 'NotRegisteredError',
+
+    #   IP classes.
+    'IPAddress', 'IPNetwork', 'IPRange', 'IPSet',
+
+    #   IPv6 dialect classes.
+    'ipv6_compact', 'ipv6_full', 'ipv6_verbose',
+
+    #   IP functions and generators.
+    'all_matching_cidrs', 'cidr_abbrev_to_verbose', 'cidr_exclude',
+    'cidr_merge', 'iprange_to_cidrs', 'iter_iprange', 'iter_unique_ips',
+    'largest_matching_cidr', 'smallest_matching_cidr', 'spanning_cidr',
+
+    #   IP globbing class.
+    'IPGlob',
+
+    #   IP globbing functions.
+    'cidr_to_glob', 'glob_to_cidrs', 'glob_to_iprange', 'glob_to_iptuple',
+    'iprange_to_globs',
+
+    #   IEEE EUI classes.
+    'EUI', 'IAB', 'OUI',
+
+    #   EUI-48 (MAC) dialect classes.
+    'mac_bare', 'mac_cisco', 'mac_eui48', 'mac_pgsql', 'mac_unix',
+    'mac_unix_expanded',
+
+    #   Validation functions.
+    'valid_ipv4', 'valid_ipv6', 'valid_glob', 'valid_mac',
+
+    #   nmap-style range functions.
+    'valid_nmap_range', 'iter_nmap_range',
+
+    #   RFC 1924 functions.
+    'base85_to_ipv6', 'ipv6_to_base85',
+]

netaddr/compat.py

@@ -0,0 +1,92 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+Compatibility wrappers providing uniform behaviour for Python code required to
+run under both Python 2.x and 3.x.
+
+All operations emulate 2.x behaviour where applicable.
+"""
+import sys as _sys
+
+if _sys.version_info[0] == 3:
+    # Python 3.x specific logic.
+    _sys_maxint = _sys.maxsize
+
+    _int_type = int
+
+    _str_type = str
+
+    _is_str = lambda x: isinstance(x, (str, type(''.encode())))
+
+    _is_int = lambda x: isinstance(x, int)
+
+    _callable = lambda x: hasattr(x, '__call__')
+
+    _func_doc = lambda x: x.__doc__
+
+    _dict_keys = lambda x: list(x.keys())
+
+    _dict_items = lambda x: list(x.items())
+
+    _iter_dict_keys = lambda x: x.keys()
+
+    def _bytes_join(*args): return ''.encode().join(*args)
+
+    def _zip(*args): return list(zip(*args))
+
+    def _range(*args, **kwargs): return list(range(*args, **kwargs))
+
+    _iter_range = range
+
+    def _func_name(f, name=None):
+        if name is not None: f.__name__ = name
+        else: return f.__name__
+
+    def _func_doc(f, docstring=None):
+        if docstring is not None: f.__doc__ = docstring
+        else: return f.__doc__
+
+elif  _sys.version_info[0:2] > [2, 3]:
+    # Python 2.4 or higher.
+    _sys_maxint = _sys.maxint
+
+    _int_type = (int, long)
+
+    _str_type = basestring
+
+    _is_str = lambda x: isinstance(x, basestring)
+
+    _is_int = lambda x: isinstance(x, (int, long))
+
+    _callable = lambda x: callable(x)
+
+    _dict_keys = lambda x: x.keys()
+
+    _dict_items = lambda x: x.items()
+
+    _iter_dict_keys = lambda x: iter(x.keys())
+
+    def _bytes_join(*args): return ''.join(*args)
+
+    def _zip(*args): return zip(*args)
+
+    def _range(*args, **kwargs): return range(*args, **kwargs)
+
+    _iter_range = xrange
+
+    def _func_name(f, name=None):
+        if name is not None: f.func_name = name
+        else: return f.func_name
+
+    def _func_doc(f, docstring=None):
+        if docstring is not None: f.func_doc = docstring
+        else: return f.func_doc
+
+else:
+    # Unsupported versions.
+    raise RuntimeError(
+        'this module only supports Python 2.4.x or higher (including 3.x)!')
+

netaddr/core.py

@@ -0,0 +1,223 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""Common code shared between various netaddr sub modules"""
+
+import sys as _sys
+import pprint as _pprint
+
+from netaddr.compat import _callable, _iter_dict_keys
+
+#: True if platform is natively big endian, False otherwise.
+BIG_ENDIAN_PLATFORM = _sys.byteorder == 'big'
+
+#:  Use inet_pton() semantics instead of inet_aton() when parsing IPv4.
+P = INET_PTON = 1
+
+#:  Remove any preceding zeros from IPv4 address octets before parsing.
+Z = ZEROFILL = 2
+
+#:  Remove any host bits found to the right of an applied CIDR prefix.
+N = NOHOST = 4
+
+#-----------------------------------------------------------------------------
+#   Custom exceptions.
+#-----------------------------------------------------------------------------
+class AddrFormatError(Exception):
+    """
+    An Exception indicating a network address is not correctly formatted.
+    """
+    pass
+
+
+class AddrConversionError(Exception):
+    """
+    An Exception indicating a failure to convert between address types or
+    notations.
+    """
+    pass
+
+
+class NotRegisteredError(Exception):
+    """
+    An Exception indicating that an OUI or IAB was not found in the IEEE
+    Registry.
+    """
+    pass
+
+
+try:
+    a = 42
+    a.bit_length()
+    # No exception, must be Python 2.7 or 3.1+ -> can use bit_length()
+    def num_bits(int_val):
+        """
+        :param int_val: an unsigned integer.
+
+        :return: the minimum number of bits needed to represent value provided.
+        """
+        return int_val.bit_length()
+except AttributeError:
+    # a.bit_length() excepted, must be an older Python version.
+    def num_bits(int_val):
+        """
+        :param int_val: an unsigned integer.
+
+        :return: the minimum number of bits needed to represent value provided.
+        """
+        numbits = 0
+        while int_val:
+            numbits += 1
+            int_val >>= 1
+        return numbits
+
+
+class Subscriber(object):
+    """
+    An abstract class defining the interface expected by a Publisher.
+    """
+    def update(self, data):
+        """
+        A callback method used by a Publisher to notify this Subscriber about
+        updates.
+
+        :param data: a Python object containing data provided by Publisher.
+        """
+        raise NotImplementedError('cannot invoke virtual method!')
+
+
+class PrettyPrinter(Subscriber):
+    """
+    A concrete Subscriber that employs the pprint in the standard library to
+    format all data from updates received, writing them to a file-like
+    object.
+
+    Useful as a debugging aid.
+    """
+    def __init__(self, fh=_sys.stdout, write_eol=True):
+        """
+        Constructor.
+
+        :param fh: a file-like object to write updates to.
+            Default: sys.stdout.
+
+
+        :param write_eol: if ``True`` this object will write newlines to
+            output, if ``False`` it will not.
+        """
+        self.fh = fh
+        self.write_eol = write_eol
+
+    def update(self, data):
+        """
+        A callback method used by a Publisher to notify this Subscriber about
+        updates.
+
+        :param data: a Python object containing data provided by Publisher.
+        """
+        self.fh.write(_pprint.pformat(data))
+        if self.write_eol:
+            self.fh.write("\n")
+
+
+class Publisher(object):
+    """
+    A 'push' Publisher that maintains a list of Subscriber objects notifying
+    them of state changes by passing them update data when it encounter events
+    of interest.
+    """
+    def __init__(self):
+        """Constructor"""
+        self.subscribers = []
+
+    def attach(self, subscriber):
+        """
+        Add a new subscriber.
+
+        :param subscriber: a new object that implements the Subscriber object
+            interface.
+        """
+        if hasattr(subscriber, 'update') and \
+           _callable(eval('subscriber.update')):
+            if subscriber not in self.subscribers:
+                self.subscribers.append(subscriber)
+        else:
+            raise TypeError('%r does not support required interface!' \
+                % subscriber)
+
+    def detach(self, subscriber):
+        """
+        Remove an existing subscriber.
+
+        :param subscriber: a new object that implements the Subscriber object
+            interface.
+        """
+        try:
+            self.subscribers.remove(subscriber)
+        except ValueError:
+            pass
+
+    def notify(self, data):
+        """
+        Send update data to to all registered Subscribers.
+
+        :param data: the data to be passed to each registered Subscriber.
+        """
+        for subscriber in self.subscribers:
+            subscriber.update(data)
+
+
+class DictDotLookup(object):
+    """
+    Creates objects that behave much like a dictionaries, but allow nested
+    key access using object '.' (dot) lookups.
+
+    Recipe 576586: Dot-style nested lookups over dictionary based data
+    structures - http://code.activestate.com/recipes/576586/
+
+    """
+    def __init__(self, d):
+        for k in d:
+            if isinstance(d[k], dict):
+                self.__dict__[k] = DictDotLookup(d[k])
+            elif isinstance(d[k], (list, tuple)):
+                l = []
+                for v in d[k]:
+                    if isinstance(v, dict):
+                        l.append(DictDotLookup(v))
+                    else:
+                        l.append(v)
+                self.__dict__[k] = l
+            else:
+                self.__dict__[k] = d[k]
+
+    def __getitem__(self, name):
+        if name in self.__dict__:
+            return self.__dict__[name]
+
+    def __iter__(self):
+        return _iter_dict_keys(self.__dict__)
+
+    def __repr__(self):
+        return _pprint.pformat(self.__dict__)
+
+
+def dos2unix(filename):
+    """
+    Replace DOS line endings (CRLF) with UNIX line endings (LF) in file.
+
+    """
+    fh = open(filename, "rb")
+    data = fh.read()
+    fh.close()
+
+    if '\0' in data:
+        raise ValueError('file contains binary data: %s!' % filename)
+
+    newdata = data.replace("\r\n".encode(), "\n".encode())
+    if newdata != data:
+        f = open(filename, "wb")
+        f.write(newdata)
+        f.close()

netaddr/eui/__init__.py

@@ -0,0 +1,697 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+Classes and functions for dealing with MAC addresses, EUI-48, EUI-64, OUI, IAB
+identifiers.
+"""
+
+from netaddr.core import NotRegisteredError, AddrFormatError, \
+    AddrConversionError, Subscriber, Publisher, DictDotLookup
+from netaddr.strategy import eui48 as _eui48, eui64 as _eui64
+from netaddr.strategy.eui48 import mac_eui48
+from netaddr.ip import IPAddress
+
+from netaddr.compat import _is_int, _is_str
+
+
+class BaseIdentifier(object):
+    """Base class for all IEEE identifiers."""
+    __slots__ = ('_value',)
+
+    def __init__(self):
+        self._value = None
+
+    def __int__(self):
+        """:return: integer value of this identifier"""
+        return self._value
+
+    def __long__(self):
+        """:return: integer value of this identifier"""
+        return self._value
+
+    def __oct__(self):
+        """:return: octal string representation of this identifier."""
+        #   Python 2.x only.
+        if self._value == 0:
+            return '0'
+        return '0%o' % self._value
+
+    def __hex__(self):
+        """:return: hexadecimal string representation of this identifier."""
+        #   Python 2.x only.
+        return '0x%x' % self._value
+
+    def __index__(self):
+        """
+        :return: return the integer value of this identifier when passed to
+            hex(), oct() or bin().
+        """
+        #   Python 3.x only.
+        return self._value
+
+    def __eq__(self, other):
+        """
+        :return: ``True`` if this BaseIdentifier object is numerically the
+            same as other, ``False`` otherwise.
+        """
+        try:
+            return (self.__class__, self._value) == (other.__class__, other._value)
+        except AttributeError:
+            return NotImplemented
+
+
+
+class OUI(BaseIdentifier):
+    """
+    An individual IEEE OUI (Organisationally Unique Identifier).
+
+    For online details see - http://standards.ieee.org/regauth/oui/
+
+    """
+    __slots__ = ('records',)
+
+    def __init__(self, oui):
+        """
+        Constructor
+
+        :param oui: an OUI string ``XX-XX-XX`` or an unsigned integer. \
+            Also accepts and parses full MAC/EUI-48 address strings (but not \
+            MAC/EUI-48 integers)!
+        """
+        super(OUI, self).__init__()
+
+        #   Lazy loading of IEEE data structures.
+        from netaddr.eui import ieee
+
+        self.records = []
+
+        if isinstance(oui, str):
+            #TODO: Improve string parsing here.
+            #TODO: Accept full MAC/EUI-48 addressses as well as XX-XX-XX
+            #TODO: and just take /16 (see IAB for details)
+            self._value = int(oui.replace('-', ''), 16)
+        elif _is_int(oui):
+            if 0 <= oui <= 0xffffff:
+                self._value = oui
+            else:
+                raise ValueError('OUI int outside expected range: %r' % oui)
+        else:
+            raise TypeError('unexpected OUI format: %r' % oui)
+
+        #   Discover offsets.
+        if self._value in ieee.OUI_INDEX:
+            fh = open(ieee.OUI_REGISTRY)
+            for (offset, size) in ieee.OUI_INDEX[self._value]:
+                fh.seek(offset)
+                data = fh.read(size)
+                self._parse_data(data, offset, size)
+            fh.close()
+        else:
+            raise NotRegisteredError('OUI %r not registered!' % oui)
+
+    def __getstate__(self):
+        """:returns: Pickled state of an `OUI` object."""
+        return self._value, self.records
+
+    def __setstate__(self, state):
+        """:param state: data used to unpickle a pickled `OUI` object."""
+        self._value, self.records = state
+
+    def _parse_data(self, data, offset, size):
+        """Returns a dict record from raw OUI record data"""
+        record = {
+            'idx': 0,
+            'oui': '',
+            'org': '',
+            'address' : [],
+            'offset': offset,
+            'size': size,
+        }
+
+        for line in data.split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+
+            if '(hex)' in line:
+                record['idx'] = self._value
+                record['org'] = line.split(None, 2)[2]
+                record['oui'] = str(self)
+            elif '(base 16)' in line:
+                continue
+            else:
+                record['address'].append(line)
+
+        self.records.append(record)
+
+    @property
+    def reg_count(self):
+        """Number of registered organisations with this OUI"""
+        return len(self.records)
+
+    def registration(self, index=0):
+        """
+        The IEEE registration details for this OUI.
+
+        :param index: the index of record (may contain multiple registrations)
+            (Default: 0 - first registration)
+
+        :return: Objectified Python data structure containing registration
+            details.
+        """
+        return DictDotLookup(self.records[index])
+
+    def __str__(self):
+        """:return: string representation of this OUI"""
+        int_val = self._value
+        return "%02X-%02X-%02X" % (
+                (int_val >> 16) & 0xff,
+                (int_val >> 8) & 0xff,
+                int_val & 0xff)
+
+    def __repr__(self):
+        """:return: executable Python string to recreate equivalent object."""
+        return "OUI('%s')" % self
+
+
+class IAB(BaseIdentifier):
+    """
+    An individual IEEE IAB (Individual Address Block) identifier.
+
+    For online details see - http://standards.ieee.org/regauth/oui/
+
+    """
+    __slots__ = ('record',)
+
+    @staticmethod
+    def split_iab_mac(eui_int, strict=False):
+        """
+        :param eui_int: a MAC IAB as an unsigned integer.
+
+        :param strict: If True, raises a ValueError if the last 12 bits of
+            IAB MAC/EUI-48 address are non-zero, ignores them otherwise.
+            (Default: False)
+        """
+        if 0x50c2000 <= eui_int <= 0x50c2fff:
+            return eui_int, 0
+
+        user_mask = 2 ** 12 - 1
+        iab_mask = (2 ** 48 - 1) ^ user_mask
+        iab_bits = eui_int >> 12
+        user_bits = (eui_int | iab_mask) - iab_mask
+
+        if 0x50c2000 <= iab_bits <= 0x50c2fff:
+            if strict and user_bits != 0:
+                raise ValueError('%r is not a strict IAB!' % hex(user_bits))
+        else:
+            raise ValueError('%r is not an IAB address!' % hex(eui_int))
+
+        return iab_bits, user_bits
+
+    def __init__(self, iab, strict=False):
+        """
+        Constructor
+
+        :param iab: an IAB string ``00-50-C2-XX-X0-00`` or an unsigned \
+            integer. This address looks like an EUI-48 but it should not \
+            have any non-zero bits in the last 3 bytes.
+
+        :param strict: If True, raises a ValueError if the last 12 bits \
+            of IAB MAC/EUI-48 address are non-zero, ignores them otherwise. \
+            (Default: False)
+        """
+        super(IAB, self).__init__()
+
+        #   Lazy loading of IEEE data structures.
+        from netaddr.eui import ieee
+
+        self.record = {
+            'idx': 0,
+            'iab': '',
+            'org': '',
+            'address' : [],
+            'offset': 0,
+            'size': 0,
+        }
+
+        if isinstance(iab, str):
+            #TODO: Improve string parsing here.
+            #TODO: '00-50-C2' is actually invalid.
+            #TODO: Should be '00-50-C2-00-00-00' (i.e. a full MAC/EUI-48)
+            int_val = int(iab.replace('-', ''), 16)
+            iab_int, user_int = self.split_iab_mac(int_val,
+                    strict=strict)
+            self._value = iab_int
+        elif _is_int(iab):
+            iab_int, user_int = self.split_iab_mac(iab, strict=strict)
+            self._value = iab_int
+        else:
+            raise TypeError('unexpected IAB format: %r!' % iab)
+
+        #   Discover offsets.
+        if self._value in ieee.IAB_INDEX:
+            fh = open(ieee.IAB_REGISTRY)
+            (offset, size) = ieee.IAB_INDEX[self._value][0]
+            self.record['offset'] = offset
+            self.record['size'] = size
+            fh.seek(offset)
+            data = fh.read(size)
+            self._parse_data(data, offset, size)
+            fh.close()
+        else:
+            raise NotRegisteredError('IAB %r not unregistered!' % iab)
+
+    def __getstate__(self):
+        """:returns: Pickled state of an `IAB` object."""
+        return self._value, self.record
+
+    def __setstate__(self, state):
+        """:param state: data used to unpickle a pickled `IAB` object."""
+        self._value, self.record = state
+
+    def _parse_data(self, data, offset, size):
+        """Returns a dict record from raw IAB record data"""
+        for line in data.split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+
+            if '(hex)' in line:
+                self.record['idx'] = self._value
+                self.record['org'] = line.split(None, 2)[2]
+                self.record['iab'] = str(self)
+            elif '(base 16)' in line:
+                continue
+            else:
+                self.record['address'].append(line)
+
+    def registration(self):
+        """The IEEE registration details for this IAB"""
+        return DictDotLookup(self.record)
+
+    def __str__(self):
+        """:return: string representation of this IAB"""
+        int_val = self._value << 4
+
+        return "%02X-%02X-%02X-%02X-%02X-00" % (
+                (int_val >> 32) & 0xff,
+                (int_val >> 24) & 0xff,
+                (int_val >> 16) & 0xff,
+                (int_val >> 8) & 0xff,
+                int_val & 0xff)
+
+    def __repr__(self):
+        """:return: executable Python string to recreate equivalent object."""
+        return "IAB('%s')" % self
+
+
+class EUI(BaseIdentifier):
+    """
+    An IEEE EUI (Extended Unique Identifier).
+
+    Both EUI-48 (used for layer 2 MAC addresses) and EUI-64 are supported.
+
+    Input parsing for EUI-48 addresses is flexible, supporting many MAC
+    variants.
+
+    """
+    __slots__ = ('_module', '_dialect')
+
+    def __init__(self, addr, version=None, dialect=None):
+        """
+        Constructor.
+
+        :param addr: an EUI-48 (MAC) or EUI-64 address in string format or \
+            an unsigned integer. May also be another EUI object (copy \
+            construction).
+
+        :param version: (optional) the explicit EUI address version, either \
+            48 or 64. Mainly used to distinguish EUI-48 and EUI-64 identifiers \
+            specified as integers which may be numerically equivalent.
+
+        :param dialect: (optional) the mac_* dialect to be used to configure \
+            the formatting of EUI-48 (MAC) addresses.
+        """
+        super(EUI, self).__init__()
+
+        self._module = None
+
+        if isinstance(addr, EUI):
+            #   Copy constructor.
+            if version is not None and version != addr._module.version:
+                raise ValueError('cannot switch EUI versions using '
+                    'copy constructor!')
+            self._module = addr._module
+            self._value = addr._value
+            self.dialect = addr.dialect
+            return
+
+        if version is not None:
+            if version == 48:
+                self._module = _eui48
+            elif version == 64:
+                self._module = _eui64
+            else:
+                raise ValueError('unsupported EUI version %r' % version)
+        else:
+        #   Choose a default version when addr is an integer and version is
+        #   not specified.
+            if _is_int(addr):
+                if 0 <= addr <= 0xffffffffffff:
+                    self._module = _eui48
+                elif 0xffffffffffff < addr <= 0xffffffffffffffff:
+                    self._module = _eui64
+
+        self.value = addr
+
+        #   Choose a dialect for MAC formatting.
+        self.dialect = dialect
+
+    def __getstate__(self):
+        """:returns: Pickled state of an `EUI` object."""
+        return self._value, self._module.version, self.dialect
+
+    def __setstate__(self, state):
+        """
+        :param state: data used to unpickle a pickled `EUI` object.
+
+        """
+        value, version, dialect = state
+
+        self._value = value
+
+        if version == 48:
+            self._module = _eui48
+        elif version == 64:
+            self._module = _eui64
+        else:
+            raise ValueError('unpickling failed for object state: %s' \
+                % str(state))
+
+        self.dialect = dialect
+
+    def _get_value(self):
+        return self._value
+
+    def _set_value(self, value):
+        if self._module is None:
+            #   EUI version is implicit, detect it from value.
+            for module in (_eui48, _eui64):
+                try:
+                    self._value = module.str_to_int(value)
+                    self._module = module
+                    break
+                except AddrFormatError:
+                    try:
+                        if 0 <= int(value) <= module.max_int:
+                            self._value = int(value)
+                            self._module = module
+                            break
+                    except ValueError:
+                        pass
+
+            if self._module is None:
+                raise AddrFormatError('failed to detect EUI version: %r'
+                    % value)
+        else:
+            #   EUI version is explicit.
+            if _is_str(value):
+                try:
+                    self._value = self._module.str_to_int(value)
+                except AddrFormatError:
+                    raise AddrFormatError('address %r is not an EUIv%d'
+                        % (value, self._module.version))
+            else:
+                if 0 <= int(value) <= self._module.max_int:
+                    self._value = int(value)
+                else:
+                    raise AddrFormatError('bad address format: %r' % value)
+
+    value = property(_get_value, _set_value, None,
+        'a positive integer representing the value of this EUI indentifier.')
+
+    def _get_dialect(self):
+        return self._dialect
+
+    def _set_dialect(self, value):
+        if value is None:
+            self._dialect = mac_eui48
+        else:
+            if hasattr(value, 'word_size') and hasattr(value, 'word_fmt'):
+                self._dialect = value
+            else:
+                raise TypeError('custom dialects should subclass mac_eui48!')
+
+    dialect = property(_get_dialect, _set_dialect, None,
+        "a Python class providing support for the interpretation of "
+        "various MAC\n address formats.")
+
+    @property
+    def oui(self):
+        """The OUI (Organisationally Unique Identifier) for this EUI."""
+        if self._module == _eui48:
+            return OUI(self.value >> 24)
+        elif self._module == _eui64:
+            return OUI(self.value >> 40)
+
+    @property
+    def ei(self):
+        """The EI (Extension Identifier) for this EUI"""
+        if self._module == _eui48:
+            return '%02X-%02X-%02X' % tuple(self[3:6])
+        elif self._module == _eui64:
+            return '%02X-%02X-%02X-%02X-%02X' % tuple(self[3:8])
+
+    def is_iab(self):
+        """:return: True if this EUI is an IAB address, False otherwise"""
+        return 0x50c2000 <= (self._value >> 12) <= 0x50c2fff
+
+    @property
+    def iab(self):
+        """
+        If is_iab() is True, the IAB (Individual Address Block) is returned,
+        ``None`` otherwise.
+        """
+        if self.is_iab():
+            return IAB(self._value >> 12)
+
+    @property
+    def version(self):
+        """The EUI version represented by this EUI object."""
+        return self._module.version
+
+    def __getitem__(self, idx):
+        """
+        :return: The integer value of the word referenced by index (both \
+            positive and negative). Raises ``IndexError`` if index is out \
+            of bounds. Also supports Python list slices for accessing \
+            word groups.
+        """
+        if _is_int(idx):
+            #   Indexing, including negative indexing goodness.
+            num_words = self._dialect.num_words
+            if not (-num_words) <= idx <= (num_words - 1):
+                raise IndexError('index out range for address type!')
+            return self._module.int_to_words(self._value, self._dialect)[idx]
+        elif isinstance(idx, slice):
+            words = self._module.int_to_words(self._value, self._dialect)
+            return [words[i] for i in range(*idx.indices(len(words)))]
+        else:
+            raise TypeError('unsupported type %r!' % idx)
+
+    def __setitem__(self, idx, value):
+        """Set the value of the word referenced by index in this address"""
+        if isinstance(idx, slice):
+            #   TODO - settable slices.
+            raise NotImplementedError('settable slices are not supported!')
+
+        if not _is_int(idx):
+            raise TypeError('index not an integer!')
+
+        if not 0 <= idx <= (self._dialect.num_words - 1):
+            raise IndexError('index %d outside address type boundary!' % idx)
+
+        if not _is_int(value):
+            raise TypeError('value not an integer!')
+
+        if not 0 <= value <= self._dialect.max_word:
+            raise IndexError('value %d outside word size maximum of %d bits!'
+                % (value, self._dialect.word_size))
+
+        words = list(self._module.int_to_words(self._value, self._dialect))
+        words[idx] = value
+        self._value = self._module.words_to_int(words)
+
+    def __hash__(self):
+        """:return: hash of this EUI object suitable for dict keys, sets etc"""
+        return hash((self.version, self._value))
+
+    def __eq__(self, other):
+        """
+        :return: ``True`` if this EUI object is numerically the same as other, \
+            ``False`` otherwise.
+        """
+        try:
+            return(self.version, self._value) == (other.version, other._value)
+        except AttributeError:
+            return NotImplemented
+
+    def __ne__(self, other):
+        """
+        :return: ``False`` if this EUI object is numerically the same as the \
+            other, ``True`` otherwise.
+        """
+        try:
+            return(self.version, self._value) != (other.version, other._value)
+        except AttributeError:
+            return NotImplemented
+
+    def __lt__(self, other):
+        """
+        :return: ``True`` if this EUI object is numerically lower in value than \
+            other, ``False`` otherwise.
+        """
+        try:
+            return (self.version, self._value) < (other.version, other._value)
+        except AttributeError:
+            return NotImplemented
+
+    def __le__(self, other):
+        """
+        :return: ``True`` if this EUI object is numerically lower or equal in \
+            value to other, ``False`` otherwise.
+        """
+        try:
+            return(self.version, self._value) <= (other.version, other._value)
+        except AttributeError:
+            return NotImplemented
+
+    def __gt__(self, other):
+        """
+        :return: ``True`` if this EUI object is numerically greater in value \
+            than other, ``False`` otherwise.
+        """
+        try:
+            return (self.version, self._value) > (other.version, other._value)
+        except AttributeError:
+            return NotImplemented
+
+    def __ge__(self, other):
+        """
+        :return: ``True`` if this EUI object is numerically greater or equal \
+            in value to other, ``False`` otherwise.
+        """
+        try:
+            return(self.version, self._value) >= (other.version, other._value)
+        except AttributeError:
+            return NotImplemented
+
+    def bits(self, word_sep=None):
+        """
+        :param word_sep: (optional) the separator to insert between words. \
+            Default: None - use default separator for address type.
+
+        :return: human-readable binary digit string of this address.
+        """
+        return self._module.int_to_bits(self._value, word_sep)
+
+    @property
+    def packed(self):
+        """The value of this EUI address as a packed binary string."""
+        return self._module.int_to_packed(self._value)
+
+    @property
+    def words(self):
+        """A list of unsigned integer octets found in this EUI address."""
+        return self._module.int_to_words(self._value)
+
+    @property
+    def bin(self):
+        """
+        The value of this EUI adddress in standard Python binary
+        representational form (0bxxx). A back port of the format provided by
+        the builtin bin() function found in Python 2.6.x and higher.
+        """
+        return self._module.int_to_bin(self._value)
+
+    def eui64(self):
+        """
+        - If this object represents an EUI-48 it is converted to EUI-64 \
+            as per the standard.
+        - If this object is already an EUI-64, a new, numerically \
+            equivalent object is returned instead.
+
+        :return: The value of this EUI object as a new 64-bit EUI object.
+        """
+        if self.version == 48:
+            # Convert 11:22:33:44:55:66 into 11:22:33:FF:FE:44:55:66.
+            first_three = self._value >> 24
+            last_three = self._value & 0xffffff
+            new_value = (first_three << 40) | 0xfffe000000 | last_three
+        else:
+            # is already a EUI64
+            new_value = self._value
+        return self.__class__(new_value, version=64)
+
+    def modified_eui64(self):
+        """
+        - create a new EUI object with a modified EUI-64 as described in RFC 4291 section 2.5.1
+
+        :return: a new and modified 64-bit EUI object.
+        """
+        # Modified EUI-64 format interface identifiers are formed by inverting
+        # the "u" bit (universal/local bit in IEEE EUI-64 terminology) when
+        # forming the interface identifier from IEEE EUI-64 identifiers.  In
+        # the resulting Modified EUI-64 format, the "u" bit is set to one (1)
+        # to indicate universal scope, and it is set to zero (0) to indicate
+        # local scope.
+        eui64 = self.eui64()
+        eui64._value ^= 0x00000000000000000200000000000000
+        return eui64
+
+    def ipv6(self, prefix):
+        """
+        .. note:: This poses security risks in certain scenarios. \
+            Please read RFC 4941 for details. Reference: RFCs 4291 and 4941.
+
+        :param prefix: ipv6 prefix
+
+        :return: new IPv6 `IPAddress` object based on this `EUI` \
+            using the technique described in RFC 4291.
+        """
+        int_val = int(prefix) + int(self.modified_eui64())
+        return IPAddress(int_val, version=6)
+
+    def ipv6_link_local(self):
+        """
+        .. note:: This poses security risks in certain scenarios. \
+            Please read RFC 4941 for details. Reference: RFCs 4291 and 4941.
+
+        :return: new link local IPv6 `IPAddress` object based on this `EUI` \
+            using the technique described in RFC 4291.
+        """
+        return self.ipv6(0xfe800000000000000000000000000000)
+
+    @property
+    def info(self):
+        """
+        A record dict containing IEEE registration details for this EUI
+        (MAC-48) if available, None otherwise.
+        """
+        data = {'OUI': self.oui.registration()}
+        if self.is_iab():
+            data['IAB'] = self.iab.registration()
+
+        return DictDotLookup(data)
+
+    def __str__(self):
+        """:return: EUI in representational format"""
+        return self._module.int_to_str(self._value, self._dialect)
+
+    def __repr__(self):
+        """:return: executable Python string to recreate equivalent object."""
+        return "EUI('%s')" % self
+

netaddr/eui/ieee.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+#
+#   DISCLAIMER
+#
+#   netaddr is not sponsored nor endorsed by the IEEE.
+#
+#   Use of data from the IEEE (Institute of Electrical and Electronics
+#   Engineers) is subject to copyright. See the following URL for
+#   details :-
+#
+#       - http://www.ieee.org/web/publications/rights/legal.html
+#
+#   IEEE data files included with netaddr are not modified in any way but are
+#   parsed and made available to end users through an API. There is no
+#   guarantee that referenced files are not out of date.
+#
+#   See README file and source code for URLs to latest copies of the relevant
+#   files.
+#
+#-----------------------------------------------------------------------------
+"""
+Provides access to public OUI and IAB registration data published by the IEEE.
+
+More details can be found at the following URLs :-
+
+    - IEEE Home Page - http://www.ieee.org/
+    - Registration Authority Home Page - http://standards.ieee.org/regauth/
+"""
+
+import os.path as _path
+import csv as _csv
+
+from netaddr.core import Subscriber, Publisher
+
+
+#: Path to local copy of IEEE OUI Registry data file.
+OUI_REGISTRY = _path.join(_path.dirname(__file__), 'oui.txt')
+#: Path to netaddr OUI index file.
+OUI_METADATA = _path.join(_path.dirname(__file__), 'oui.idx')
+
+#: OUI index lookup dictionary.
+OUI_INDEX = {}
+
+#: Path to local copy of IEEE IAB Registry data file.
+IAB_REGISTRY = _path.join(_path.dirname(__file__), 'iab.txt')
+
+#: Path to netaddr IAB index file.
+IAB_METADATA = _path.join(_path.dirname(__file__), 'iab.idx')
+
+#: IAB index lookup dictionary.
+IAB_INDEX = {}
+
+
+class FileIndexer(Subscriber):
+    """
+    A concrete Subscriber that receives OUI record offset information that is
+    written to an index data file as a set of comma separated records.
+    """
+    def __init__(self, index_file):
+        """
+        Constructor.
+
+        :param index_file: a file-like object or name of index file where
+            index records will be written.
+        """
+        if hasattr(index_file, 'readline') and hasattr(index_file, 'tell'):
+            self.fh = index_file
+        else:
+            self.fh = open(index_file, 'w')
+
+        self.writer = _csv.writer(self.fh, lineterminator="\n")
+
+    def update(self, data):
+        """
+        Receives and writes index data to a CSV data file.
+
+        :param data: record containing offset record information.
+        """
+        self.writer.writerow(data)
+
+
+class OUIIndexParser(Publisher):
+    """
+    A concrete Publisher that parses OUI (Organisationally Unique Identifier)
+    records from IEEE text-based registration files
+
+    It notifies registered Subscribers as each record is encountered, passing
+    on the record's position relative to the start of the file (offset) and
+    the size of the record (in bytes).
+
+    The file processed by this parser is available online from this URL :-
+
+        - http://standards.ieee.org/regauth/oui/oui.txt
+
+    This is a sample of the record structure expected::
+
+        00-CA-FE   (hex)        ACME CORPORATION
+        00CAFE     (base 16)        ACME CORPORATION
+                        1 MAIN STREET
+                        SPRINGFIELD
+                        UNITED STATES
+    """
+    def __init__(self, ieee_file):
+        """
+        Constructor.
+
+        :param ieee_file: a file-like object or name of file containing OUI
+            records. When using a file-like object always open it in binary
+            mode otherwise offsets will probably misbehave.
+        """
+        super(OUIIndexParser, self).__init__()
+
+        if hasattr(ieee_file, 'readline') and hasattr(ieee_file, 'tell'):
+            self.fh = ieee_file
+        else:
+            self.fh = open(ieee_file)
+
+    def parse(self):
+        """
+        Starts the parsing process which detects records and notifies
+        registered subscribers as it finds each OUI record.
+        """
+        skip_header = True
+        record = None
+        size = 0
+
+        while True:
+            line = self.fh.readline() # unbuffered to obtain correct offsets
+
+            if not line:
+                break   # EOF, we're done
+
+            if skip_header and '(hex)' in line:
+                skip_header = False
+
+            if skip_header:
+                #   ignoring header section
+                continue
+
+            if '(hex)' in line:
+                #   record start
+                if record is not None:
+                    #   a complete record.
+                    record.append(size)
+                    self.notify(record)
+
+                size = len(line)
+                offset = (self.fh.tell() - len(line))
+                oui = line.split()[0]
+                index = int(oui.replace('-', ''), 16)
+                record = [index, offset]
+            else:
+                #   within record
+                size += len(line)
+
+        #   process final record on loop exit
+        record.append(size)
+        self.notify(record)
+
+
+class IABIndexParser(Publisher):
+    """
+    A concrete Publisher that parses IAB (Individual Address Block) records
+    from IEEE text-based registration files
+
+    It notifies registered Subscribers as each record is encountered, passing
+    on the record's position relative to the start of the file (offset) and
+    the size of the record (in bytes).
+
+    The file processed by this parser is available online from this URL :-
+
+        - http://standards.ieee.org/regauth/oui/iab.txt
+
+    This is a sample of the record structure expected::
+
+        00-50-C2   (hex)        ACME CORPORATION
+        ABC000-ABCFFF     (base 16)        ACME CORPORATION
+                        1 MAIN STREET
+                        SPRINGFIELD
+                        UNITED STATES
+    """
+    def __init__(self, ieee_file):
+        """
+        Constructor.
+
+        :param ieee_file: a file-like object or name of file containing IAB
+            records. When using a file-like object always open it in binary
+            mode otherwise offsets will probably misbehave.
+        """
+        super(IABIndexParser, self).__init__()
+
+        if hasattr(ieee_file, 'readline') and hasattr(ieee_file, 'tell'):
+            self.fh = ieee_file
+        else:
+            self.fh = open(ieee_file)
+
+    def parse(self):
+        """
+        Starts the parsing process which detects records and notifies
+        registered subscribers as it finds each IAB record.
+        """
+        skip_header = True
+        record = None
+        size = 0
+        while True:
+            line = self.fh.readline()   # unbuffered
+
+            if not line:
+                break   # EOF, we're done
+
+            if skip_header and '(hex)' in line:
+                skip_header = False
+
+            if skip_header:
+                #   ignoring header section
+                continue
+
+            if '(hex)' in line:
+                #   record start
+                if record is not None:
+                    record.append(size)
+                    self.notify(record)
+
+                offset = (self.fh.tell() - len(line))
+                iab_prefix = line.split()[0]
+                index = iab_prefix
+                record = [index, offset]
+                size = len(line)
+            elif '(base 16)' in line:
+                #   within record
+                size += len(line)
+                prefix = record[0].replace('-', '')
+                suffix = line.split()[0]
+                suffix = suffix.split('-')[0]
+                record[0] = (int(prefix + suffix, 16)) >> 12
+            else:
+                #   within record
+                size += len(line)
+
+        #   process final record on loop exit
+        record.append(size)
+        self.notify(record)
+
+
+def create_indices():
+    """Create indices for OUI and IAB file based lookups"""
+    oui_parser = OUIIndexParser(OUI_REGISTRY)
+    oui_parser.attach(FileIndexer(OUI_METADATA))
+    oui_parser.parse()
+
+    iab_parser = IABIndexParser(IAB_REGISTRY)
+    iab_parser.attach(FileIndexer(IAB_METADATA))
+    iab_parser.parse()
+
+
+def load_indices():
+    """Load OUI and IAB lookup indices into memory"""
+    fp = open(OUI_METADATA)
+    try:
+        for row in _csv.reader(fp):
+            (key, offset, size) = [int(_) for _ in row]
+            OUI_INDEX.setdefault(key, [])
+            OUI_INDEX[key].append((offset, size))
+    finally:
+        fp.close()
+
+    fp = open(IAB_METADATA)
+    try:
+        for row in _csv.reader(fp):
+            (key, offset, size) = [int(_) for _ in row]
+            IAB_INDEX.setdefault(key, [])
+            IAB_INDEX[key].append((offset, size))
+    finally:
+        fp.close()
+
+
+if __name__ == '__main__':
+    #   Generate indices when module is executed as a script.
+    create_indices()
+else:
+    #   On module load read indices in memory to enable lookups.
+    load_indices()

netaddr/fbsocket.py

@@ -0,0 +1,246 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""Fallback routines for Python's standard library socket module"""
+
+from struct import unpack as _unpack, pack as _pack
+
+from netaddr.compat import _bytes_join, _is_str
+
+AF_INET   =  2
+AF_INET6  = 10
+
+
+def inet_ntoa(packed_ip):
+    """
+    Convert an IP address from 32-bit packed binary format to string format.
+    """
+    if not _is_str(packed_ip):
+        raise TypeError('string type expected, not %s' % str(type(packed_ip)))
+
+    if len(packed_ip) != 4:
+        raise ValueError('invalid length of packed IP address string')
+
+    return '%d.%d.%d.%d' % _unpack('4B', packed_ip)
+
+
+def _compact_ipv6_tokens(tokens):
+    new_tokens = []
+
+    positions = []
+    start_index = None
+    num_tokens = 0
+
+    #   Discover all runs of zeros.
+    for idx, token in enumerate(tokens):
+        if token == '0':
+            if start_index is None:
+                start_index = idx
+            num_tokens += 1
+        else:
+            if num_tokens > 1:
+                positions.append((num_tokens, start_index))
+            start_index = None
+            num_tokens = 0
+
+        new_tokens.append(token)
+
+    #   Store any position not saved before loop exit.
+    if num_tokens > 1:
+        positions.append((num_tokens, start_index))
+
+    #   Replace first longest run with an empty string.
+    if len(positions) != 0:
+        #   Locate longest, left-most run of zeros.
+        positions.sort(key=lambda x: x[1])
+        best_position = positions[0]
+        for position in positions:
+            if position[0] > best_position[0]:
+                best_position = position
+        #   Replace chosen zero run.
+        (length, start_idx) = best_position
+        new_tokens = new_tokens[0:start_idx] + [''] + \
+                     new_tokens[start_idx+length:]
+
+        #   Add start and end blanks so join creates '::'.
+        if new_tokens[0] == '':
+            new_tokens.insert(0, '')
+
+        if new_tokens[-1] == '':
+            new_tokens.append('')
+
+    return new_tokens
+
+
+def inet_ntop(af, packed_ip):
+    """Convert an packed IP address of the given family to string format."""
+    if af == AF_INET:
+        #   IPv4.
+        return inet_ntoa(packed_ip)
+    elif af == AF_INET6:
+        #   IPv6.
+        if len(packed_ip) != 16 or not _is_str(packed_ip):
+            raise ValueError('invalid length of packed IP address string')
+
+        tokens = ['%x' % i for i in _unpack('>8H', packed_ip)]
+
+        #   Convert packed address to an integer value.
+        words = list(_unpack('>8H', packed_ip))
+        int_val = 0
+        for i, num in enumerate(reversed(words)):
+            word = num
+            word = word << 16 * i
+            int_val = int_val | word
+
+        if 0xffff < int_val <= 0xffffffff or int_val >> 32 == 0xffff:
+            #   IPv4 compatible / mapped IPv6.
+            packed_ipv4 = _pack('>2H', *[int(i, 16) for i in tokens[-2:]])
+            ipv4_str = inet_ntoa(packed_ipv4)
+            tokens = tokens[0:-2] + [ipv4_str]
+
+        return ':'.join(_compact_ipv6_tokens(tokens))
+    else:
+        raise ValueError('unknown address family %d' % af)
+
+
+def _inet_pton_af_inet(ip_string):
+    """
+    Convert an IP address in string format (123.45.67.89) to the 32-bit packed
+    binary format used in low-level network functions. Differs from inet_aton
+    by only support decimal octets. Using octal or hexadecimal values will
+    raise a ValueError exception.
+    """
+    #TODO: optimise this ... use inet_aton with mods if available ...
+    if _is_str(ip_string):
+        invalid_addr = ValueError('illegal IP address string %r' % ip_string)
+        #   Support for hexadecimal and octal octets.
+        tokens = ip_string.split('.')
+
+        #   Pack octets.
+        if len(tokens) == 4:
+            words = []
+            for token in tokens:
+                if token.startswith('0x') or \
+                  (token.startswith('0') and len(token) > 1):
+                    raise invalid_addr
+                try:
+                    octet = int(token)
+                except ValueError:
+                    raise invalid_addr
+
+                if (octet >> 8) != 0:
+                    raise invalid_addr
+                words.append(_pack('B', octet))
+            return _bytes_join(words)
+        else:
+            raise invalid_addr
+
+    raise ValueError('argument should be a string, not %s' % type(ip_string))
+
+
+def inet_pton(af, ip_string):
+    """
+    Convert an IP address from string format to a packed string suitable for
+    use with low-level network functions.
+    """
+    if af == AF_INET:
+        #   IPv4.
+        return _inet_pton_af_inet(ip_string)
+    elif af == AF_INET6:
+        invalid_addr = ValueError('illegal IP address string %r' % ip_string)
+        #   IPv6.
+        values = []
+
+        if not _is_str(ip_string):
+            raise invalid_addr
+
+        if 'x' in ip_string:
+            #   Don't accept hextets with the 0x prefix.
+            raise invalid_addr
+
+        if '::' in ip_string:
+            if ip_string == '::':
+                #   Unspecified address.
+                return '\x00'.encode() * 16
+            #   IPv6 compact mode.
+            try:
+                prefix, suffix = ip_string.split('::')
+            except ValueError:
+                raise invalid_addr
+
+            l_prefix = []
+            l_suffix = []
+
+            if prefix != '':
+                l_prefix = prefix.split(':')
+
+            if suffix != '':
+                l_suffix = suffix.split(':')
+
+            #   IPv6 compact IPv4 compatibility mode.
+            if len(l_suffix) and '.' in l_suffix[-1]:
+                ipv4_str = _inet_pton_af_inet(l_suffix.pop())
+                l_suffix.append('%x' % _unpack('>H', ipv4_str[0:2])[0])
+                l_suffix.append('%x' % _unpack('>H', ipv4_str[2:4])[0])
+
+            token_count = len(l_prefix) + len(l_suffix)
+
+            if not 0 <= token_count <= 8 - 1:
+                raise invalid_addr
+
+            gap_size = 8 - ( len(l_prefix) + len(l_suffix) )
+
+            values = [_pack('>H', int(i, 16)) for i in l_prefix] \
+                   + ['\x00\x00'.encode() for i in range(gap_size)] \
+                   + [_pack('>H', int(i, 16)) for i in l_suffix]
+            try:
+                for token in l_prefix + l_suffix:
+                    word = int(token, 16)
+                    if not 0 <= word <= 0xffff:
+                        raise invalid_addr
+            except ValueError:
+                raise invalid_addr
+        else:
+            #   IPv6 verbose mode.
+            if ':' in ip_string:
+                tokens = ip_string.split(':')
+
+                if '.' in ip_string:
+                    ipv6_prefix = tokens[:-1]
+                    if ipv6_prefix[:-1] != ['0', '0', '0', '0', '0']:
+                        raise invalid_addr
+
+                    if ipv6_prefix[-1].lower() not in ('0', 'ffff'):
+                        raise invalid_addr
+
+                    #   IPv6 verbose IPv4 compatibility mode.
+                    if len(tokens) != 7:
+                        raise invalid_addr
+
+                    ipv4_str = _inet_pton_af_inet(tokens.pop())
+                    tokens.append('%x' % _unpack('>H', ipv4_str[0:2])[0])
+                    tokens.append('%x' % _unpack('>H', ipv4_str[2:4])[0])
+
+                    values = [_pack('>H', int(i, 16)) for i in tokens]
+                else:
+                    #   IPv6 verbose mode.
+                    if len(tokens) != 8:
+                        raise invalid_addr
+                try:
+                    tokens = [int(token, 16) for token in tokens]
+                    for token in tokens:
+                        if not 0 <= token <= 0xffff:
+                            raise invalid_addr
+
+                except ValueError:
+                    raise invalid_addr
+
+                values = [_pack('>H', i) for i in tokens]
+            else:
+                raise invalid_addr
+
+        return _bytes_join(values)
+    else:
+        raise ValueError('Unknown address family %d' % af)

netaddr/ip/glob.py

@@ -0,0 +1,312 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+Routines and classes for supporting and expressing IP address ranges using a
+glob style syntax.
+
+"""
+from netaddr.core import AddrFormatError, AddrConversionError
+from netaddr.ip import IPRange, IPAddress, IPNetwork, iprange_to_cidrs
+from netaddr.compat import _is_str
+
+
+def valid_glob(ipglob):
+    """
+    :param ipglob: An IP address range in a glob-style format.
+
+    :return: ``True`` if IP range glob is valid, ``False`` otherwise.
+    """
+    #TODO: Add support for abbreviated ipglobs.
+    #TODO: e.g. 192.0.*.* == 192.0.*
+    #TODO:      *.*.*.*     == *
+    #TODO: Add strict flag to enable verbose ipglob checking.
+    if not _is_str(ipglob):
+        return False
+
+    seen_hyphen = False
+    seen_asterisk = False
+
+    octets = ipglob.split('.')
+
+    if len(octets) != 4:
+        return False
+
+    for octet in octets:
+        if '-' in octet:
+            if seen_hyphen:
+                return False
+            seen_hyphen = True
+            if seen_asterisk:
+                #   Asterisks cannot precede hyphenated octets.
+                return False
+            try:
+                (octet1, octet2) = [int(i) for i in octet.split('-')]
+            except ValueError:
+                return False
+            if octet1 >= octet2:
+                return False
+            if not 0 <= octet1 <= 254:
+                return False
+            if not 1 <= octet2 <= 255:
+                return False
+        elif octet == '*':
+            seen_asterisk = True
+        else:
+            if seen_hyphen is True:
+                return False
+            if seen_asterisk is True:
+                return False
+            try:
+                if not 0 <= int(octet) <= 255:
+                    return False
+            except ValueError:
+                return False
+    return True
+
+
+def glob_to_iptuple(ipglob):
+    """
+    A function that accepts a glob-style IP range and returns the component
+    lower and upper bound IP address.
+
+    :param ipglob: an IP address range in a glob-style format.
+
+    :return: a tuple contain lower and upper bound IP objects.
+    """
+    if not valid_glob(ipglob):
+        raise AddrFormatError('not a recognised IP glob range: %r!' % ipglob)
+
+    start_tokens = []
+    end_tokens = []
+
+    for octet in ipglob.split('.'):
+        if '-' in octet:
+            tokens = octet.split('-')
+            start_tokens.append(tokens[0])
+            end_tokens.append(tokens[1])
+        elif octet == '*':
+            start_tokens.append('0')
+            end_tokens.append('255')
+        else:
+            start_tokens.append(octet)
+            end_tokens.append(octet)
+
+    return IPAddress('.'.join(start_tokens)), IPAddress('.'.join(end_tokens))
+
+
+def glob_to_iprange(ipglob):
+    """
+    A function that accepts a glob-style IP range and returns the equivalent
+    IP range.
+
+    :param ipglob: an IP address range in a glob-style format.
+
+    :return: an IPRange object.
+    """
+    if not valid_glob(ipglob):
+        raise AddrFormatError('not a recognised IP glob range: %r!' % ipglob)
+
+    start_tokens = []
+    end_tokens = []
+
+    for octet in ipglob.split('.'):
+        if '-' in octet:
+            tokens = octet.split('-')
+            start_tokens.append(tokens[0])
+            end_tokens.append(tokens[1])
+        elif octet == '*':
+            start_tokens.append('0')
+            end_tokens.append('255')
+        else:
+            start_tokens.append(octet)
+            end_tokens.append(octet)
+
+    return IPRange('.'.join(start_tokens), '.'.join(end_tokens))
+
+
+def iprange_to_globs(start, end):
+    """
+    A function that accepts an arbitrary start and end IP address or subnet
+    and returns one or more glob-style IP ranges.
+
+    :param start: the start IP address or subnet.
+
+    :param end: the end IP address or subnet.
+
+    :return: a list containing one or more IP globs.
+    """
+    start = IPAddress(start)
+    end = IPAddress(end)
+
+    if start.version != 4 and end.version != 4:
+        raise AddrConversionError('IP glob ranges only support IPv4!')
+
+    def _iprange_to_glob(lb, ub):
+        #   Internal function to process individual IP globs.
+        t1 = [int(_) for _ in str(lb).split('.')]
+        t2 = [int(_) for _ in str(ub).split('.')]
+
+        tokens = []
+
+        seen_hyphen = False
+        seen_asterisk = False
+
+        for i in range(4):
+            if t1[i] == t2[i]:
+                #   A normal octet.
+                tokens.append(str(t1[i]))
+            elif (t1[i] == 0) and (t2[i] == 255):
+                #   An asterisk octet.
+                tokens.append('*')
+                seen_asterisk = True
+            else:
+                #   Create a hyphenated octet - only one allowed per IP glob.
+                if not seen_asterisk:
+                    if not seen_hyphen:
+                        tokens.append('%s-%s' % (t1[i], t2[i]))
+                        seen_hyphen = True
+                    else:
+                        raise AddrConversionError('only 1 hyphenated octet' \
+                            ' per IP glob allowed!')
+                else:
+                    raise AddrConversionError("asterisks are not allowed' \
+                        ' before hyphenated octets!")
+
+        return '.'.join(tokens)
+
+    globs = []
+
+    try:
+        #   IP range can be represented by a single glob.
+        ipglob = _iprange_to_glob(start, end)
+        if not valid_glob(ipglob):
+            #TODO: this is a workaround, it is produces non-optimal but valid
+            #TODO: glob conversions. Fix inner function so that is always
+            #TODO: produces a valid glob.
+            raise AddrConversionError('invalid ip glob created')
+        globs.append(ipglob)
+    except AddrConversionError:
+        #   Break IP range up into CIDRs before conversion to globs.
+        #
+        #TODO: this is still not completely optimised but is good enough
+        #TODO: for the moment.
+        #
+        for cidr in iprange_to_cidrs(start, end):
+            ipglob = _iprange_to_glob(cidr[0], cidr[-1])
+            globs.append(ipglob)
+
+    return globs
+
+
+def glob_to_cidrs(ipglob):
+    """
+    A function that accepts a glob-style IP range and returns a list of one
+    or more IP CIDRs that exactly matches it.
+
+    :param ipglob: an IP address range in a glob-style format.
+
+    :return: a list of one or more IP objects.
+    """
+    return iprange_to_cidrs(*glob_to_iptuple(ipglob))
+
+
+def cidr_to_glob(cidr):
+    """
+    A function that accepts an IP subnet in a glob-style format and returns
+    a list of CIDR subnets that exactly matches the specified glob.
+
+    :param cidr: an IP object CIDR subnet.
+
+    :return: a list of one or more IP addresses and subnets.
+    """
+    ip = IPNetwork(cidr)
+    globs = iprange_to_globs(ip[0], ip[-1])
+    if len(globs) != 1:
+        #   There should only ever be a one to one mapping between a CIDR and
+        #   an IP glob range.
+        raise AddrConversionError('bad CIDR to IP glob conversion!')
+    return globs[0]
+
+
+class IPGlob(IPRange):
+    """
+    Represents an IP address range using a glob-style syntax ``x.x.x-y.*``
+
+    Individual octets can be represented using the following shortcuts :
+
+        1. ``*`` - the asterisk octet (represents values ``0`` through ``255``)
+        2. ``x-y`` - the hyphenated octet (represents values ``x`` through ``y``)
+
+    A few basic rules also apply :
+
+        1. ``x`` must always be greater than ``y``, therefore :
+
+        - ``x`` can only be ``0`` through ``254``
+        - ``y`` can only be ``1`` through ``255``
+
+        2. only one hyphenated octet per IP glob is allowed
+        3. only asterisks are permitted after a hyphenated octet
+
+    Examples:
+
+    +------------------+------------------------------+
+    | IP glob          | Description                  |
+    +==================+==============================+
+    | ``192.0.2.1``    | a single address             |
+    +------------------+------------------------------+
+    | ``192.0.2.0-31`` | 32 addresses                 |
+    +------------------+------------------------------+
+    | ``192.0.2.*``    | 256 addresses                |
+    +------------------+------------------------------+
+    | ``192.0.2-3.*``  | 512 addresses                |
+    +------------------+------------------------------+
+    | ``192.0-1.*.*``  | 131,072 addresses            |
+    +------------------+------------------------------+
+    | ``*.*.*.*``      | the whole IPv4 address space |
+    +------------------+------------------------------+
+
+    .. note :: \
+    IP glob ranges are not directly equivalent to CIDR blocks. \
+    They can represent address ranges that do not fall on strict bit mask \
+    boundaries. They are suitable for use in configuration files, being \
+    more obvious and readable than their CIDR counterparts, especially for \
+    admins and end users with little or no networking knowledge or \
+    experience. All CIDR addresses can always be represented as IP globs \
+    but the reverse is not always true.
+    """
+    __slots__ = ('_glob',)
+
+    def __init__(self, ipglob):
+        (start, end) = glob_to_iptuple(ipglob)
+        super(IPGlob, self).__init__(start, end)
+        self.glob = iprange_to_globs(self._start, self._end)[0]
+
+    def __getstate__(self):
+        """:return: Pickled state of an `IPGlob` object."""
+        return super(IPGlob, self).__getstate__()
+
+    def __setstate__(self, state):
+        """:param state: data used to unpickle a pickled `IPGlob` object."""
+        super(IPGlob, self).__setstate__(state)
+        self.glob = iprange_to_globs(self._start, self._end)[0]
+
+    def _get_glob(self):
+        return self._glob
+
+    def _set_glob(self, ipglob):
+        (self._start, self._end) = glob_to_iptuple(ipglob)
+        self._glob = iprange_to_globs(self._start, self._end)[0]
+
+    glob = property(_get_glob, _set_glob, None,
+        'an arbitrary IP address range in glob format.')
+
+    def __str__(self):
+        """:return: IP glob in common representational format."""
+        return "%s" % self.glob
+
+    def __repr__(self):
+        """:return: Python statement to create an equivalent object"""
+        return "%s('%s')" % (self.__class__.__name__, self.glob)

netaddr/ip/iana.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+#
+#   DISCLAIMER
+#
+#   netaddr is not sponsored nor endorsed by IANA.
+#
+#   Use of data from IANA (Internet Assigned Numbers Authority) is subject to
+#   copyright and is provided with prior written permission.
+#
+#   IANA data files included with netaddr are not modified in any way but are
+#   parsed and made available to end users through an API.
+#
+#   See README file and source code for URLs to latest copies of the relevant
+#   files.
+#
+#-----------------------------------------------------------------------------
+"""
+Routines for accessing data published by IANA (Internet Assigned Numbers
+Authority).
+
+More details can be found at the following URLs :-
+
+    - IANA Home Page - http://www.iana.org/
+    - IEEE Protocols Information Home Page - http://www.iana.org/protocols/
+"""
+
+import os as _os
+import os.path as _path
+import sys as _sys
+
+from xml.sax import make_parser, handler
+
+from netaddr.core import Publisher, Subscriber, dos2unix
+from netaddr.ip import IPAddress, IPNetwork, IPRange, cidr_abbrev_to_verbose
+
+from netaddr.compat import _dict_items, _callable
+
+
+
+#: Topic based lookup dictionary for IANA information.
+IANA_INFO = {
+    'IPv4'      : {},
+    'IPv6'      : {},
+    'multicast' : {},
+}
+
+
+
+class SaxRecordParser(handler.ContentHandler):
+
+    def __init__(self, callback=None):
+        self._level = 0
+        self._is_active = False
+        self._record = None
+        self._tag_level = None
+        self._tag_payload = None
+        self._tag_feeding = None
+        self._callback = callback
+
+    def startElement(self, name, attrs):
+        self._level += 1
+
+        if self._is_active is False:
+            if name == 'record':
+                self._is_active = True
+                self._tag_level = self._level
+                self._record = {}
+                if 'date' in attrs:
+                    self._record['date'] = attrs['date']
+        elif self._level == self._tag_level + 1:
+            if name == 'xref':
+                if 'type' in attrs and 'data' in attrs:
+                    l = self._record.setdefault(attrs['type'], [])
+                    l.append(attrs['data'])
+            else:
+                self._tag_payload = []
+                self._tag_feeding = True
+        else:
+            self._tag_feeding = False
+
+    def endElement(self, name):
+        if self._is_active is True:
+            if name == 'record' and self._tag_level == self._level:
+                self._is_active = False
+                self._tag_level = None
+                if _callable(self._callback):
+                    self._callback(self._record)
+                self._record = None
+            elif self._level == self._tag_level + 1:
+                if name != 'xref':
+                    self._record[name] = ''.join(self._tag_payload)
+                    self._tag_payload = None
+                    self._tag_feeding = False
+
+        self._level -= 1
+
+    def characters(self, content):
+        if self._tag_feeding is True:
+            self._tag_payload.append(content)
+
+
+class XMLRecordParser(Publisher):
+    """
+    A configurable Parser that understands how to parse XML based records.
+    """
+    def __init__(self, fh, **kwargs):
+        """
+        Constructor.
+
+        fh - a valid, open file handle to XML based record data.
+        """
+        super(XMLRecordParser, self).__init__()
+
+        self.xmlparser = make_parser()
+        self.xmlparser.setContentHandler(SaxRecordParser(self.consume_record))
+
+        self.fh = fh
+
+        self.__dict__.update(kwargs)
+
+    def process_record(self, rec):
+        """
+        This is the callback method invoked for every record. It is usually
+        over-ridden by base classes to provide specific record-based logic.
+
+        Any record can be vetoed (not passed to registered Subscriber objects)
+        by simply returning None.
+        """
+        return rec
+
+    def consume_record(self, rec):
+        record = self.process_record(rec)
+        if record is not None:
+            self.notify(record)
+
+    def parse(self):
+        """
+        Parse and normalises records, notifying registered subscribers with
+        record data as it is encountered.
+        """
+        self.xmlparser.parse(self.fh)
+
+
+class IPv4Parser(XMLRecordParser):
+    """
+    A XMLRecordParser that understands how to parse and retrieve data records
+    from the IANA IPv4 address space file.
+
+    It can be found online here :-
+
+        - http://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.xml
+    """
+    def __init__(self, fh, **kwargs):
+        """
+        Constructor.
+
+        fh - a valid, open file handle to an IANA IPv4 address space file.
+
+        kwargs - additional parser options.
+        """
+        super(IPv4Parser, self).__init__(fh)
+
+    def process_record(self, rec):
+        """
+        Callback method invoked for every record.
+
+        See base class method for more details.
+        """
+
+        record = {}
+        for key in ('prefix', 'designation', 'date', 'whois', 'status'):
+            record[key] = str(rec.get(key, '')).strip()
+
+        #   Strip leading zeros from octet.
+        if '/' in record['prefix']:
+            (octet, prefix) = record['prefix'].split('/')
+            record['prefix'] = '%d/%d' % (int(octet), int(prefix))
+
+        record['status'] = record['status'].capitalize()
+
+        return record
+
+
+class IPv6Parser(XMLRecordParser):
+    """
+    A XMLRecordParser that understands how to parse and retrieve data records
+    from the IANA IPv6 address space file.
+
+    It can be found online here :-
+
+        - http://www.iana.org/assignments/ipv6-address-space/ipv6-address-space.xml
+    """
+    def __init__(self, fh, **kwargs):
+        """
+        Constructor.
+
+        fh - a valid, open file handle to an IANA IPv6 address space file.
+
+        kwargs - additional parser options.
+        """
+        super(IPv6Parser, self).__init__(fh)
+
+    def process_record(self, rec):
+        """
+        Callback method invoked for every record.
+
+        See base class method for more details.
+        """
+
+        record = {
+                'prefix':       str(rec.get('prefix', '')).strip(),
+                'allocation':   str(rec.get('description', '')).strip(),
+                'reference':    str(rec.get('rfc', [''])[0]).strip(),
+            }
+
+        return record
+
+
+class MulticastParser(XMLRecordParser):
+    """
+    A XMLRecordParser that knows how to process the IANA IPv4 multicast address
+    allocation file.
+
+    It can be found online here :-
+
+        - http://www.iana.org/assignments/multicast-addresses/multicast-addresses.xml
+    """
+    def __init__(self, fh, **kwargs):
+        """
+        Constructor.
+
+        fh - a valid, open file handle to an IANA IPv4 multicast address
+             allocation file.
+
+        kwargs - additional parser options.
+        """
+        super(MulticastParser, self).__init__(fh)
+
+    def normalise_addr(self, addr):
+        """
+        Removes variations from address entries found in this particular file.
+        """
+        if '-' in addr:
+            (a1, a2) = addr.split('-')
+            o1 = a1.strip().split('.')
+            o2 = a2.strip().split('.')
+            return '%s-%s' % ('.'.join([str(int(i)) for i in o1]),
+                              '.'.join([str(int(i)) for i in o2]))
+        else:
+            o1 = addr.strip().split('.')
+            return '.'.join([str(int(i)) for i in o1])
+
+    def process_record(self, rec):
+        """
+        Callback method invoked for every record.
+
+        See base class method for more details.
+        """
+
+        if 'addr' in rec:
+            record = {
+                    'address': self.normalise_addr(str(rec['addr'])),
+                    'descr': str(rec.get('description', '')),
+                }
+            return record
+
+
+class DictUpdater(Subscriber):
+    """
+    Concrete Subscriber that inserts records received from a Publisher into a
+    dictionary.
+    """
+    def __init__(self, dct, topic, unique_key):
+        """
+        Constructor.
+
+        dct - lookup dict or dict like object to insert records into.
+
+        topic - high-level category name of data to be processed.
+
+        unique_key - key name in data dict that uniquely identifies it.
+        """
+        self.dct = dct
+        self.topic = topic
+        self.unique_key = unique_key
+
+    def update(self, data):
+        """
+        Callback function used by Publisher to notify this Subscriber about
+        an update. Stores topic based information into dictionary passed to
+        constructor.
+        """
+        data_id = data[self.unique_key]
+
+        if self.topic == 'IPv4':
+            cidr = IPNetwork(cidr_abbrev_to_verbose(data_id))
+            self.dct[cidr] = data
+        elif self.topic == 'IPv6':
+            cidr = IPNetwork(cidr_abbrev_to_verbose(data_id))
+            self.dct[cidr] = data
+        elif self.topic == 'multicast':
+            iprange = None
+            if '-' in data_id:
+                #   See if we can manage a single CIDR.
+                (first, last) = data_id.split('-')
+                iprange = IPRange(first, last)
+                cidrs = iprange.cidrs()
+                if len(cidrs) == 1:
+                    iprange = cidrs[0]
+            else:
+                iprange = IPAddress(data_id)
+            self.dct[iprange] = data
+
+
+def load_info():
+    """
+    Parse and load internal IANA data lookups with the latest information from
+    data files.
+    """
+    PATH = _path.dirname(__file__)
+
+    ipv4 = IPv4Parser(open(_path.join(PATH, 'ipv4-address-space.xml')))
+    ipv4.attach(DictUpdater(IANA_INFO['IPv4'], 'IPv4', 'prefix'))
+    ipv4.parse()
+
+    ipv6 = IPv6Parser(open(_path.join(PATH, 'ipv6-address-space.xml')))
+    ipv6.attach(DictUpdater(IANA_INFO['IPv6'], 'IPv6', 'prefix'))
+    ipv6.parse()
+
+    mcast = MulticastParser(open(_path.join(PATH, 'multicast-addresses.xml')))
+    mcast.attach(DictUpdater(IANA_INFO['multicast'], 'multicast', 'address'))
+    mcast.parse()
+
+
+def pprint_info(fh=None):
+    """
+    Pretty prints IANA information to filehandle.
+    """
+    if fh is None:
+        fh = _sys.stdout
+
+    for category in sorted(IANA_INFO):
+        fh.write('-' * len(category) + "\n")
+        fh.write(category + "\n")
+        fh.write('-' * len(category) + "\n")
+        ipranges = IANA_INFO[category]
+        for iprange in sorted(ipranges):
+            details = ipranges[iprange]
+            fh.write('%-45r' % (iprange) + details + "\n")
+
+
+def query(ip_addr):
+    """
+    Returns informational data specific to this IP address.
+    """
+    info = {}
+
+    def within_bounds(ip, ip_range):
+        #   Boundary checking for multiple IP classes.
+        if hasattr(ip_range, 'first'):
+            #   IP network or IP range.
+            return ip in ip_range
+        elif hasattr(ip_range, 'value'):
+            #   IP address.
+            return ip == ip_range
+
+        raise Exception('Unsupported IP range or address: %r!' % ip_range)
+
+    if ip_addr.version == 4:
+        for cidr, record in _dict_items(IANA_INFO['IPv4']):
+            if within_bounds(ip_addr, cidr):
+                info.setdefault('IPv4', [])
+                info['IPv4'].append(record)
+
+        if ip_addr.is_multicast():
+            for iprange, record in _dict_items(IANA_INFO['multicast']):
+                if within_bounds(ip_addr, iprange):
+                    info.setdefault('Multicast', [])
+                    info['Multicast'].append(record)
+
+    elif ip_addr.version == 6:
+        for cidr, record in _dict_items(IANA_INFO['IPv6']):
+            if within_bounds(ip_addr, cidr):
+                info.setdefault('IPv6', [])
+                info['IPv6'].append(record)
+
+    return info
+
+
+def get_latest_files():
+    """Download the latest files from IANA"""
+    if _sys.version_info[0] == 3:
+        #   Python 3.x
+        from urllib.request import Request, urlopen
+    else:
+        #   Python 2.x
+        from urllib2 import Request, urlopen
+
+    urls = [
+        'http://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.xml',
+        'http://www.iana.org/assignments/ipv6-address-space/ipv6-address-space.xml',
+        'http://www.iana.org/assignments/multicast-addresses/multicast-addresses.xml',
+    ]
+
+    for url in urls:
+        _sys.stdout.write('downloading latest copy of %s\n' % url)
+        request = Request(url)
+        response = urlopen(request)
+        save_path = _path.dirname(__file__)
+        basename = _os.path.basename(response.geturl().rstrip('/'))
+        filename = _path.join(save_path, basename)
+        fh = open(filename, 'wb')
+        fh.write(response.read())
+        fh.close()
+
+        #   Make sure the line endings are consistent across platforms.
+        dos2unix(filename)
+
+
+if __name__ == '__main__':
+    #   Generate indices when module is executed as a script.
+    get_latest_files()
+
+#   On module import, read IANA data files and populate lookups dict.
+load_info()

netaddr/ip/ipv6-address-space.xml

@@ -0,0 +1,175 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<?xml-stylesheet type="text/xsl" href="ipv6-address-space.xsl"?>
+<?oxygen RNGSchema="ipv6-address-space.rng" type="xml"?>
+<registry xmlns="http://www.iana.org/assignments" id="ipv6-address-space">
+  <title>Internet Protocol Version 6 Address Space</title>
+  <updated>2013-02-15</updated>
+  <note>The IPv6 address management function was formally delegated to
+IANA in December 1995 <xref type="rfc" data="rfc1881"/>. The registration procedure
+was confirmed with the IETF Chair in March 2010.</note>
+<registry id="ipv6-address-space-1">
+  <registration_rule>IESG Approval</registration_rule>
+  <record>
+    <prefix>0000::/8</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes>
+    <xref type="note" data="1"/>
+    <xref type="note" data="2"/>
+    <xref type="note" data="3"/>
+    <xref type="note" data="4"/>
+    <xref type="note" data="5"/>
+    </notes>
+  </record>
+  <record>
+    <prefix>0100::/8</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes>0100::/64 reserved for Discard-Only Address Block <xref type="rfc" data="rfc6666"/>. 
+Complete registration details are found in <xref type="registry" data="iana-ipv6-special-registry"/>.</notes>
+  </record>
+  <record>
+    <prefix>0200::/7</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4048"/>
+    <notes>Deprecated as of December 2004 <xref type="rfc" data="rfc4048"/>. 
+Formerly an OSI NSAP-mapped prefix set <xref type="rfc" data="rfc4548"/>.</notes>
+  </record>
+  <record>
+    <prefix>0400::/6</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>0800::/5</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>1000::/4</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>2000::/3</prefix>
+    <description>Global Unicast</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes>The IPv6 Unicast space encompasses the entire IPv6 address range 
+with the exception of ff00::/8, per <xref type="rfc" data="rfc4291"/>. IANA unicast address 
+assignments are currently limited to the IPv6 unicast address 
+range of 2000::/3. IANA assignments from this block are registered 
+in <xref type="registry" data="ipv6-unicast-address-assignments"/>.
+      <xref type="note" data="6"/>    
+      <xref type="note" data="7"/>    
+      <xref type="note" data="8"/>      
+      <xref type="note" data="9"/>      
+      <xref type="note" data="10"/>      
+      <xref type="note" data="11"/>
+    </notes>
+  </record>
+  <record>
+    <prefix>4000::/3</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>6000::/3</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>8000::/3</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>a000::/3</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>c000::/3</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>e000::/4</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>f000::/5</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>f800::/6</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>fc00::/7</prefix>
+    <description>Unique Local Unicast</description>
+    <xref type="rfc" data="rfc4193"/>
+    <notes>For complete registration details, see <xref type="registry" data="iana-ipv6-special-registry"/>.</notes>
+  </record>
+  <record>
+    <prefix>fe00::/9</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes/>
+  </record>
+  <record>
+    <prefix>fe80::/10</prefix>
+    <description>Link-Scoped Unicast</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes>Reserved by protocol. For authoritative registration, see <xref type="registry" data="iana-ipv6-special-registry"/>.</notes>
+  </record>
+  <record>
+    <prefix>fec0::/10</prefix>
+    <description>Reserved by IETF</description>
+    <xref type="rfc" data="rfc3879"/>
+    <notes>Deprecated by <xref type="rfc" data="rfc3879"/> in September 2004. Formerly a Site-Local scoped address prefix.</notes>
+  </record>
+  <record>
+    <prefix>ff00::/8</prefix>
+    <description>Multicast</description>
+    <xref type="rfc" data="rfc4291"/>
+    <notes>IANA assignments from this block are registered in <xref type="registry" data="ipv6-multicast-addresses"/>.</notes>
+  </record>
+  <footnote anchor="1">::1/128 reserved for Loopback Address <xref type="rfc" data="rfc4291"/>. 
+Reserved by protocol. For authoritative registration, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>
+  <footnote anchor="2">::/128 reserved for Unspecified Address <xref type="rfc" data="rfc4291"/>. 
+Reserved by protocol. For authoritative registration, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>
+  <footnote anchor="3">::ffff:0:0/96 reserved for IPv4-mapped Address <xref type="rfc" data="rfc4291"/>. 
+Reserved by protocol. For authoritative registration, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>
+  <footnote anchor="4">0000::/96 deprecated by <xref type="rfc" data="rfc4291"/>. Formerly defined as the "IPv4-compatible IPv6 address" prefix.</footnote>
+  <footnote anchor="5">The "Well Known Prefix" 64:ff9b::/96 is used in an algorithmic mapping between IPv4 to IPv6 addresses <xref type="rfc" data="rfc6052"/>.</footnote>  
+  <footnote anchor="6">2001:0000::/23 reserved for IETF Protocol Assignments <xref type="rfc" data="rfc2928"/>. 
+For complete registration details, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>  
+  <footnote anchor="7">2001:0000::/32 reserved for TEREDO <xref type="rfc" data="rfc4380"/>. 
+For complete registration details, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>  
+  <footnote anchor="8">2001:0002::/48 reserved for Benchmarking <xref type="rfc" data="rfc5180"/>. 
+For complete registration details, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>  
+  <footnote anchor="9">2001:db8::/32 reserved for Documentation <xref type="rfc" data="rfc3849"/>. 
+For complete registration details, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>  
+  <footnote anchor="10">2001:10::/28 reserved for ORCHID <xref type="rfc" data="rfc4843"/>. 
+For complete registration details, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>  
+  <footnote anchor="11">2002::/16 reserved for 6to4 <xref type="rfc" data="rfc3056"/>. 
+For complete registration details, see <xref type="registry" data="iana-ipv6-special-registry"/>.</footnote>
+
+
+  <people/>
+</registry>
+ </registry>

netaddr/ip/nmap.py

@@ -0,0 +1,98 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+Routines for dealing with nmap-style IPv4 address ranges.
+
+Based on nmap's Target Specification :-
+
+    http://nmap.org/book/man-target-specification.html
+"""
+
+from netaddr.core import AddrFormatError
+from netaddr.ip import IPAddress
+from netaddr.compat import _iter_range, _is_str
+
+
+def _nmap_octet_target_values(spec):
+    #   Generates sequence of values for an individual octet as defined in the
+    #   nmap Target Specification.
+    values = set()
+
+    for element in spec.split(','):
+        if '-' in element:
+            left, right = element.split('-', 1)
+            if not left:
+                left = 0
+            if not right:
+                right = 255
+            low = int(left)
+            high = int(right)
+            if not ((0 <= low <= 255) and (0 <= high <= 255)):
+                raise ValueError('octet value overflow for spec %s!' % spec)
+            if low > high:
+                raise ValueError('left side of hyphen must be <= right %r' % element)
+            for octet in _iter_range(low, high + 1):
+                values.add(octet)
+        else:
+            octet = int(element)
+            if not (0 <= octet <= 255):
+                raise ValueError('octet value overflow for spec %s!' % spec)
+            values.add(octet)
+
+    return sorted(values)
+
+
+def _generate_nmap_octet_ranges(nmap_target_spec):
+    #   Generate 4 lists containing all octets defined by a given nmap Target
+    #   specification.
+    if not _is_str(nmap_target_spec):
+        raise TypeError('string expected, not %s' % type(nmap_target_spec))
+
+    if not nmap_target_spec:
+        raise ValueError('nmap target specification cannot be blank!')
+
+    tokens = nmap_target_spec.split('.')
+
+    if len(tokens) != 4:
+        raise AddrFormatError('invalid nmap range: %s' % nmap_target_spec)
+
+    return (_nmap_octet_target_values(tokens[0]),
+            _nmap_octet_target_values(tokens[1]),
+            _nmap_octet_target_values(tokens[2]),
+            _nmap_octet_target_values(tokens[3]))
+
+
+def valid_nmap_range(nmap_target_spec):
+    """
+    :param nmap_target_spec: an nmap-style IP range target specification.
+
+    :return: ``True`` if IP range target spec is valid, ``False`` otherwise.
+    """
+    try:
+        _generate_nmap_octet_ranges(nmap_target_spec)
+        return True
+    except (TypeError, ValueError, AddrFormatError):
+        pass
+    return False
+
+
+def iter_nmap_range(nmap_target_spec):
+    """
+    The nmap security tool supports a custom type of IPv4 range using multiple
+    hyphenated octets. This generator provides iterators yielding IP addresses
+    according to this rule set.
+
+    :param nmap_target_spec: an nmap-style IP range target specification.
+
+    :return: an iterator producing IPAddress objects for each IP in the range.
+    """
+    octet_ranges = _generate_nmap_octet_ranges(nmap_target_spec)
+    for w in octet_ranges[0]:
+        for x in octet_ranges[1]:
+            for y in octet_ranges[2]:
+                for z in octet_ranges[3]:
+                    yield IPAddress("%d.%d.%d.%d" % (w, x, y, z), 4)
+

netaddr/ip/rfc1924.py

@@ -0,0 +1,58 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""A basic implementation of RFC 1924 ;-)"""
+
+from netaddr.core import AddrFormatError
+from netaddr.ip import IPAddress
+
+from netaddr.compat import _zip
+
+
+def chr_range(low, high):
+    """Returns all characters between low and high chars."""
+    return [chr(i) for i in range(ord(low), ord(high)+1)]
+
+#: Base 85 integer index to character lookup table.
+BASE_85 = chr_range('0', '9') + chr_range('A', 'Z') + chr_range('a', 'z') + \
+    ['!', '#', '$', '%', '&', '(',')', '*', '+', '-',';', '<', '=', '>',
+     '?', '@', '^', '_','`', '{', '|', '}', '~']
+
+#: Base 85 digit to integer lookup table.
+BASE_85_DICT = dict(_zip(BASE_85, range(0, 86)))
+
+
+def ipv6_to_base85(addr):
+    """Convert a regular IPv6 address to base 85."""
+    ip = IPAddress(addr)
+    int_val = int(ip)
+
+    remainder = []
+    while int_val > 0:
+        remainder.append(int_val % 85)
+        int_val //= 85
+
+    encoded = ''.join([BASE_85[w] for w in reversed(remainder)])
+    leading_zeroes = (20 - len(encoded)) * "0"
+    return leading_zeroes + encoded
+
+
+def base85_to_ipv6(addr):
+    """
+    Convert a base 85 IPv6 address to its hexadecimal format.
+    """
+    tokens = list(addr)
+
+    if len(tokens) != 20:
+        raise AddrFormatError('Invalid base 85 IPv6 address: %r' % addr)
+
+    result = 0
+    for i, num in enumerate(reversed(tokens)):
+        num = BASE_85_DICT[num]
+        result += (num * 85 ** i)
+
+    ip = IPAddress(result, 6)
+
+    return str(ip)

netaddr/ip/sets.py

@@ -0,0 +1,743 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""Set based operations for IP addresses and subnets."""
+
+import itertools as _itertools
+
+from netaddr.ip import IPNetwork, IPAddress, IPRange, cidr_merge, \
+    cidr_exclude, iprange_to_cidrs
+
+from netaddr.compat import _sys_maxint, _dict_keys, _int_type
+
+
+def _subtract(supernet, subnets, subnet_idx, ranges):
+    """Calculate IPSet([supernet]) - IPSet(subnets).
+
+    Assumptions: subnets is sorted, subnet_idx points to the first
+    element in subnets that is a subnet of supernet.
+
+    Results are appended to the ranges parameter as tuples of in format
+    (version, first, last). Return value is the first subnet_idx that
+    does not point to a subnet of supernet (or len(subnets) if all
+    subsequents items are a subnet of supernet).
+    """
+    version = supernet._module.version
+    subnet = subnets[subnet_idx]
+    if subnet.first > supernet.first:
+        ranges.append((version, supernet.first, subnet.first - 1))
+
+    subnet_idx += 1
+    prev_subnet = subnet
+    while subnet_idx < len(subnets):
+        cur_subnet = subnets[subnet_idx]
+
+        if cur_subnet not in supernet:
+            break
+        if prev_subnet.last + 1 == cur_subnet.first:
+            # two adjacent, non-mergable IPNetworks
+            pass
+        else:
+            ranges.append((version, prev_subnet.last + 1, cur_subnet.first - 1))
+
+        subnet_idx += 1
+        prev_subnet = cur_subnet
+
+    first = prev_subnet.last + 1
+    last = supernet.last
+    if first <= last:
+        ranges.append((version, first, last))
+
+    return subnet_idx
+
+def _iter_merged_ranges(sorted_ranges):
+    """Iterate over sorted_ranges, merging where possible
+
+    Sorted ranges must be a sorted iterable of (version, first, last) tuples.
+    Merging occurs for pairs like [(4, 10, 42), (4, 43, 100)] which is merged
+    into (4, 10, 100), and leads to return value
+    ( IPAddress(10, 4), IPAddress(100, 4) ), which is suitable input for the
+    iprange_to_cidrs function.
+    """
+    if not sorted_ranges:
+        return
+
+    current_version, current_start, current_stop = sorted_ranges[0]
+
+    for next_version, next_start, next_stop in sorted_ranges[1:]:
+        if next_start == current_stop + 1 and next_version == current_version:
+            # Can be merged.
+            current_stop = next_stop
+            continue
+        # Cannot be merged.
+        yield (IPAddress(current_start, current_version),
+                IPAddress(current_stop, current_version))
+        current_start = next_start
+        current_stop = next_stop
+        current_version = next_version
+    yield (IPAddress(current_start, current_version),
+            IPAddress(current_stop, current_version))
+
+
+class IPSet(object):
+    """
+    Represents an unordered collection (set) of unique IP addresses and
+    subnets.
+
+    """
+    __slots__ = ('_cidrs',)
+
+    def __init__(self, iterable=None, flags=0):
+        """
+        Constructor.
+
+        :param iterable: (optional) an iterable containing IP addresses and
+            subnets.
+
+        :param flags: decides which rules are applied to the interpretation
+            of the addr value. See the netaddr.core namespace documentation
+            for supported constant values.
+
+        """
+        if isinstance(iterable, IPNetwork):
+            self._cidrs = {IPNetwork(iterable): True}
+        elif isinstance(iterable, IPRange):
+            self._cidrs = dict.fromkeys(
+                    iprange_to_cidrs(iterable[0], iterable[-1]), True)
+        elif isinstance(iterable, IPSet):
+            self._cidrs = dict.fromkeys(iterable.iter_cidrs(), True)
+        else:
+            self._cidrs = {}
+            if iterable is not None:
+                mergeable = []
+                for addr in iterable:
+                    if isinstance(addr, _int_type):
+                        addr = IPAddress(addr, flags=flags)
+                    mergeable.append(addr)
+
+                for cidr in cidr_merge(mergeable):
+                    self._cidrs[cidr] = True
+
+    def __getstate__(self):
+        """:return: Pickled state of an ``IPSet`` object."""
+        return tuple([cidr.__getstate__() for cidr in self._cidrs])
+
+    def __setstate__(self, state):
+        """
+        :param state: data used to unpickle a pickled ``IPSet`` object.
+
+        """
+        self._cidrs = dict.fromkeys(
+                (IPNetwork((value, prefixlen), version=version)
+                    for value, prefixlen, version in state),
+                True)
+
+    def _compact_single_network(self, added_network):
+        """
+        Same as compact(), but assume that added_network is the only change and
+        that this IPSet was properly compacted before added_network was added.
+        This allows to perform compaction much faster. added_network must
+        already be present in self._cidrs.
+        """
+        added_first = added_network.first
+        added_last = added_network.last
+        added_version = added_network.version
+
+        # Check for supernets and subnets of added_network.
+        if added_network._prefixlen == added_network._module.width:
+            # This is a single IP address, i.e. /32 for IPv4 or /128 for IPv6.
+            # It does not have any subnets, so we only need to check for its
+            # potential supernets.
+            for potential_supernet in added_network.supernet():
+                if potential_supernet in self._cidrs:
+                    del self._cidrs[added_network]
+                    return
+        else:
+            # IPNetworks from self._cidrs that are subnets of added_network.
+            to_remove = []
+            for cidr in self._cidrs:
+                if (cidr._module.version != added_version or cidr == added_network):
+                    # We found added_network or some network of a different version.
+                    continue
+                first = cidr.first
+                last = cidr.last
+                if first >= added_first and last <= added_last:
+                    # cidr is a subnet of added_network. Remember to remove it.
+                    to_remove.append(cidr)
+                elif first <= added_first and last >= added_last:
+                    # cidr is a supernet of added_network. Remove added_network.
+                    del self._cidrs[added_network]
+                    # This IPSet was properly compacted before. Since added_network
+                    # is removed now, it must again be properly compacted -> done.
+                    assert(not to_remove)
+                    return
+            for item in to_remove:
+                del self._cidrs[item]
+
+        # Check if added_network can be merged with another network.
+
+        # Note that merging can only happen between networks of the same
+        # prefixlen. This just leaves 2 candidates: The IPNetworks just before
+        # and just after the added_network.
+        # This can be reduced to 1 candidate: 10.0.0.0/24 and 10.0.1.0/24 can
+        # be merged into into 10.0.0.0/23. But 10.0.1.0/24 and 10.0.2.0/24
+        # cannot be merged. With only 1 candidate, we might as well make a
+        # dictionary lookup.
+        shift_width = added_network._module.width - added_network.prefixlen
+        while added_network.prefixlen != 0:
+            # figure out if the least significant bit of the network part is 0 or 1.
+            the_bit = (added_network._value >> shift_width) & 1
+            if the_bit:
+                candidate = added_network.previous()
+            else:
+                candidate = added_network.next()
+
+            if candidate not in self._cidrs:
+                # The only possible merge does not work -> merge done
+                return
+            # Remove added_network&candidate, add merged network.
+            del self._cidrs[candidate]
+            del self._cidrs[added_network]
+            added_network.prefixlen -= 1
+            # Be sure that we set the host bits to 0 when we move the prefixlen.
+            # Otherwise, adding 255.255.255.255/32 will result in a merged
+            # 255.255.255.255/24 network, but we want 255.255.255.0/24.
+            shift_width += 1
+            added_network._value = (added_network._value >> shift_width) << shift_width
+            self._cidrs[added_network] = True
+
+    def compact(self):
+        """
+        Compact internal list of `IPNetwork` objects using a CIDR merge.
+        """
+        cidrs = cidr_merge(self._cidrs)
+        self._cidrs = dict.fromkeys(cidrs, True)
+
+    def __hash__(self):
+        """
+        Raises ``TypeError`` if this method is called.
+
+        .. note:: IPSet objects are not hashable and cannot be used as \
+            dictionary keys or as members of other sets. \
+        """
+        raise TypeError('IP sets are unhashable!')
+
+    def __contains__(self, ip):
+        """
+        :param ip: An IP address or subnet.
+
+        :return: ``True`` if IP address or subnet is a member of this IP set.
+        """
+        ip = IPNetwork(ip)
+        # Iterating over self._cidrs is an O(n) operation: 1000 items in
+        # self._cidrs would mean 1000 loops. Iterating over all possible
+        # supernets loops at most 32 times for IPv4 or 128 times for IPv6,
+        # no matter how many CIDRs this object contains.
+        if ip in self._cidrs:
+            return True
+        for cidr in ip.supernet():
+            if cidr in self._cidrs:
+                return True
+        return False
+
+    def __nonzero__(self):
+        """Return True if IPSet contains at least one IP, else False"""
+        return bool(self._cidrs)
+
+    __bool__ = __nonzero__  #   Python 3.x.
+
+    def __iter__(self):
+        """
+        :return: an iterator over the IP addresses within this IP set.
+        """
+        return _itertools.chain(*sorted(self._cidrs))
+
+    def iter_cidrs(self):
+        """
+        :return: an iterator over individual IP subnets within this IP set.
+        """
+        return sorted(self._cidrs)
+
+    def add(self, addr, flags=0):
+        """
+        Adds an IP address or subnet or IPRange to this IP set. Has no effect if
+        it is already present.
+
+        Note that where possible the IP address or subnet is merged with other
+        members of the set to form more concise CIDR blocks.
+
+        :param addr: An IP address or subnet in either string or object form, or
+            an IPRange object.
+
+        :param flags: decides which rules are applied to the interpretation
+            of the addr value. See the netaddr.core namespace documentation
+            for supported constant values.
+
+        """
+        if isinstance(addr, IPRange):
+            new_cidrs = dict.fromkeys(
+                    iprange_to_cidrs(addr[0], addr[-1]), True)
+            self._cidrs.update(new_cidrs)
+            self.compact()
+            return
+
+        if isinstance(addr, _int_type):
+            addr = IPNetwork(IPAddress(addr, flags=flags))
+        else:
+            addr = IPNetwork(addr)
+
+        self._cidrs[addr] = True
+        self._compact_single_network(addr)
+
+    def remove(self, addr, flags=0):
+        """
+        Removes an IP address or subnet or IPRange from this IP set. Does
+        nothing if it is not already a member.
+
+        Note that this method behaves more like discard() found in regular
+        Python sets because it doesn't raise KeyError exceptions if the
+        IP address or subnet is question does not exist. It doesn't make sense
+        to fully emulate that behaviour here as IP sets contain groups of
+        individual IP addresses as individual set members using IPNetwork
+        objects.
+
+        :param addr: An IP address or subnet, or an IPRange.
+
+        :param flags: decides which rules are applied to the interpretation
+            of the addr value. See the netaddr.core namespace documentation
+            for supported constant values.
+
+        """
+        if isinstance(addr, IPRange):
+            cidrs = iprange_to_cidrs(addr[0], addr[-1])
+            for cidr in cidrs:
+                self.remove(cidr)
+            return
+
+        if isinstance(addr, _int_type):
+            addr = IPAddress(addr, flags=flags)
+        else:
+            addr = IPNetwork(addr)
+
+        #   This add() is required for address blocks provided that are larger
+        #   than blocks found within the set but have overlaps. e.g. :-
+        #
+        #   >>> IPSet(['192.0.2.0/24']).remove('192.0.2.0/23')
+        #   IPSet([])
+        #
+        self.add(addr)
+
+        remainder = None
+        matching_cidr = None
+
+        #   Search for a matching CIDR and exclude IP from it.
+        for cidr in self._cidrs:
+            if addr in cidr:
+                remainder = cidr_exclude(cidr, addr)
+                matching_cidr = cidr
+                break
+
+        #   Replace matching CIDR with remaining CIDR elements.
+        if remainder is not None:
+            del self._cidrs[matching_cidr]
+            for cidr in remainder:
+                self._cidrs[cidr] = True
+        # No call to self.compact() is needed. Removing an IPNetwork cannot
+        # create mergable networks.
+
+    def pop(self):
+        """
+        Removes and returns an arbitrary IP address or subnet from this IP
+        set.
+
+        :return: An IP address or subnet.
+        """
+        return self._cidrs.popitem()[0]
+
+    def isdisjoint(self, other):
+        """
+        :param other: an IP set.
+
+        :return: ``True`` if this IP set has no elements (IP addresses
+            or subnets) in common with other. Intersection *must* be an
+            empty set.
+        """
+        result = self.intersection(other)
+        return not result
+
+    def copy(self):
+        """:return: a shallow copy of this IP set."""
+        obj_copy = self.__class__()
+        obj_copy._cidrs.update(self._cidrs)
+        return obj_copy
+
+    def update(self, iterable, flags=0):
+        """
+        Update the contents of this IP set with the union of itself and
+        other IP set.
+
+        :param iterable: an iterable containing IP addresses and subnets.
+
+        :param flags: decides which rules are applied to the interpretation
+            of the addr value. See the netaddr.core namespace documentation
+            for supported constant values.
+
+        """
+        if isinstance(iterable, IPSet):
+            self._cidrs = dict.fromkeys(
+                    (ip for ip in cidr_merge(_dict_keys(self._cidrs)
+                        + _dict_keys(iterable._cidrs))), True)
+            return
+        elif isinstance(iterable, (IPNetwork, IPRange)):
+            self.add(iterable)
+            return
+
+        if not hasattr(iterable, '__iter__'):
+            raise TypeError('an iterable was expected!')
+        #   An iterable containing IP addresses or subnets.
+        mergeable = []
+        for addr in iterable:
+            if isinstance(addr, _int_type):
+                addr = IPAddress(addr, flags=flags)
+            mergeable.append(addr)
+
+        for cidr in cidr_merge(_dict_keys(self._cidrs) + mergeable):
+            self._cidrs[cidr] = True
+
+        self.compact()
+
+    def clear(self):
+        """Remove all IP addresses and subnets from this IP set."""
+        self._cidrs = {}
+
+    def __eq__(self, other):
+        """
+        :param other: an IP set
+
+        :return: ``True`` if this IP set is equivalent to the ``other`` IP set,
+            ``False`` otherwise.
+        """
+        try:
+            return self._cidrs == other._cidrs
+        except AttributeError:
+            return NotImplemented
+
+    def __ne__(self, other):
+        """
+        :param other: an IP set
+
+        :return: ``False`` if this IP set is equivalent to the ``other`` IP set,
+            ``True`` otherwise.
+        """
+        try:
+            return self._cidrs != other._cidrs
+        except AttributeError:
+            return NotImplemented
+
+    def __lt__(self, other):
+        """
+        :param other: an IP set
+
+        :return: ``True`` if this IP set is less than the ``other`` IP set,
+            ``False`` otherwise.
+        """
+        if not hasattr(other, '_cidrs'):
+            return NotImplemented
+
+        return self.size < other.size and self.issubset(other)
+
+    def issubset(self, other):
+        """
+        :param other: an IP set.
+
+        :return: ``True`` if every IP address and subnet in this IP set
+            is found within ``other``.
+        """
+        for cidr in self._cidrs:
+            if cidr not in other:
+                return False
+        return True
+
+    __le__ = issubset
+
+    def __gt__(self, other):
+        """
+        :param other: an IP set.
+
+        :return: ``True`` if this IP set is greater than the ``other`` IP set,
+            ``False`` otherwise.
+        """
+        if not hasattr(other, '_cidrs'):
+            return NotImplemented
+
+        return self.size > other.size and self.issuperset(other)
+
+    def issuperset(self, other):
+        """
+        :param other: an IP set.
+
+        :return: ``True`` if every IP address and subnet in other IP set
+            is found within this one.
+        """
+        if not hasattr(other, '_cidrs'):
+            return NotImplemented
+
+        for cidr in other._cidrs:
+            if cidr not in self:
+                return False
+        return True
+
+    __ge__ = issuperset
+
+    def union(self, other):
+        """
+        :param other: an IP set.
+
+        :return: the union of this IP set and another as a new IP set
+            (combines IP addresses and subnets from both sets).
+        """
+        ip_set = self.copy()
+        ip_set.update(other)
+        return ip_set
+
+    __or__ = union
+
+    def intersection(self, other):
+        """
+        :param other: an IP set.
+
+        :return: the intersection of this IP set and another as a new IP set.
+            (IP addresses and subnets common to both sets).
+        """
+        result_cidrs = {}
+
+        own_nets = sorted(self._cidrs)
+        other_nets = sorted(other._cidrs)
+        own_idx = 0
+        other_idx = 0
+        own_len = len(own_nets)
+        other_len = len(other_nets)
+        while own_idx < own_len and other_idx < other_len:
+            own_cur = own_nets[own_idx]
+            other_cur = other_nets[other_idx]
+
+            if own_cur == other_cur:
+                result_cidrs[own_cur] = True
+                own_idx += 1
+                other_idx += 1
+            elif own_cur in other_cur:
+                result_cidrs[own_cur] = True
+                own_idx += 1
+            elif other_cur in own_cur:
+                result_cidrs[other_cur] = True
+                other_idx += 1
+            else:
+                # own_cur and other_cur have nothing in common
+                if own_cur < other_cur:
+                    own_idx += 1
+                else:
+                    other_idx += 1
+
+        # We ran out of networks in own_nets or other_nets. Either way, there
+        # can be no further result_cidrs.
+        result = IPSet()
+        result._cidrs = result_cidrs
+        return result
+
+    __and__ = intersection
+
+    def symmetric_difference(self, other):
+        """
+        :param other: an IP set.
+
+        :return: the symmetric difference of this IP set and another as a new
+            IP set (all IP addresses and subnets that are in exactly one
+            of the sets).
+        """
+        # In contrast to intersection() and difference(), we cannot construct
+        # the result_cidrs easily. Some cidrs may have to be merged, e.g. for
+        # IPSet(["10.0.0.0/32"]).symmetric_difference(IPSet(["10.0.0.1/32"])).
+        result_ranges = []
+
+        own_nets = sorted(self._cidrs)
+        other_nets = sorted(other._cidrs)
+        own_idx = 0
+        other_idx = 0
+        own_len = len(own_nets)
+        other_len = len(other_nets)
+        while own_idx < own_len and other_idx < other_len:
+            own_cur = own_nets[own_idx]
+            other_cur = other_nets[other_idx]
+
+            if own_cur == other_cur:
+                own_idx += 1
+                other_idx += 1
+            elif own_cur in other_cur:
+                own_idx = _subtract(other_cur, own_nets, own_idx, result_ranges)
+                other_idx += 1
+            elif other_cur in own_cur:
+                other_idx = _subtract(own_cur, other_nets, other_idx, result_ranges)
+                own_idx += 1
+            else:
+                # own_cur and other_cur have nothing in common
+                if own_cur < other_cur:
+                    result_ranges.append( (own_cur._module.version,
+                            own_cur.first, own_cur.last) )
+                    own_idx += 1
+                else:
+                    result_ranges.append( (other_cur._module.version,
+                            other_cur.first, other_cur.last) )
+                    other_idx += 1
+
+        # If the above loop terminated because it processed all cidrs of
+        # "other", then any remaining cidrs in self must be part of the result.
+        while own_idx < own_len:
+            own_cur = own_nets[own_idx]
+            result_ranges.append((own_cur._module.version,
+                    own_cur.first, own_cur.last))
+            own_idx += 1
+
+        # If the above loop terminated because it processed all cidrs of
+        # self, then any remaining cidrs in "other" must be part of the result.
+        while other_idx < other_len:
+            other_cur = other_nets[other_idx]
+            result_ranges.append((other_cur._module.version,
+                    other_cur.first, other_cur.last))
+            other_idx += 1
+
+        result = IPSet()
+        for start, stop in _iter_merged_ranges(result_ranges):
+            cidrs = iprange_to_cidrs(start, stop)
+            for cidr in cidrs:
+                result._cidrs[cidr] = True
+        return result
+
+    __xor__ = symmetric_difference
+
+    def difference(self, other):
+        """
+        :param other: an IP set.
+
+        :return: the difference between this IP set and another as a new IP
+            set (all IP addresses and subnets that are in this IP set but
+            not found in the other.)
+        """
+        result_ranges = []
+        result_cidrs = {}
+
+        own_nets = sorted(self._cidrs)
+        other_nets = sorted(other._cidrs)
+        own_idx = 0
+        other_idx = 0
+        own_len = len(own_nets)
+        other_len = len(other_nets)
+        while own_idx < own_len and other_idx < other_len:
+            own_cur = own_nets[own_idx]
+            other_cur = other_nets[other_idx]
+
+            if own_cur == other_cur:
+                own_idx += 1
+                other_idx += 1
+            elif own_cur in other_cur:
+                own_idx += 1
+            elif other_cur in own_cur:
+                other_idx = _subtract(own_cur, other_nets, other_idx,
+                        result_ranges)
+                own_idx += 1
+            else:
+                # own_cur and other_cur have nothing in common
+                if own_cur < other_cur:
+                    result_cidrs[own_cur] = True
+                    own_idx += 1
+                else:
+                    other_idx += 1
+
+        # If the above loop terminated because it processed all cidrs of
+        # "other", then any remaining cidrs in self must be part of the result.
+        while own_idx < own_len:
+            result_cidrs[own_nets[own_idx]] = True
+            own_idx += 1
+
+        for start, stop in _iter_merged_ranges(result_ranges):
+            for cidr in iprange_to_cidrs(start, stop):
+                result_cidrs[cidr] = True
+
+        result = IPSet()
+        result._cidrs = result_cidrs
+        return result
+
+    __sub__ = difference
+
+    def __len__(self):
+        """
+        :return: the cardinality of this IP set (i.e. sum of individual IP \
+            addresses). Raises ``IndexError`` if size > maxint (a Python \
+            limitation). Use the .size property for subnets of any size.
+        """
+        size = self.size
+        if size > _sys_maxint:
+            raise IndexError("range contains more than %d (sys.maxint) " \
+                "IP addresses! Use the .size property instead." % _sys_maxint)
+        return size
+
+    @property
+    def size(self):
+        """
+        The cardinality of this IP set (based on the number of individual IP
+        addresses including those implicitly defined in subnets).
+        """
+        return sum([cidr.size for cidr in self._cidrs])
+
+    def __repr__(self):
+        """:return: Python statement to create an equivalent object"""
+        return 'IPSet(%r)' % [str(c) for c in sorted(self._cidrs)]
+
+    __str__ = __repr__
+
+    def iscontiguous(self):
+        """
+        Returns True if the members of the set form a contiguous IP
+        address range (with no gaps), False otherwise.
+
+        :return: ``True`` if the ``IPSet`` object is contiguous.
+        """
+        cidrs = self.iter_cidrs()
+        if len(cidrs) > 1:
+            previous = cidrs[0][0]
+            for cidr in cidrs:
+                if cidr[0] != previous:
+                    return False
+                previous = cidr[-1] + 1
+        return True
+
+    def iprange(self):
+        """
+        Generates an IPRange for this IPSet, if all its members
+        form a single contiguous sequence.
+
+        Raises ``ValueError`` if the set is not contiguous.
+
+        :return: An ``IPRange`` for all IPs in the IPSet.
+        """
+        if self.iscontiguous():
+            cidrs = self.iter_cidrs()
+            if not cidrs:
+                return None
+            return IPRange(cidrs[0][0], cidrs[-1][-1])
+        else:
+            raise ValueError("IPSet is not contiguous")
+
+    def iter_ipranges(self):
+        """Generate the merged IPRanges for this IPSet.
+
+        In contrast to self.iprange(), this will work even when the IPSet is
+        not contiguous. Adjacent IPRanges will be merged together, so you
+        get the minimal number of IPRanges.
+        """
+        sorted_ranges = [(cidr._module.version, cidr.first, cidr.last) for
+                cidr in self.iter_cidrs()]
+
+        for start, stop in _iter_merged_ranges(sorted_ranges):
+            yield IPRange(start, stop)

netaddr/strategy/__init__.py

@@ -0,0 +1,273 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+Shared logic for various address types.
+"""
+import re as _re
+
+from netaddr.compat import _range, _is_str
+
+
+def bytes_to_bits():
+    """
+    :return: A 256 element list containing 8-bit binary digit strings. The
+        list index value is equivalent to its bit string value.
+    """
+    lookup = []
+    bits_per_byte = _range(7, -1, -1)
+    for num in range(256):
+        bits = 8 * [None]
+        for i in bits_per_byte:
+            bits[i] = '01'[num & 1]
+            num >>= 1
+        lookup.append(''.join(bits))
+    return lookup
+
+#: A lookup table of 8-bit integer values to their binary digit bit strings.
+BYTES_TO_BITS = bytes_to_bits()
+
+
+def valid_words(words, word_size, num_words):
+    """
+    :param words: A sequence of unsigned integer word values.
+
+    :param word_size: Width (in bits) of each unsigned integer word value.
+
+    :param num_words: Number of unsigned integer words expected.
+
+    :return: ``True`` if word sequence is valid for this address type,
+        ``False`` otherwise.
+    """
+    if not hasattr(words, '__iter__'):
+        return False
+
+    if len(words) != num_words:
+        return False
+
+    max_word = 2 ** word_size - 1
+
+    for i in words:
+        if not 0 <= i <= max_word:
+            return False
+
+    return True
+
+
+def int_to_words(int_val, word_size, num_words):
+    """
+    :param int_val: Unsigned integer to be divided into words of equal size.
+
+    :param word_size: Width (in bits) of each unsigned integer word value.
+
+    :param num_words: Number of unsigned integer words expected.
+
+    :return: A tuple contain unsigned integer word values split according
+        to provided arguments.
+    """
+    max_int = 2 ** (num_words * word_size) - 1
+
+    if not 0 <= int_val <= max_int:
+        raise IndexError('integer out of bounds: %r!' % hex(int_val))
+
+    max_word = 2 ** word_size - 1
+
+    words = []
+    for _ in range(num_words):
+        word = int_val & max_word
+        words.append(int(word))
+        int_val >>= word_size
+
+    return tuple(reversed(words))
+
+
+def words_to_int(words, word_size, num_words):
+    """
+    :param words: A sequence of unsigned integer word values.
+
+    :param word_size: Width (in bits) of each unsigned integer word value.
+
+    :param num_words: Number of unsigned integer words expected.
+
+    :return: An unsigned integer that is equivalent to value represented
+        by word sequence.
+    """
+    if not valid_words(words, word_size, num_words):
+        raise ValueError('invalid integer word sequence: %r!' % words)
+
+    int_val = 0
+    for i, num in enumerate(reversed(words)):
+        word = num
+        word = word << word_size * i
+        int_val = int_val | word
+
+    return int_val
+
+
+def valid_bits(bits, width, word_sep=''):
+    """
+    :param bits: A network address in a delimited binary string format.
+
+    :param width: Maximum width (in bits) of a network address (excluding
+        delimiters).
+
+    :param word_sep: (optional) character or string used to delimit word
+        groups (default: '', no separator).
+
+    :return: ``True`` if network address is valid, ``False`` otherwise.
+    """
+    if not _is_str(bits):
+        return False
+
+    if word_sep != '':
+        bits = bits.replace(word_sep, '')
+
+    if len(bits) != width:
+        return False
+
+    max_int = 2 ** width - 1
+
+    try:
+        if 0 <= int(bits, 2) <= max_int:
+            return True
+    except ValueError:
+        pass
+
+    return False
+
+
+def bits_to_int(bits, width, word_sep=''):
+    """
+    :param bits: A network address in a delimited binary string format.
+
+    :param width: Maximum width (in bits) of a network address (excluding
+        delimiters).
+
+    :param word_sep: (optional) character or string used to delimit word
+        groups (default: '', no separator).
+
+    :return: An unsigned integer that is equivalent to value represented
+        by network address in readable binary form.
+    """
+    if not valid_bits(bits, width, word_sep):
+        raise ValueError('invalid readable binary string: %r!' % bits)
+
+    if word_sep != '':
+        bits = bits.replace(word_sep, '')
+
+    return int(bits, 2)
+
+
+def int_to_bits(int_val, word_size, num_words, word_sep=''):
+    """
+    :param int_val: An unsigned integer.
+
+    :param word_size: Width (in bits) of each unsigned integer word value.
+
+    :param num_words: Number of unsigned integer words expected.
+
+    :param word_sep: (optional) character or string used to delimit word
+        groups (default: '', no separator).
+
+    :return: A network address in a delimited binary string format that is
+        equivalent in value to unsigned integer.
+    """
+    bit_words = []
+
+    for word in int_to_words(int_val, word_size, num_words):
+        bits = []
+        while word:
+            bits.append(BYTES_TO_BITS[word & 255])
+            word >>= 8
+        bits.reverse()
+        bit_str = ''.join(bits) or '0' * word_size
+        bits = ('0' * word_size + bit_str)[-word_size:]
+        bit_words.append(bits)
+
+    if word_sep is not '':
+        #   Check custom separator.
+        if not _is_str(word_sep):
+            raise ValueError('word separator is not a string: %r!' % word_sep)
+
+    return word_sep.join(bit_words)
+
+
+def valid_bin(bin_val, width):
+    """
+    :param bin_val: A network address in Python's binary representation format
+        ('0bxxx').
+
+    :param width: Maximum width (in bits) of a network address (excluding
+        delimiters).
+
+    :return: ``True`` if network address is valid, ``False`` otherwise.
+    """
+    if not _is_str(bin_val):
+        return False
+
+    if not bin_val.startswith('0b'):
+        return False
+
+    bin_val = bin_val.replace('0b', '')
+
+    if len(bin_val) > width:
+        return False
+
+    max_int = 2 ** width - 1
+
+    try:
+        if 0 <= int(bin_val, 2) <= max_int:
+            return True
+    except ValueError:
+        pass
+
+    return False
+
+
+def int_to_bin(int_val, width):
+    """
+    :param int_val: An unsigned integer.
+
+    :param width: Maximum allowed width (in bits) of a unsigned integer.
+
+    :return: Equivalent string value in Python's binary representation format
+        ('0bxxx').
+    """
+    bin_tokens = []
+
+    try:
+        #   Python 2.6.x and upwards.
+        bin_val = bin(int_val)
+    except NameError:
+        #   Python 2.4.x and 2.5.x
+        i = int_val
+        while i > 0:
+            word = i & 0xff
+            bin_tokens.append(BYTES_TO_BITS[word])
+            i >>= 8
+
+        bin_tokens.reverse()
+        bin_val = '0b' + _re.sub(r'^[0]+([01]+)$', r'\1', ''.join(bin_tokens))
+
+    if len(bin_val[2:]) > width:
+        raise IndexError('binary string out of bounds: %s!' % bin_val)
+
+    return bin_val
+
+
+def bin_to_int(bin_val, width):
+    """
+    :param bin_val: A string containing an unsigned integer in Python's binary
+        representation format ('0bxxx').
+
+    :param width: Maximum allowed width (in bits) of a unsigned integer.
+
+    :return: An unsigned integer that is equivalent to value represented
+        by Python binary string format.
+    """
+    if not valid_bin(bin_val, width):
+        raise ValueError('not a valid Python binary string: %r!' % bin_val)
+
+    return int(bin_val.replace('0b', ''), 2)

netaddr/strategy/eui48.py

@@ -0,0 +1,296 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+IEEE 48-bit EUI (MAC address) logic.
+
+Supports numerous MAC string formats including Cisco's triple hextet as well
+as bare MACs containing no delimiters.
+"""
+import struct as _struct
+import re as _re
+
+#   Check whether we need to use fallback code or not.
+try:
+    from socket import AF_LINK
+except ImportError:
+    AF_LINK = 48
+
+from netaddr.core import AddrFormatError
+from netaddr.strategy import \
+    valid_words  as _valid_words, \
+    int_to_words as _int_to_words, \
+    words_to_int as _words_to_int, \
+    valid_bits   as _valid_bits, \
+    bits_to_int  as _bits_to_int, \
+    int_to_bits  as _int_to_bits, \
+    valid_bin    as _valid_bin, \
+    int_to_bin   as _int_to_bin, \
+    bin_to_int   as _bin_to_int
+from netaddr.compat import _is_str
+
+#: The width (in bits) of this address type.
+width = 48
+
+#: The AF_* constant value of this address type.
+family = AF_LINK
+
+#: A friendly string name address type.
+family_name = 'MAC'
+
+#: The version of this address type.
+version = 48
+
+#: The maximum integer value that can be represented by this address type.
+max_int = 2 ** width - 1
+
+#-----------------------------------------------------------------------------
+#   Dialect classes.
+#-----------------------------------------------------------------------------
+
+class mac_eui48(object):
+    """A standard IEEE EUI-48 dialect class."""
+    #: The individual word size (in bits) of this address type.
+    word_size = 8
+
+    #: The number of words in this address type.
+    num_words = width // word_size
+
+    #: The maximum integer value for an individual word in this address type.
+    max_word = 2 ** word_size - 1
+
+    #: The separator character used between each word.
+    word_sep = '-'
+
+    #: The format string to be used when converting words to string values.
+    word_fmt = '%.2X'
+
+    #: The number base to be used when interpreting word values as integers.
+    word_base = 16
+
+class mac_unix(mac_eui48):
+    """A UNIX-style MAC address dialect class."""
+    word_size = 8
+    num_words = width // word_size
+    word_sep  = ':'
+    word_fmt  = '%x'
+    word_base = 16
+
+class mac_unix_expanded(mac_unix):
+    """A UNIX-style MAC address dialect class with leading zeroes."""
+    word_fmt  = '%.2x'
+
+class mac_cisco(mac_eui48):
+    """A Cisco 'triple hextet' MAC address dialect class."""
+    word_size = 16
+    num_words = width // word_size
+    word_sep  = '.'
+    word_fmt  = '%.4x'
+    word_base = 16
+
+class mac_bare(mac_eui48):
+    """A bare (no delimiters) MAC address dialect class."""
+    word_size = 48
+    num_words = width // word_size
+    word_sep  = ''
+    word_fmt  = '%.12X'
+    word_base = 16
+
+class mac_pgsql(mac_eui48):
+    """A PostgreSQL style (2 x 24-bit words) MAC address dialect class."""
+    word_size = 24
+    num_words = width // word_size
+    word_sep  = ':'
+    word_fmt  = '%.6x'
+    word_base = 16
+
+#: The default dialect to be used when not specified by the user.
+DEFAULT_DIALECT = mac_eui48
+
+#-----------------------------------------------------------------------------
+#: Regular expressions to match all supported MAC address formats.
+RE_MAC_FORMATS = (
+    #   2 bytes x 6 (UNIX, Windows, EUI-48)
+    '^' + ':'.join(['([0-9A-F]{1,2})'] * 6) + '$',
+    '^' + '-'.join(['([0-9A-F]{1,2})'] * 6) + '$',
+
+    #   4 bytes x 3 (Cisco)
+    '^' + ':'.join(['([0-9A-F]{1,4})'] * 3) + '$',
+    '^' + '-'.join(['([0-9A-F]{1,4})'] * 3) + '$',
+    '^' + '\.'.join(['([0-9A-F]{1,4})'] * 3) + '$',
+
+    #   6 bytes x 2 (PostgreSQL)
+    '^' + '-'.join(['([0-9A-F]{5,6})'] * 2) + '$',
+    '^' + ':'.join(['([0-9A-F]{5,6})'] * 2) + '$',
+
+    #   12 bytes (bare, no delimiters)
+    '^(' + ''.join(['[0-9A-F]'] * 12) + ')$',
+    '^(' + ''.join(['[0-9A-F]'] * 11) + ')$',
+)
+#   For efficiency, each string regexp converted in place to its compiled
+#   counterpart.
+RE_MAC_FORMATS = [_re.compile(_, _re.IGNORECASE) for _ in RE_MAC_FORMATS]
+
+
+def valid_str(addr):
+    """
+    :param addr: An IEEE EUI-48 (MAC) address in string form.
+
+    :return: ``True`` if MAC address string is valid, ``False`` otherwise.
+    """
+    for regexp in RE_MAC_FORMATS:
+        try:
+            match_result = regexp.findall(addr)
+            if len(match_result) != 0:
+                return True
+        except TypeError:
+            pass
+
+    return False
+
+
+def str_to_int(addr):
+    """
+    :param addr: An IEEE EUI-48 (MAC) address in string form.
+
+    :return: An unsigned integer that is equivalent to value represented
+        by EUI-48/MAC string address formatted according to the dialect
+        settings.
+    """
+    words = []
+    if _is_str(addr):
+        found_match = False
+        for regexp in RE_MAC_FORMATS:
+            match_result = regexp.findall(addr)
+            if len(match_result) != 0:
+                found_match = True
+                if isinstance(match_result[0], tuple):
+                    words = match_result[0]
+                else:
+                    words = (match_result[0],)
+                break
+        if not found_match:
+            raise AddrFormatError('%r is not a supported MAC format!' % addr)
+    else:
+        raise TypeError('%r is not str() or unicode()!' % addr)
+
+    int_val = None
+
+    if len(words) == 6:
+        #   2 bytes x 6 (UNIX, Windows, EUI-48)
+        int_val = int(''.join(['%.2x' % int(w, 16) for w in words]), 16)
+    elif len(words) == 3:
+        #   4 bytes x 3 (Cisco)
+        int_val = int(''.join(['%.4x' % int(w, 16) for w in words]), 16)
+    elif len(words) == 2:
+        #   6 bytes x 2 (PostgreSQL)
+        int_val = int(''.join(['%.6x' % int(w, 16) for w in words]), 16)
+    elif len(words) == 1:
+        #   12 bytes (bare, no delimiters)
+        int_val = int('%012x' % int(words[0], 16), 16)
+    else:
+        raise AddrFormatError('unexpected word count in MAC address %r!' \
+            % addr)
+
+    return int_val
+
+
+def int_to_str(int_val, dialect=None):
+    """
+    :param int_val: An unsigned integer.
+
+    :param dialect: (optional) a Python class defining formatting options.
+
+    :return: An IEEE EUI-48 (MAC) address string that is equivalent to
+        unsigned integer formatted according to the dialect settings.
+    """
+    if dialect is None:
+        dialect = mac_eui48
+
+    words = int_to_words(int_val, dialect)
+    tokens = [dialect.word_fmt % i for i in words]
+    addr = dialect.word_sep.join(tokens)
+
+    return addr
+
+
+def int_to_packed(int_val):
+    """
+    :param int_val: the integer to be packed.
+
+    :return: a packed string that is equivalent to value represented by an
+    unsigned integer.
+    """
+    return _struct.pack(">HI", int_val >> 32, int_val & 0xffffffff)
+
+
+def packed_to_int(packed_int):
+    """
+    :param packed_int: a packed string containing an unsigned integer.
+        It is assumed that string is packed in network byte order.
+
+    :return: An unsigned integer equivalent to value of network address
+        represented by packed binary string.
+    """
+    words = list(_struct.unpack('>6B', packed_int))
+
+    int_val = 0
+    for i, num in enumerate(reversed(words)):
+        word = num
+        word = word << 8 * i
+        int_val = int_val | word
+
+    return int_val
+
+
+def valid_words(words, dialect=None):
+    if dialect is None:
+        dialect = DEFAULT_DIALECT
+    return _valid_words(words, dialect.word_size, dialect.num_words)
+
+
+def int_to_words(int_val, dialect=None):
+    if dialect is None:
+        dialect = DEFAULT_DIALECT
+    return _int_to_words(int_val, dialect.word_size, dialect.num_words)
+
+
+def words_to_int(words, dialect=None):
+    if dialect is None:
+        dialect = DEFAULT_DIALECT
+    return _words_to_int(words, dialect.word_size, dialect.num_words)
+
+
+def valid_bits(bits, dialect=None):
+    if dialect is None:
+        dialect = DEFAULT_DIALECT
+    return _valid_bits(bits, width, dialect.word_sep)
+
+
+def bits_to_int(bits, dialect=None):
+    if dialect is None:
+        dialect = DEFAULT_DIALECT
+    return _bits_to_int(bits, width, dialect.word_sep)
+
+
+def int_to_bits(int_val, dialect=None):
+    if dialect is None:
+        dialect = DEFAULT_DIALECT
+    return _int_to_bits(int_val, dialect.word_size, dialect.num_words,
+        dialect.word_sep)
+
+
+def valid_bin(bin_val, dialect=None):
+    if dialect is None:
+        dialect = DEFAULT_DIALECT
+    return _valid_bin(bin_val, width)
+
+
+def int_to_bin(int_val):
+    return _int_to_bin(int_val, width)
+
+
+def bin_to_int(bin_val):
+    return _bin_to_int(bin_val, width)

netaddr/strategy/eui64.py

@@ -0,0 +1,184 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+IEEE 64-bit EUI (Extended Unique Indentifier) logic.
+"""
+import struct as _struct
+import re as _re
+
+#   This is a fake constant that doesn't really exist. Here for completeness.
+AF_EUI64 = 64
+
+from netaddr.core import AddrFormatError
+from netaddr.strategy import \
+    valid_words  as _valid_words, \
+    int_to_words as _int_to_words, \
+    words_to_int as _words_to_int, \
+    valid_bits   as _valid_bits, \
+    bits_to_int  as _bits_to_int, \
+    int_to_bits  as _int_to_bits, \
+    valid_bin    as _valid_bin, \
+    int_to_bin   as _int_to_bin, \
+    bin_to_int   as _bin_to_int
+
+#: The width (in bits) of this address type.
+width = 64
+
+#: The individual word size (in bits) of this address type.
+word_size = 8
+
+#: The format string to be used when converting words to string values.
+word_fmt = '%.2X'
+
+#: The separator character used between each word.
+word_sep = '-'
+
+#: The AF_* constant value of this address type.
+family = AF_EUI64
+
+#: A friendly string name address type.
+family_name = 'EUI-64'
+
+#: The version of this address type.
+version = 64
+
+#: The number base to be used when interpreting word values as integers.
+word_base = 16
+
+#: The maximum integer value that can be represented by this address type.
+max_int = 2 ** width - 1
+
+#: The number of words in this address type.
+num_words = width // word_size
+
+#: The maximum integer value for an individual word in this address type.
+max_word = 2 ** word_size - 1
+
+#: Compiled regular expression for detecting value EUI-64 identifiers.
+RE_EUI64_FORMAT = _re.compile('^' + '-'.join(['([0-9A-F]{1,2})'] * 8) + '$',
+    _re.IGNORECASE)
+
+
+def valid_str(addr):
+    """
+    :param addr: An IEEE EUI-64 indentifier in string form.
+
+    :return: ``True`` if EUI-64 indentifier is valid, ``False`` otherwise.
+    """
+    try:
+        match_result = RE_EUI64_FORMAT.findall(addr)
+        if len(match_result) != 0:
+            return True
+    except TypeError:
+        pass
+
+    return False
+
+
+def str_to_int(addr):
+    """
+    :param addr: An IEEE EUI-64 indentifier in string form.
+
+    :return: An unsigned integer that is equivalent to value represented
+        by EUI-64 string identifier.
+    """
+    words = []
+
+    try:
+        match_result = RE_EUI64_FORMAT.findall(addr)
+        if not match_result:
+            raise TypeError
+    except TypeError:
+        raise AddrFormatError('invalid IEEE EUI-64 identifier: %r!' % addr)
+
+    words = match_result[0]
+
+    if len(words) != num_words:
+        raise AddrFormatError('bad word count for EUI-64 identifier: %r!' \
+            % addr)
+
+    return int(''.join(['%.2x' % int(w, 16) for w in words]), 16)
+
+
+def int_to_str(int_val, dialect=None):
+    """
+    :param int_val: An unsigned integer.
+
+    :param dialect: (optional) a Python class defining formatting options
+        (Please Note - not currently in use).
+
+    :return: An IEEE EUI-64 identifier that is equivalent to unsigned integer.
+    """
+    words = int_to_words(int_val)
+    tokens = [word_fmt % i for i in words]
+    addr = word_sep.join(tokens)
+    return addr
+
+
+def int_to_packed(int_val):
+    """
+    :param int_val: the integer to be packed.
+
+    :return: a packed string that is equivalent to value represented by an
+    unsigned integer.
+    """
+    words = int_to_words(int_val)
+    return _struct.pack('>8B', *words)
+
+
+def packed_to_int(packed_int):
+    """
+    :param packed_int: a packed string containing an unsigned integer.
+        It is assumed that string is packed in network byte order.
+
+    :return: An unsigned integer equivalent to value of network address
+        represented by packed binary string.
+    """
+    words = list(_struct.unpack('>8B', packed_int))
+
+    int_val = 0
+    for i, num in enumerate(reversed(words)):
+        word = num
+        word = word << 8 * i
+        int_val = int_val | word
+
+    return int_val
+
+
+def valid_words(words, dialect=None):
+    return _valid_words(words, word_size, num_words)
+
+
+def int_to_words(int_val, dialect=None):
+    return _int_to_words(int_val, word_size, num_words)
+
+
+def words_to_int(words, dialect=None):
+    return _words_to_int(words, word_size, num_words)
+
+
+def valid_bits(bits, dialect=None):
+    return _valid_bits(bits, width, word_sep)
+
+
+def bits_to_int(bits, dialect=None):
+    return _bits_to_int(bits, width, word_sep)
+
+
+def int_to_bits(int_val, dialect=None):
+    return _int_to_bits(int_val, word_size, num_words, word_sep)
+
+
+def valid_bin(bin_val):
+    return _valid_bin(bin_val, width)
+
+
+def int_to_bin(int_val):
+    return _int_to_bin(int_val, width)
+
+
+def bin_to_int(bin_val):
+    return _bin_to_int(bin_val, width)

netaddr/strategy/ipv4.py

@@ -0,0 +1,283 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""IPv4 address logic."""
+
+import sys as _sys
+import struct as _struct
+
+from socket import inet_aton as _inet_aton
+#   Check whether we need to use fallback code or not.
+if _sys.platform in ('win32', 'cygwin'):
+    #   inet_pton() not available on Windows. inet_pton() under cygwin
+    #   behaves exactly like inet_aton() and is therefore highly unreliable.
+    from netaddr.fbsocket import inet_pton as _inet_pton, AF_INET
+else:
+    #   All other cases, use all functions from the socket module.
+    from socket import inet_pton as _inet_pton, AF_INET
+
+from netaddr.core import AddrFormatError, ZEROFILL, INET_PTON
+
+from netaddr.strategy import valid_words  as _valid_words, \
+    valid_bits   as _valid_bits, \
+    bits_to_int  as _bits_to_int, \
+    int_to_bits  as _int_to_bits, \
+    valid_bin    as _valid_bin, \
+    int_to_bin   as _int_to_bin, \
+    bin_to_int   as _bin_to_int
+
+from netaddr.compat import _str_type
+
+#: The width (in bits) of this address type.
+width = 32
+
+#: The individual word size (in bits) of this address type.
+word_size = 8
+
+#: The format string to be used when converting words to string values.
+word_fmt = '%d'
+
+#: The separator character used between each word.
+word_sep = '.'
+
+#: The AF_* constant value of this address type.
+family = AF_INET
+
+#: A friendly string name address type.
+family_name = 'IPv4'
+
+#: The version of this address type.
+version = 4
+
+#: The number base to be used when interpreting word values as integers.
+word_base = 10
+
+#: The maximum integer value that can be represented by this address type.
+max_int = 2 ** width - 1
+
+#: The number of words in this address type.
+num_words = width // word_size
+
+#: The maximum integer value for an individual word in this address type.
+max_word = 2 ** word_size - 1
+
+#: A dictionary mapping IPv4 CIDR prefixes to the equivalent netmasks.
+prefix_to_netmask = dict(
+    [(i, max_int ^ (2 ** (width - i) - 1)) for i in range(0, width+1)])
+
+#: A dictionary mapping IPv4 netmasks to their equivalent CIDR prefixes.
+netmask_to_prefix = dict(
+    [(max_int ^ (2 ** (width - i) - 1), i) for i in range(0, width+1)])
+
+#: A dictionary mapping IPv4 CIDR prefixes to the equivalent hostmasks.
+prefix_to_hostmask = dict(
+    [(i, (2 ** (width - i) - 1)) for i in range(0, width+1)])
+
+#: A dictionary mapping IPv4 hostmasks to their equivalent CIDR prefixes.
+hostmask_to_prefix = dict(
+    [((2 ** (width - i) - 1), i) for i in range(0, width+1)])
+
+
+def valid_str(addr, flags=0):
+    """
+    :param addr: An IPv4 address in presentation (string) format.
+
+    :param flags: decides which rules are applied to the interpretation of the
+        addr value. Supported constants are INET_PTON and ZEROFILL. See the
+        netaddr.core docs for details.
+
+    :return: ``True`` if IPv4 address is valid, ``False`` otherwise.
+    """
+    if addr == '':
+        raise AddrFormatError('Empty strings are not supported!')
+
+    validity = True
+
+    if flags & ZEROFILL:
+        addr = '.'.join(['%d' % int(i) for i in addr.split('.')])
+
+    try:
+        if flags & INET_PTON:
+            _inet_pton(AF_INET, addr)
+        else:
+            _inet_aton(addr)
+    except Exception:
+        validity = False
+
+    return validity
+
+
+def str_to_int(addr, flags=0):
+    """
+    :param addr: An IPv4 dotted decimal address in string form.
+
+    :param flags: decides which rules are applied to the interpretation of the
+        addr value. Supported constants are INET_PTON and ZEROFILL. See the
+        netaddr.core docs for details.
+
+    :return: The equivalent unsigned integer for a given IPv4 address.
+    """
+    if flags & ZEROFILL:
+        addr = '.'.join(['%d' % int(i) for i in addr.split('.')])
+
+    try:
+        if flags & INET_PTON:
+            return _struct.unpack('>I', _inet_pton(AF_INET, addr))[0]
+        else:
+            return _struct.unpack('>I', _inet_aton(addr))[0]
+    except Exception:
+        raise AddrFormatError('%r is not a valid IPv4 address string!' % addr)
+
+
+def int_to_str(int_val, dialect=None):
+    """
+    :param int_val: An unsigned integer.
+
+    :param dialect: (unused) Any value passed in is ignored.
+
+    :return: The IPv4 presentation (string) format address equivalent to the
+        unsigned integer provided.
+    """
+    if 0 <= int_val <= max_int:
+        return '%d.%d.%d.%d' % (
+             int_val >> 24,
+            (int_val >> 16) & 0xff,
+            (int_val >>  8) & 0xff,
+             int_val & 0xff)
+    else:
+        raise ValueError('%r is not a valid 32-bit unsigned integer!' \
+            % int_val)
+
+
+def int_to_arpa(int_val):
+    """
+    :param int_val: An unsigned integer.
+
+    :return: The reverse DNS lookup for an IPv4 address in network byte
+        order integer form.
+    """
+    words = ["%d" % i for i in int_to_words(int_val)]
+    words.reverse()
+    words.extend(['in-addr', 'arpa', ''])
+    return '.'.join(words)
+
+
+def int_to_packed(int_val):
+    """
+    :param int_val: the integer to be packed.
+
+    :return: a packed string that is equivalent to value represented by an
+    unsigned integer.
+    """
+    return _struct.pack('>I', int_val)
+
+
+def packed_to_int(packed_int):
+    """
+    :param packed_int: a packed string containing an unsigned integer.
+        It is assumed that string is packed in network byte order.
+
+    :return: An unsigned integer equivalent to value of network address
+        represented by packed binary string.
+    """
+    return _struct.unpack('>I', packed_int)[0]
+
+
+def valid_words(words):
+    return _valid_words(words, word_size, num_words)
+
+
+def int_to_words(int_val):
+    """
+    :param int_val: An unsigned integer.
+
+    :return: An integer word (octet) sequence that is equivalent to value
+        represented by an unsigned integer.
+    """
+    if not 0 <= int_val <= max_int:
+        raise ValueError('%r is not a valid integer value supported ' \
+            'by this address type!' % int_val)
+    return ( int_val >> 24,
+            (int_val >> 16) & 0xff,
+            (int_val >>  8) & 0xff,
+             int_val & 0xff)
+
+
+def words_to_int(words):
+    """
+    :param words: A list or tuple containing integer octets.
+
+    :return: An unsigned integer that is equivalent to value represented
+        by word (octet) sequence.
+    """
+    if not valid_words(words):
+        raise ValueError('%r is not a valid octet list for an IPv4 ' \
+            'address!' % words)
+    return _struct.unpack('>I', _struct.pack('4B', *words))[0]
+
+
+def valid_bits(bits):
+    return _valid_bits(bits, width, word_sep)
+
+
+def bits_to_int(bits):
+    return _bits_to_int(bits, width, word_sep)
+
+
+def int_to_bits(int_val, word_sep=None):
+    if word_sep is None:
+        word_sep = globals()['word_sep']
+    return _int_to_bits(int_val, word_size, num_words, word_sep)
+
+
+def valid_bin(bin_val):
+    return _valid_bin(bin_val, width)
+
+
+def int_to_bin(int_val):
+    return _int_to_bin(int_val, width)
+
+
+def bin_to_int(bin_val):
+    return _bin_to_int(bin_val, width)
+
+
+def expand_partial_address(addr):
+    """
+    Expands a partial IPv4 address into a full 4-octet version.
+
+    :param addr: an partial or abbreviated IPv4 address
+
+    :return: an expanded IP address in presentation format (x.x.x.x)
+
+    """
+    tokens = []
+
+    error = AddrFormatError('invalid partial IPv4 address: %r!' % addr)
+
+    if isinstance(addr, _str_type):
+        if ':' in addr:
+            #   Ignore IPv6 ...
+            raise error
+
+        try:
+            if '.' in addr:
+                tokens = ['%d' % int(o) for o in addr.split('.')]
+            else:
+                tokens = ['%d' % int(addr)]
+        except ValueError:
+            raise error
+
+        if 1 <= len(tokens) <= 4:
+            for i in range(4 - len(tokens)):
+                tokens.append('0')
+        else:
+            raise error
+
+    if not tokens:
+        raise error
+
+    return '%s.%s.%s.%s' % tuple(tokens)
+

netaddr/strategy/ipv6.py

@@ -0,0 +1,266 @@
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""
+IPv6 address logic.
+"""
+import struct as _struct
+
+OPT_IMPORTS = False
+
+#   Check whether we need to use fallback code or not.
+try:
+    import socket as _socket
+    #   These might all generate exceptions on different platforms.
+    if not _socket.has_ipv6:
+        raise Exception('IPv6 disabled')
+    _socket.inet_pton
+    _socket.AF_INET6
+    from _socket import inet_pton as _inet_pton, \
+                        inet_ntop as _inet_ntop, \
+                        AF_INET6
+    OPT_IMPORTS = True
+except Exception:
+    from netaddr.fbsocket import inet_pton as _inet_pton, \
+                                 inet_ntop as _inet_ntop, \
+                                 AF_INET6
+
+from netaddr.core import AddrFormatError
+from netaddr.strategy import \
+    valid_words  as _valid_words, \
+    int_to_words as _int_to_words, \
+    words_to_int as _words_to_int, \
+    valid_bits   as _valid_bits, \
+    bits_to_int  as _bits_to_int, \
+    int_to_bits  as _int_to_bits, \
+    valid_bin    as _valid_bin, \
+    int_to_bin   as _int_to_bin, \
+    bin_to_int   as _bin_to_int
+
+#: The width (in bits) of this address type.
+width = 128
+
+#: The individual word size (in bits) of this address type.
+word_size = 16
+
+#: The separator character used between each word.
+word_sep = ':'
+
+#: The AF_* constant value of this address type.
+family = AF_INET6
+
+#: A friendly string name address type.
+family_name = 'IPv6'
+
+#: The version of this address type.
+version = 6
+
+#: The number base to be used when interpreting word values as integers.
+word_base = 16
+
+#: The maximum integer value that can be represented by this address type.
+max_int = 2 ** width - 1
+
+#: The number of words in this address type.
+num_words = width // word_size
+
+#: The maximum integer value for an individual word in this address type.
+max_word = 2 ** word_size - 1
+
+#: A dictionary mapping IPv6 CIDR prefixes to the equivalent netmasks.
+prefix_to_netmask = dict(
+    [(i, max_int ^ (2 ** (width - i) - 1)) for i in range(0, width+1)])
+
+#: A dictionary mapping IPv6 netmasks to their equivalent CIDR prefixes.
+netmask_to_prefix = dict(
+    [(max_int ^ (2 ** (width - i) - 1), i) for i in range(0, width+1)])
+
+#: A dictionary mapping IPv6 CIDR prefixes to the equivalent hostmasks.
+prefix_to_hostmask = dict(
+    [(i, (2 ** (width - i) - 1)) for i in range(0, width+1)])
+
+#: A dictionary mapping IPv6 hostmasks to their equivalent CIDR prefixes.
+hostmask_to_prefix = dict(
+    [((2 ** (width - i) - 1), i) for i in range(0, width+1)])
+
+#-----------------------------------------------------------------------------
+#   Dialect classes.
+#-----------------------------------------------------------------------------
+
+class ipv6_compact(object):
+    """An IPv6 dialect class - compact form."""
+    #: The format string used to converting words into string values.
+    word_fmt = '%x'
+
+    #: Boolean flag indicating if IPv6 compaction algorithm should be used.
+    compact = True
+
+class ipv6_full(ipv6_compact):
+    """An IPv6 dialect class - 'all zeroes' form."""
+
+    #: Boolean flag indicating if IPv6 compaction algorithm should be used.
+    compact = False
+
+class ipv6_verbose(ipv6_compact):
+    """An IPv6 dialect class - extra wide 'all zeroes' form."""
+
+    #: The format string used to converting words into string values.
+    word_fmt = '%.4x'
+
+    #: Boolean flag indicating if IPv6 compaction algorithm should be used.
+    compact = False
+
+
+def valid_str(addr, flags=0):
+    """
+    :param addr: An IPv6 address in presentation (string) format.
+
+    :param flags: decides which rules are applied to the interpretation of the
+        addr value. Future use - currently has no effect.
+
+    :return: ``True`` if IPv6 address is valid, ``False`` otherwise.
+    """
+    if addr == '':
+        raise AddrFormatError('Empty strings are not supported!')
+
+    try:
+        _inet_pton(AF_INET6, addr)
+    except:
+        return False
+    return True
+
+
+def str_to_int(addr, flags=0):
+    """
+    :param addr: An IPv6 address in string form.
+
+    :param flags: decides which rules are applied to the interpretation of the
+        addr value. Future use - currently has no effect.
+
+    :return: The equivalent unsigned integer for a given IPv6 address.
+    """
+    try:
+        packed_int = _inet_pton(AF_INET6, addr)
+        return packed_to_int(packed_int)
+    except Exception:
+        raise AddrFormatError('%r is not a valid IPv6 address string!' % addr)
+
+
+def int_to_str(int_val, dialect=None):
+    """
+    :param int_val: An unsigned integer.
+
+    :param dialect: (optional) a Python class defining formatting options.
+
+    :return: The IPv6 presentation (string) format address equivalent to the
+        unsigned integer provided.
+    """
+    if dialect is None:
+        dialect = ipv6_compact
+
+    addr = None
+
+    try:
+        packed_int = int_to_packed(int_val)
+        if dialect.compact:
+            #   Default return value.
+            addr = _inet_ntop(AF_INET6, packed_int)
+        else:
+            #   Custom return value.
+            words = list(_struct.unpack('>8H', packed_int))
+            tokens = [dialect.word_fmt % word for word in words]
+            addr = word_sep.join(tokens)
+    except Exception:
+        raise ValueError('%r is not a valid 128-bit unsigned integer!' \
+            % int_val)
+
+    return addr
+
+
+def int_to_arpa(int_val):
+    """
+    :param int_val: An unsigned integer.
+
+    :return: The reverse DNS lookup for an IPv6 address in network byte
+        order integer form.
+    """
+    addr = int_to_str(int_val, ipv6_verbose)
+    tokens = list(addr.replace(':', ''))
+    tokens.reverse()
+    #   We won't support ip6.int here - see RFC 3152 for details.
+    tokens = tokens + ['ip6', 'arpa', '']
+    return '.'.join(tokens)
+
+
+def int_to_packed(int_val):
+    """
+    :param int_val: the integer to be packed.
+
+    :return: a packed string that is equivalent to value represented by an
+    unsigned integer.
+    """
+    words = int_to_words(int_val, 4, 32)
+    return _struct.pack('>4I', *words)
+
+
+def packed_to_int(packed_int):
+    """
+    :param packed_int: a packed string containing an unsigned integer.
+        It is assumed that string is packed in network byte order.
+
+    :return: An unsigned integer equivalent to value of network address
+        represented by packed binary string.
+    """
+    words = list(_struct.unpack('>4I', packed_int))
+
+    int_val = 0
+    for i, num in enumerate(reversed(words)):
+        word = num
+        word = word << 32 * i
+        int_val = int_val | word
+
+    return int_val
+
+
+def valid_words(words):
+    return _valid_words(words, word_size, num_words)
+
+
+def int_to_words(int_val, num_words=None, word_size=None):
+    if num_words is None:
+        num_words = globals()['num_words']
+    if word_size is None:
+        word_size = globals()['word_size']
+    return _int_to_words(int_val, word_size, num_words)
+
+
+def words_to_int(words):
+    return _words_to_int(words, word_size, num_words)
+
+
+def valid_bits(bits):
+    return _valid_bits(bits, width, word_sep)
+
+
+def bits_to_int(bits):
+    return _bits_to_int(bits, width, word_sep)
+
+
+def int_to_bits(int_val, word_sep=None):
+    if word_sep is None:
+        word_sep = globals()['word_sep']
+    return _int_to_bits(int_val, word_size, num_words, word_sep)
+
+
+def valid_bin(bin_val):
+    return _valid_bin(bin_val, width)
+
+
+def int_to_bin(int_val):
+    return _int_to_bin(int_val, width)
+
+
+def bin_to_int(bin_val):
+    return _bin_to_int(bin_val, width)

netaddr/tests/2.x/core/compat.txt

@@ -0,0 +1,107 @@
+=Python 2.x and 3.x compatibility tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.compat import _sys_maxint, _is_str, _is_int, _callable
+
+>>> from netaddr.compat import _func_doc, _dict_keys, _dict_items
+
+>>> from netaddr.compat import _iter_dict_keys, _bytes_join, _zip, _range
+
+>>> from netaddr.compat import _iter_range, _func_name, _func_doc
+
+#   string and integer detection tests.
+>>> _is_int(_sys_maxint)
+True
+
+>>> _is_str(_sys_maxint)
+False
+
+>>> _is_str('')
+True
+
+>>> _is_str(''.encode())
+True
+
+>>> _is_str(unicode(''))
+True
+
+#   Python 2.x - 8 bit strings are just regular strings
+>>> str_8bit = _bytes_join(['a', 'b', 'c'])
+
+>>> str_8bit == 'abc'.encode()
+True
+
+>>> "'abc'" == '%r' % str_8bit
+True
+
+#   dict operation tests.
+>>> d = { 'a' : 0, 'b' : 1, 'c' : 2 }
+
+>>> sorted(_dict_keys(d)) == ['a', 'b', 'c']
+True
+
+>>> sorted(_dict_items(d)) == [('a', 0), ('b', 1), ('c', 2)]
+True
+
+#   zip() BIF tests.
+>>> l2 = _zip([0], [1])
+
+>>> hasattr(_zip(l2), 'pop')
+True
+
+>>> l2 == [(0, 1)]
+True
+
+#   range/xrange() tests.
+>>> l1 = _range(3)
+
+>>> isinstance(l1, list)
+True
+
+>>> hasattr(l1, 'pop')
+True
+
+>>> l1 == [0, 1, 2]
+True
+
+>>> it = _iter_range(3)
+
+>>> isinstance(it, list)
+False
+
+>>> hasattr(it, '__iter__')
+True
+
+>>> it == [0, 1, 2]
+False
+
+>>> list(it) == [0, 1, 2]
+True
+
+#   callable() and function meta-data tests.
+>>> i = 1
+>>> def f1():
+...     """docstring"""
+...     pass
+
+>>> f2 = lambda x: x
+
+>>> _callable(i)
+False
+
+>>> _callable(f1)
+True
+
+>>> _callable(f2)
+True
+
+>>> _func_name(f1) == 'f1'
+True
+
+>>> _func_doc(f1) == 'docstring'
+True
+
+}}}

netaddr/tests/2.x/core/pubsub.txt

@@ -0,0 +1,48 @@
+=Publish / Subscribe DP Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+Basic Publisher and Subscriber object tests.
+
+{{{
+
+>>> from netaddr.core import Publisher, Subscriber, PrettyPrinter
+>>> import pprint
+
+>>> class Subject(Publisher):
+...     pass
+
+
+>>> class Observer(Subscriber):
+...     def __init__(self, id):
+...         self.id = id
+...
+...     def update(self, data):
+...         return repr(self), pprint.pformat(data)
+...
+...     def __repr__(self):
+...         return '%s(%r)' % (self.__class__.__name__, self.id)
+...
+
+>>> s = Subject()
+
+>>> s.attach(Observer('foo'))
+>>> s.attach(Observer('bar'))
+
+#FIXME: >>> pp = PrettyPrinter()
+#FIXME: >>> s.attach(pp)
+
+>>> data = [{'foo': 42}, {'list': [1,'2', list(range(10))]}, {'strings': ['foo', 'bar', 'baz', 'quux']}]
+>>> s.notify(data)
+
+#FIXME: >>> s.detach(pp)
+>>> s.notify(['foo', 'bar', 'baz'])
+
+>>> s.attach('foo')
+Traceback (most recent call last):
+...
+TypeError: 'foo' does not support required interface!
+
+>>> s.detach('foo')
+
+}}}

netaddr/tests/2.x/eui/eui.txt

@@ -0,0 +1,207 @@
+=IEEE EUI-64 Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+IEEE EUI-64 tests.
+
+{{{
+
+>>> eui = EUI('00-1B-77-FF-FE-49-54-FD')
+>>> eui
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> eui.oui
+OUI('00-1B-77')
+
+>>> eui.ei
+'FF-FE-49-54-FD'
+
+>>> eui.eui64()
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> mac = EUI('00-0F-1F-12-E7-33')
+>>> ip = mac.ipv6_link_local()
+>>> ip
+IPAddress('fe80::20f:1fff:fe12:e733')
+>>> ip.is_link_local()
+True
+
+>>> mac.eui64()
+EUI('00-0F-1F-FF-FE-12-E7-33')
+
+}}}
+
+Individual Address Block tests.
+
+{{{
+
+>>> lower_eui = EUI('00-50-C2-05-C0-00')
+>>> upper_eui = EUI('00-50-C2-05-CF-FF')
+
+>>> lower_eui.is_iab()
+True
+
+>>> str(lower_eui.oui)
+'00-50-C2'
+
+>>> str(lower_eui.iab)
+'00-50-C2-05-C0-00'
+
+>>> lower_eui.ei
+'05-C0-00'
+
+>>> int(lower_eui.oui) == 0x0050c2
+True
+
+>>> int(lower_eui.iab) == 0x0050c205c
+True
+
+>>> upper_eui.is_iab()
+True
+
+>>> str(upper_eui.oui)
+'00-50-C2'
+
+>>> str(upper_eui.iab)
+'00-50-C2-05-C0-00'
+
+>>> upper_eui.ei
+'05-CF-FF'
+
+>>> int(upper_eui.oui) == 0x0050c2
+True
+
+>>> int(upper_eui.iab) == 0x0050c205c
+True
+
+}}}
+
+Constructor tests.
+
+{{{
+
+>>> eui = EUI('00-90-96-AF-CC-39')
+
+>>> eui == EUI('0-90-96-AF-CC-39')
+True
+
+>>> eui == EUI('00-90-96-af-cc-39')
+True
+
+>>> eui == EUI('00:90:96:AF:CC:39')
+True
+
+>>> eui == EUI('00:90:96:af:cc:39')
+True
+
+>>> eui == EUI('0090-96AF-CC39')
+True
+
+>>> eui == EUI('0090:96af:cc39')
+True
+
+>>> eui == EUI('009096-AFCC39')
+True
+
+>>> eui == EUI('009096:AFCC39')
+True
+
+>>> eui == EUI('009096AFCC39')
+True
+
+>>> eui == EUI('009096afcc39')
+True
+
+>>> EUI('01-00-00-00-00-00') == EUI('010000000000')
+True
+
+>>> EUI('01-00-00-00-00-00') == EUI('10000000000')
+True
+
+>>> EUI('01-00-00-01-00-00') == EUI('010000:010000')
+True
+
+>>> EUI('01-00-00-01-00-00') == EUI('10000:10000')
+True
+
+}}}
+
+EUI-48 and EUI-64 indentifiers of the same value are *not* equivalent.
+
+{{{
+
+>>> eui48 = EUI('01-00-00-01-00-00')
+>>> int(eui48) == 1099511693312
+True
+
+>>> eui64 = EUI('00-00-01-00-00-01-00-00')
+>>> int(eui64) == 1099511693312
+True
+
+>>> eui48 == eui64
+False
+
+}}}
+ 
+Sortability
+
+{{{
+
+>>> import random
+
+>>> eui_list = [EUI(0, 64), EUI(0), EUI(0xffffffffffff, dialect=mac_unix), EUI(0x1000000000000)]
+
+>>> random.shuffle(eui_list)
+
+>>> eui_list.sort()
+
+>>> for eui in eui_list:
+... 	str(eui), eui.version
+('00-00-00-00-00-00', 48)
+('ff:ff:ff:ff:ff:ff', 48)
+('00-00-00-00-00-00-00-00', 64)
+('00-01-00-00-00-00-00-00', 64)
+
+}}}
+
+Persistence
+
+{{{
+
+>>> import pickle
+
+>>> eui1 = EUI('00-00-00-01-02-03')
+>>> eui2 = pickle.loads(pickle.dumps(eui1))
+>>> eui1 == eui2
+True
+
+>>> eui1 = EUI('00-00-00-01-02-03', dialect=mac_cisco)
+>>> eui2 = pickle.loads(pickle.dumps(eui1))
+>>> eui1 == eui2
+True
+
+>>> eui1.dialect == eui2.dialect
+True
+
+>>> oui1 = EUI('00-00-00-01-02-03').oui
+>>> oui2 = pickle.loads(pickle.dumps(oui1))
+>>> oui1 == oui2
+True
+>>> oui1.records == oui2.records
+True
+
+>>> iab1 = EUI('00-50-C2-00-1F-FF').iab
+>>> iab2 = pickle.loads(pickle.dumps(iab1))
+>>> iab1 == iab2
+True
+>>> iab1.record == iab2.record
+True
+
+}}}
+

netaddr/tests/2.x/eui/eui64.txt

@@ -0,0 +1,67 @@
+=IEEE EUI-64 Identifier Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Basic operations.
+
+{{{
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+>>> mac
+EUI('00-1B-77-49-54-FD')
+
+>>> eui = mac.eui64()
+>>> eui
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> eui.eui64()
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> int(eui) == 7731765737772285
+True
+
+>>> eui.packed
+'\x00\x1bw\xff\xfeIT\xfd'
+
+>>> eui.bin  
+'0b11011011101111111111111111110010010010101010011111101'
+
+>>> eui.bits()
+'00000000-00011011-01110111-11111111-11111110-01001001-01010100-11111101'
+
+}}}
+
+IPv6 interoperability
+
+{{{
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+
+>>> eui = mac.eui64()
+
+>>> mac
+EUI('00-1B-77-49-54-FD')
+
+>>> eui
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> mac.modified_eui64()
+EUI('02-1B-77-FF-FE-49-54-FD')
+
+>>> mac.ipv6_link_local()
+IPAddress('fe80::21b:77ff:fe49:54fd')
+
+>>> eui.ipv6_link_local()
+IPAddress('fe80::21b:77ff:fe49:54fd')
+
+>>> mac.ipv6(0x12340000000000000000000000000000)
+IPAddress('1234::21b:77ff:fe49:54fd')
+
+>>> eui.ipv6(0x12340000000000000000000000000000)
+IPAddress('1234::21b:77ff:fe49:54fd')

netaddr/tests/2.x/eui/pubsub.txt

@@ -0,0 +1,52 @@
+=IEEE Publish/Subscribe Parser Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+Basic OUIIndexParser and FileIndexer object tests.
+
+{{{ 
+
+>>> from netaddr.eui.ieee import OUIIndexParser, IABIndexParser, FileIndexer
+>>> from cStringIO import StringIO
+
+>>> infile = StringIO()
+>>> outfile = StringIO()
+>>> infile.write("""
+... 00-CA-FE   (hex)        ACME CORPORATION
+... 00CAFE     (base 16)        ACME CORPORATION
+... 				1 MAIN STREET
+... 				SPRINGFIELD
+... 				UNITED STATES
+... """)
+
+>>> infile.seek(0)
+>>> iab_parser = OUIIndexParser(infile)
+>>> iab_parser.attach(FileIndexer(outfile))
+>>> iab_parser.parse()
+>>> print outfile.getvalue(),
+51966,1,210
+
+}}}
+
+Basic IABIndexParser and FileIndexer object tests.
+
+{{{ 
+
+>>> infile = StringIO()
+>>> outfile = StringIO()
+>>> infile.write("""
+... 00-50-C2   (hex)        ACME CORPORATION
+... ABC000-ABCFFF     (base 16)        ACME CORPORATION
+...                 1 MAIN STREET
+...                 SPRINGFIELD
+...                 UNITED STATES
+... """)
+
+>>> infile.seek(0)
+>>> iab_parser = IABIndexParser(infile)
+>>> iab_parser.attach(FileIndexer(outfile))
+>>> iab_parser.parse()
+>>> print outfile.getvalue(),
+84683452,1,181
+
+}}}

netaddr/tests/2.x/eui/tutorial.txt

@@ -0,0 +1,191 @@
+First of all you need to pull the various MAC related classes and functions into your namespace.
+
+.. note:: Do this for the purpose of this tutorial only. In your own code, you should be explicit about the classes, functions and constants you import to avoid name clashes.
+
+>>> from netaddr import *
+
+You can reasonably safely import everything from the netaddr namespace as care has been taken to only export the necessary classes, functions and constants. 
+
+Always hand pick your imports if you are unsure about possible name clashes.
+
+----------------
+Basic operations
+----------------
+
+Instances of the EUI class are used to represent MAC addresses.
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+
+Standard repr() access returns a Python statement that can reconstruct the MAC address object from scratch if executed in the Python interpreter.
+
+>>> mac
+EUI('00-1B-77-49-54-FD')
+
+Accessing the EUI object in the string context.
+
+>>> str(mac)
+'00-1B-77-49-54-FD'
+>>> '%s' % mac
+'00-1B-77-49-54-FD'
+
+Here are a few other common properties.
+
+>>> str(mac), str(mac.oui), mac.ei, mac.version
+('00-1B-77-49-54-FD', '00-1B-77', '49-54-FD', 48)
+
+-------------------------
+Numerical representations
+-------------------------
+
+You can view an individual IP address in various other formats.
+
+>>> int(mac) == 117965411581
+True
+>>> hex(mac)
+'0x1b774954fd'
+>>> oct(mac)
+'01556722252375'
+>>> mac.bits()
+'00000000-00011011-01110111-01001001-01010100-11111101'
+>>> mac.bin
+'0b1101101110111010010010101010011111101'
+
+----------
+Formatting
+----------
+
+It is very common to see MAC address in many different formats other than the standard IEEE EUI-48.
+
+The EUI class constructor handles all these common forms.
+
+>>> EUI('00-1B-77-49-54-FD')
+EUI('00-1B-77-49-54-FD')
+
+IEEE EUI-48 lowercase format
+
+>>> EUI('00-1b-77-49-54-fd')
+EUI('00-1B-77-49-54-FD')
+
+Common UNIX format
+
+>>> EUI('0:1b:77:49:54:fd')
+EUI('00-1B-77-49-54-FD')
+
+Cisco triple hextet format
+
+>>> EUI('001b:7749:54fd')
+EUI('00-1B-77-49-54-FD')
+>>> EUI('1b:7749:54fd')
+EUI('00-1B-77-49-54-FD')
+>>> EUI('1B:7749:54FD')
+EUI('00-1B-77-49-54-FD')
+
+Bare MAC addresses (no delimiters)
+
+>>> EUI('001b774954fd')
+EUI('00-1B-77-49-54-FD')
+>>> EUI('01B774954FD')
+EUI('00-1B-77-49-54-FD')
+
+PostreSQL format (found in documentation)
+
+>>> EUI('001B77:4954FD')
+EUI('00-1B-77-49-54-FD')
+
+It is equally possible to specify a selected format for your MAC string output in the form of a 'dialect' class. It's use is similar to the dialect class used in the Python standard library csv module.
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+>>> mac
+EUI('00-1B-77-49-54-FD')
+>>> mac.dialect = mac_unix
+>>> mac
+EUI('0:1b:77:49:54:fd')
+>>> mac.dialect = mac_unix_expanded
+>>> mac
+EUI('00:1b:77:49:54:fd')
+>>> mac.dialect = mac_cisco
+>>> mac
+EUI('001b.7749.54fd')
+>>> mac.dialect = mac_bare
+>>> mac
+EUI('001B774954FD')
+>>> mac.dialect = mac_pgsql
+>>> mac
+EUI('001b77:4954fd')
+
+You can of course, create your own dialect classes to customise the MAC formatting if the standard ones do not suit your needs.
+
+Here's a tweaked UNIX MAC dialect that generates uppercase, zero-filled octets.
+
+>>> class mac_custom(mac_unix): pass
+>>> mac_custom.word_fmt = '%.2X'
+>>> mac = EUI('00-1B-77-49-54-FD', dialect=mac_custom)
+>>> mac
+EUI('00:1B:77:49:54:FD')
+
+-----------------------------------
+Querying organisational information
+-----------------------------------
+
+EUI objects provide an interface to the OUI (Organisationally Unique Identifier) and IAB (Individual Address Block) registration databases available from the IEEE.
+
+Here is how you query an OUI with the EUI interface.
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+>>> oui = mac.oui
+>>> oui
+OUI('00-1B-77')
+>>> oui.registration().address
+['Lot 8, Jalan Hi-Tech 2/3', 'Kulim Hi-Tech Park', 'Kulim Kedah 09000', 'MALAYSIA']
+>>> oui.registration().org
+'Intel Corporate'
+
+You can also use OUI objects directly without going through the EUI interface.
+
+A few OUI records have multiple registrations against them. I'm not sure if this is recording historical information or just a quirk of the IEEE reigstration process.
+
+This example show you how you access them individually by specifying an index number.
+
+>>> oui = OUI(524336)   #   OUI constructor accepts integer values too.
+>>> oui
+OUI('08-00-30')
+>>> oui.registration(0).address
+['2380 N. ROSE AVENUE', 'OXNARD CA 93010', 'UNITED STATES']
+>>> oui.registration(0).org
+'NETWORK RESEARCH CORPORATION'
+>>> oui.registration(0).oui
+'08-00-30'
+>>> oui.registration(1).address
+['CH-1211 GENEVE 23', 'SUISSE/SWITZ', 'SWITZERLAND']
+>>> oui.registration(1).org
+'CERN'
+>>> oui.registration(1).oui
+'08-00-30'
+>>> oui.registration(2).address
+['GPO BOX 2476V', 'MELBOURNE VIC 3001', 'AUSTRALIA']
+>>> oui.registration(2).org
+'ROYAL MELBOURNE INST OF TECH'
+>>> oui.registration(2).oui
+'08-00-30'
+>>> for i in range(oui.reg_count):
+...     str(oui), oui.registration(i).org
+...
+('08-00-30', 'NETWORK RESEARCH CORPORATION')
+('08-00-30', 'CERN')
+('08-00-30', 'ROYAL MELBOURNE INST OF TECH')
+
+Here is how you query an IAB with the EUI interface.
+
+>>> mac = EUI('00-50-C2-00-0F-01')
+>>> mac.is_iab()
+True
+>>> iab = mac.iab
+>>> iab
+IAB('00-50-C2-00-00-00')
+>>> iab.registration()
+{'address': ['1241 Superieor Ave E', 'Cleveland OH 44114', 'UNITED STATES'],
+ 'iab': '00-50-C2-00-00-00',
+ ...
+ 'offset': 123,
+ 'org': 'T.L.S. Corp.',
+ 'size': 139}

netaddr/tests/2.x/ip/abbreviated.txt

@@ -0,0 +1,202 @@
+=Abbreviated CIDR Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Abbreviation tests.
+
+{{{
+
+>>> ranges = (
+... (IPAddress('::'), IPAddress('::')),
+... (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')),
+... (IPAddress('::'), IPAddress('::255.255.255.255')),
+... (IPAddress('0.0.0.0'), IPAddress('0.0.0.0')),
+... )
+
+>>> sorted(ranges)
+[(IPAddress('0.0.0.0'), IPAddress('0.0.0.0')), (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')), (IPAddress('::'), IPAddress('::')), (IPAddress('::'), IPAddress('::255.255.255.255'))]
+
+#   Integer values.
+>>> cidr_abbrev_to_verbose(-1)
+-1
+
+#   Class A
+>>> cidr_abbrev_to_verbose(0)
+'0.0.0.0/8'
+>>> cidr_abbrev_to_verbose(10)
+'10.0.0.0/8'
+>>> cidr_abbrev_to_verbose(127)
+'127.0.0.0/8'
+
+#   Class B
+>>> cidr_abbrev_to_verbose(128)
+'128.0.0.0/16'
+>>> cidr_abbrev_to_verbose(191)
+'191.0.0.0/16'
+
+#   Class C
+>>> cidr_abbrev_to_verbose(192)
+'192.0.0.0/24'
+>>> cidr_abbrev_to_verbose(223)
+'223.0.0.0/24'
+
+#   Class D (multicast)
+>>> cidr_abbrev_to_verbose(224)
+'224.0.0.0/4'
+>>> cidr_abbrev_to_verbose(225)
+'225.0.0.0/4'
+>>> cidr_abbrev_to_verbose(239)
+'239.0.0.0/4'
+
+#   Class E (reserved)
+>>> cidr_abbrev_to_verbose(240)
+'240.0.0.0/32'
+>>> cidr_abbrev_to_verbose(254)
+'254.0.0.0/32'
+>>> cidr_abbrev_to_verbose(255)
+'255.0.0.0/32'
+>>> cidr_abbrev_to_verbose(256)
+256
+
+#   String values.
+>>> cidr_abbrev_to_verbose('-1')
+'-1'
+
+#   Class A
+>>> cidr_abbrev_to_verbose('0')
+'0.0.0.0/8'
+>>> cidr_abbrev_to_verbose('10')
+'10.0.0.0/8'
+>>> cidr_abbrev_to_verbose('127')
+'127.0.0.0/8'
+
+#   Class B
+>>> cidr_abbrev_to_verbose('128')
+'128.0.0.0/16'
+>>> cidr_abbrev_to_verbose('191')
+'191.0.0.0/16'
+
+#   Class C
+>>> cidr_abbrev_to_verbose('192')
+'192.0.0.0/24'
+>>> cidr_abbrev_to_verbose('223')
+'223.0.0.0/24'
+
+#   Class D (multicast)
+>>> cidr_abbrev_to_verbose('224')
+'224.0.0.0/4'
+>>> cidr_abbrev_to_verbose('225')
+'225.0.0.0/4'
+>>> cidr_abbrev_to_verbose('239')
+'239.0.0.0/4'
+
+#   Class E (reserved)
+>>> cidr_abbrev_to_verbose('240')
+'240.0.0.0/32'
+>>> cidr_abbrev_to_verbose('254')
+'254.0.0.0/32'
+>>> cidr_abbrev_to_verbose('255')
+'255.0.0.0/32'
+>>> cidr_abbrev_to_verbose('256')
+'256'
+
+>>> cidr_abbrev_to_verbose('128/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('128.0/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('128.0.0.0/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('128.0.0/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('192.168')
+'192.168.0.0/24'
+>>> cidr_abbrev_to_verbose('192.0.2')
+'192.0.2.0/24'
+>>> cidr_abbrev_to_verbose('192.0.2.0')
+'192.0.2.0/24'
+>>> cidr_abbrev_to_verbose('0.0.0.0')
+'0.0.0.0/8'
+
+#   No IPv6 support current.
+>>> cidr_abbrev_to_verbose('::/128')
+'::/128'
+
+#   IPv6 proper, not IPv4 mapped?
+>>> cidr_abbrev_to_verbose('::10/128')
+'::10/128'
+>>> cidr_abbrev_to_verbose('0.0.0.0.0')
+'0.0.0.0.0'
+>>> cidr_abbrev_to_verbose('')
+''
+>>> cidr_abbrev_to_verbose(None)
+
+>>> cidr_abbrev_to_verbose([])
+[]
+>>> cidr_abbrev_to_verbose({})
+{}
+
+}}}
+
+Negative testing.
+
+{{{
+
+>>> cidr_abbrev_to_verbose('192.0.2.0')
+'192.0.2.0/24'
+
+>>> cidr_abbrev_to_verbose('192.0.2.0/32')
+'192.0.2.0/32'
+
+#FIXME: >>> cidr_abbrev_to_verbose('192.0.2.0/33')
+Traceback (most recent call last):
+...
+ValueError: prefixlen in address '192.0.2.0/33' out of range for IPv4!
+
+}}}
+
+IPv4 octet expansion routine.
+
+{{{
+
+>>> from netaddr.strategy import ipv4
+
+>>> ipv4.expand_partial_address('10')
+'10.0.0.0'
+
+>>> ipv4.expand_partial_address('10.1')
+'10.1.0.0'
+
+>>> ipv4.expand_partial_address('192.168.1')
+'192.168.1.0'
+
+}}}
+
+IPNetwork constructor testing.
+
+{{{
+
+>>> IPNetwork('192.168/16')
+IPNetwork('192.168.0.0/16')
+
+>>> IPNetwork('192.168.0.15')
+IPNetwork('192.168.0.15/32')
+
+>>> IPNetwork('192.168')
+IPNetwork('192.168.0.0/32')
+
+>>> IPNetwork('192.168', implicit_prefix=True)
+IPNetwork('192.168.0.0/24')
+
+>>> IPNetwork('192.168', True)
+IPNetwork('192.168.0.0/24')
+
+>>> IPNetwork('10.0.0.1', True)
+IPNetwork('10.0.0.1/8')
+
+}}}

netaddr/tests/2.x/ip/binops.txt

@@ -0,0 +1,67 @@
+=Binary and numerical operations on IP addresses=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+==Addition and Subtraction ==
+
+{{{
+
+>>> IPAddress('192.0.2.0') + 1
+IPAddress('192.0.2.1')
+
+>>> 1 + IPAddress('192.0.2.0')
+IPAddress('192.0.2.1')
+
+>>> IPAddress('192.0.2.1') - 1
+IPAddress('192.0.2.0')
+
+>>> IPAddress('192.0.0.0') + IPAddress('0.0.0.42')
+IPAddress('192.0.0.42')
+
+>>> IPAddress('192.0.0.42') - IPAddress('0.0.0.42')
+IPAddress('192.0.0.0')
+
+>>> 1 - IPAddress('192.0.2.1')
+Traceback (most recent call last):
+...
+IndexError: result outside valid IP address boundary!
+
+>>> ip = IPAddress('10.0.0.1')
+>>> ip += 1
+>>> ip
+IPAddress('10.0.0.2')
+>>> ip -= 1
+>>> ip
+IPAddress('10.0.0.1')
+>>> ip += IPAddress('0.0.0.42')
+>>> ip
+IPAddress('10.0.0.43')
+>>> ip -= IPAddress('0.0.0.43')
+>>> ip
+IPAddress('10.0.0.0')
+
+}}}
+
+==Binary operations==
+
+{{{
+
+>>> IPAddress('192.0.2.15') & IPAddress('255.255.255.0')
+IPAddress('192.0.2.0')
+
+>>> IPAddress('255.255.0.0') | IPAddress('0.0.255.255')
+IPAddress('255.255.255.255')
+
+>>> IPAddress('255.255.0.0') ^ IPAddress('255.0.0.0')
+IPAddress('0.255.0.0')
+
+>>> IPAddress('1.2.3.4').packed
+'\x01\x02\x03\x04'
+
+}}}

netaddr/tests/2.x/ip/boundaries.txt

@@ -0,0 +1,170 @@
+=IP Range Boundary Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+>>> import pprint
+
+}}}
+
+`iter_iprange()` iterator boundary tests.
+
+{{{
+
+>>> pprint.pprint(list(iter_iprange('192.0.2.0', '192.0.2.7')))
+[IPAddress('192.0.2.0'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6'),
+ IPAddress('192.0.2.7')]
+
+>>> pprint.pprint(list(iter_iprange('::ffff:192.0.2.0', '::ffff:192.0.2.7')))
+[IPAddress('::ffff:192.0.2.0'),
+ IPAddress('::ffff:192.0.2.1'),
+ IPAddress('::ffff:192.0.2.2'),
+ IPAddress('::ffff:192.0.2.3'),
+ IPAddress('::ffff:192.0.2.4'),
+ IPAddress('::ffff:192.0.2.5'),
+ IPAddress('::ffff:192.0.2.6'),
+ IPAddress('::ffff:192.0.2.7')]
+
+
+}}}
+
+`IPNetwork()` iterator boundary tests.
+
+{{{
+
+>>> pprint.pprint(list(IPNetwork('192.0.2.0/29')[0:-1]))
+[IPAddress('192.0.2.0'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6')]
+
+>>> pprint.pprint(list(IPNetwork('192.0.2.0/29')[::-1]))
+[IPAddress('192.0.2.7'),
+ IPAddress('192.0.2.6'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.0')]
+ 
+For IPv4, network (first) and broadcast (last) address must be skipped.
+>>> pprint.pprint(list(IPNetwork('192.0.2.0/29').iter_hosts()))
+[IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6')]
+
+For IPv6, Subnet-Router anycast address (first) must be skipped.
+>>> pprint.pprint(list(IPNetwork('::ffff:192.0.2.0/125').iter_hosts()))
+[IPAddress('::ffff:192.0.2.1'),
+ IPAddress('::ffff:192.0.2.2'),
+ IPAddress('::ffff:192.0.2.3'),
+ IPAddress('::ffff:192.0.2.4'),
+ IPAddress('::ffff:192.0.2.5'),
+ IPAddress('::ffff:192.0.2.6'),
+ IPAddress('::ffff:192.0.2.7')]
+
+Very small IPNetworks do contain some IP addresses
+>>> list(IPNetwork("192.168.0.0/31"))
+[IPAddress('192.168.0.0'), IPAddress('192.168.0.1')]
+>>> list(IPNetwork("1234::/128"))
+[IPAddress('1234::')]
+
+But they have no IPs that can be assigned to hosts.
+>>> list(IPNetwork("1234::/128").iter_hosts())
+[]
+>>> list(IPNetwork("192.168.0.0/31").iter_hosts())
+[]
+
+}}}
+
+`IPRange()` iterator boundary tests.
+
+{{{
+
+>>> pprint.pprint(list(IPRange('192.0.2.0', '192.0.2.7')))
+[IPAddress('192.0.2.0'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6'),
+ IPAddress('192.0.2.7')]
+
+>>> pprint.pprint(list(IPRange('::ffff:192.0.2.0', '::ffff:192.0.2.7')))
+[IPAddress('::ffff:192.0.2.0'),
+ IPAddress('::ffff:192.0.2.1'),
+ IPAddress('::ffff:192.0.2.2'),
+ IPAddress('::ffff:192.0.2.3'),
+ IPAddress('::ffff:192.0.2.4'),
+ IPAddress('::ffff:192.0.2.5'),
+ IPAddress('::ffff:192.0.2.6'),
+ IPAddress('::ffff:192.0.2.7')]
+
+}}}
+
+Boolean contexts.
+
+{{{
+
+>>> bool(IPAddress('0.0.0.0'))
+False
+
+>>> bool(IPAddress('0.0.0.1'))
+True
+
+>>> bool(IPAddress('255.255.255.255'))
+True
+
+>>> bool(IPNetwork('0.0.0.0/0'))
+True
+
+>>> bool(IPNetwork('::/0'))
+True
+
+>>> bool(IPRange('0.0.0.0', '255.255.255.255'))
+True
+
+>>> bool(IPRange('0.0.0.0', '0.0.0.0'))
+True
+
+>>> bool(IPGlob('*.*.*.*'))
+True
+
+>>> bool(IPGlob('0.0.0.0'))
+True
+
+}}}
+
+`IPAddress()` negative increment tests.
+
+{{{
+
+>>> ip = IPAddress('0.0.0.0')
+>>> ip += -1
+Traceback (most recent call last):
+...
+IndexError: result outside valid IP address boundary!
+
+>>> ip = IPAddress('255.255.255.255')
+>>> ip -= -1
+Traceback (most recent call last):
+...
+IndexError: result outside valid IP address boundary!
+
+}}}

netaddr/tests/2.x/ip/cidr.txt

@@ -0,0 +1,449 @@
+=CIDR Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+==Basic IP Range Tuple Sorting==
+
+{{{
+
+>>> ranges = (
+... (IPAddress('::'), IPAddress('::')),
+... (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')),
+... (IPAddress('::'), IPAddress('::255.255.255.255')),
+... (IPAddress('0.0.0.0'), IPAddress('0.0.0.0')),
+... )
+
+>>> sorted(ranges)
+[(IPAddress('0.0.0.0'), IPAddress('0.0.0.0')), (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')), (IPAddress('::'), IPAddress('::')), (IPAddress('::'), IPAddress('::255.255.255.255'))]
+
+}}}
+
+Worst case IPv4 range to CIDR conversion.
+
+{{{
+
+>>> for ip in iprange_to_cidrs('0.0.0.1', '255.255.255.254'):
+...     ip
+...
+IPNetwork('0.0.0.1/32')
+IPNetwork('0.0.0.2/31')
+IPNetwork('0.0.0.4/30')
+IPNetwork('0.0.0.8/29')
+IPNetwork('0.0.0.16/28')
+IPNetwork('0.0.0.32/27')
+IPNetwork('0.0.0.64/26')
+IPNetwork('0.0.0.128/25')
+IPNetwork('0.0.1.0/24')
+IPNetwork('0.0.2.0/23')
+IPNetwork('0.0.4.0/22')
+IPNetwork('0.0.8.0/21')
+IPNetwork('0.0.16.0/20')
+IPNetwork('0.0.32.0/19')
+IPNetwork('0.0.64.0/18')
+IPNetwork('0.0.128.0/17')
+IPNetwork('0.1.0.0/16')
+IPNetwork('0.2.0.0/15')
+IPNetwork('0.4.0.0/14')
+IPNetwork('0.8.0.0/13')
+IPNetwork('0.16.0.0/12')
+IPNetwork('0.32.0.0/11')
+IPNetwork('0.64.0.0/10')
+IPNetwork('0.128.0.0/9')
+IPNetwork('1.0.0.0/8')
+IPNetwork('2.0.0.0/7')
+IPNetwork('4.0.0.0/6')
+IPNetwork('8.0.0.0/5')
+IPNetwork('16.0.0.0/4')
+IPNetwork('32.0.0.0/3')
+IPNetwork('64.0.0.0/2')
+IPNetwork('128.0.0.0/2')
+IPNetwork('192.0.0.0/3')
+IPNetwork('224.0.0.0/4')
+IPNetwork('240.0.0.0/5')
+IPNetwork('248.0.0.0/6')
+IPNetwork('252.0.0.0/7')
+IPNetwork('254.0.0.0/8')
+IPNetwork('255.0.0.0/9')
+IPNetwork('255.128.0.0/10')
+IPNetwork('255.192.0.0/11')
+IPNetwork('255.224.0.0/12')
+IPNetwork('255.240.0.0/13')
+IPNetwork('255.248.0.0/14')
+IPNetwork('255.252.0.0/15')
+IPNetwork('255.254.0.0/16')
+IPNetwork('255.255.0.0/17')
+IPNetwork('255.255.128.0/18')
+IPNetwork('255.255.192.0/19')
+IPNetwork('255.255.224.0/20')
+IPNetwork('255.255.240.0/21')
+IPNetwork('255.255.248.0/22')
+IPNetwork('255.255.252.0/23')
+IPNetwork('255.255.254.0/24')
+IPNetwork('255.255.255.0/25')
+IPNetwork('255.255.255.128/26')
+IPNetwork('255.255.255.192/27')
+IPNetwork('255.255.255.224/28')
+IPNetwork('255.255.255.240/29')
+IPNetwork('255.255.255.248/30')
+IPNetwork('255.255.255.252/31')
+IPNetwork('255.255.255.254/32')
+
+}}}
+
+Worst case IPv4 mapped IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::ffff:1', '::ffff:255.255.255.254'):
+...     ip
+...
+IPNetwork('::255.255.0.1/128')
+IPNetwork('::255.255.0.2/127')
+IPNetwork('::255.255.0.4/126')
+IPNetwork('::255.255.0.8/125')
+IPNetwork('::255.255.0.16/124')
+IPNetwork('::255.255.0.32/123')
+IPNetwork('::255.255.0.64/122')
+IPNetwork('::255.255.0.128/121')
+IPNetwork('::255.255.1.0/120')
+IPNetwork('::255.255.2.0/119')
+IPNetwork('::255.255.4.0/118')
+IPNetwork('::255.255.8.0/117')
+IPNetwork('::255.255.16.0/116')
+IPNetwork('::255.255.32.0/115')
+IPNetwork('::255.255.64.0/114')
+IPNetwork('::255.255.128.0/113')
+IPNetwork('::1:0:0/96')
+IPNetwork('::2:0:0/95')
+IPNetwork('::4:0:0/94')
+IPNetwork('::8:0:0/93')
+IPNetwork('::10:0:0/92')
+IPNetwork('::20:0:0/91')
+IPNetwork('::40:0:0/90')
+IPNetwork('::80:0:0/89')
+IPNetwork('::100:0:0/88')
+IPNetwork('::200:0:0/87')
+IPNetwork('::400:0:0/86')
+IPNetwork('::800:0:0/85')
+IPNetwork('::1000:0:0/84')
+IPNetwork('::2000:0:0/83')
+IPNetwork('::4000:0:0/82')
+IPNetwork('::8000:0:0/82')
+IPNetwork('::c000:0:0/83')
+IPNetwork('::e000:0:0/84')
+IPNetwork('::f000:0:0/85')
+IPNetwork('::f800:0:0/86')
+IPNetwork('::fc00:0:0/87')
+IPNetwork('::fe00:0:0/88')
+IPNetwork('::ff00:0:0/89')
+IPNetwork('::ff80:0:0/90')
+IPNetwork('::ffc0:0:0/91')
+IPNetwork('::ffe0:0:0/92')
+IPNetwork('::fff0:0:0/93')
+IPNetwork('::fff8:0:0/94')
+IPNetwork('::fffc:0:0/95')
+IPNetwork('::fffe:0:0/96')
+IPNetwork('::ffff:0.0.0.0/97')
+IPNetwork('::ffff:128.0.0.0/98')
+IPNetwork('::ffff:192.0.0.0/99')
+IPNetwork('::ffff:224.0.0.0/100')
+IPNetwork('::ffff:240.0.0.0/101')
+IPNetwork('::ffff:248.0.0.0/102')
+IPNetwork('::ffff:252.0.0.0/103')
+IPNetwork('::ffff:254.0.0.0/104')
+IPNetwork('::ffff:255.0.0.0/105')
+IPNetwork('::ffff:255.128.0.0/106')
+IPNetwork('::ffff:255.192.0.0/107')
+IPNetwork('::ffff:255.224.0.0/108')
+IPNetwork('::ffff:255.240.0.0/109')
+IPNetwork('::ffff:255.248.0.0/110')
+IPNetwork('::ffff:255.252.0.0/111')
+IPNetwork('::ffff:255.254.0.0/112')
+IPNetwork('::ffff:255.255.0.0/113')
+IPNetwork('::ffff:255.255.128.0/114')
+IPNetwork('::ffff:255.255.192.0/115')
+IPNetwork('::ffff:255.255.224.0/116')
+IPNetwork('::ffff:255.255.240.0/117')
+IPNetwork('::ffff:255.255.248.0/118')
+IPNetwork('::ffff:255.255.252.0/119')
+IPNetwork('::ffff:255.255.254.0/120')
+IPNetwork('::ffff:255.255.255.0/121')
+IPNetwork('::ffff:255.255.255.128/122')
+IPNetwork('::ffff:255.255.255.192/123')
+IPNetwork('::ffff:255.255.255.224/124')
+IPNetwork('::ffff:255.255.255.240/125')
+IPNetwork('::ffff:255.255.255.248/126')
+IPNetwork('::ffff:255.255.255.252/127')
+IPNetwork('::ffff:255.255.255.254/128')
+
+}}}
+
+RFC 4291 CIDR tests.
+
+{{{
+
+>>> str(IPNetwork('2001:0DB8:0000:CD30:0000:0000:0000:0000/60'))
+'2001:db8:0:cd30::/60'
+
+>>> str(IPNetwork('2001:0DB8::CD30:0:0:0:0/60'))
+'2001:db8:0:cd30::/60'
+
+>>> str(IPNetwork('2001:0DB8:0:CD30::/60'))
+'2001:db8:0:cd30::/60'
+
+}}}
+
+Equality tests.
+
+{{{
+
+>>> IPNetwork('192.0.2.0/255.255.254.0') == IPNetwork('192.0.2.0/23')
+True
+
+>>> IPNetwork('192.0.2.65/255.255.254.0') == IPNetwork('192.0.2.0/23')
+True
+
+>>> IPNetwork('192.0.2.65/255.255.254.0') == IPNetwork('192.0.2.65/23')
+True
+
+>>> IPNetwork('192.0.2.65/255.255.255.0') == IPNetwork('192.0.2.0/23')
+False
+
+>>> IPNetwork('192.0.2.65/255.255.254.0') == IPNetwork('192.0.2.65/24')
+False
+
+}}}
+
+Slicing tests.
+
+{{{
+
+>>> ip = IPNetwork('192.0.2.0/23')
+>>> ip.first == 3221225984
+True
+
+>>> ip.last == 3221226495
+True
+
+>>> ip[0]
+IPAddress('192.0.2.0')
+
+>>> ip[-1]
+IPAddress('192.0.3.255')
+
+>>> list(ip[::128])
+[IPAddress('192.0.2.0'), IPAddress('192.0.2.128'), IPAddress('192.0.3.0'), IPAddress('192.0.3.128')]
+
+>>> ip = IPNetwork('fe80::/10')
+>>> ip[0]
+IPAddress('fe80::')
+
+>>> ip[-1]
+IPAddress('febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
+
+>>> ip.size == 332306998946228968225951765070086144
+True
+
+>>> list(ip[0:5:1])
+Traceback (most recent call last):
+...
+TypeError: IPv6 slices are not supported!
+
+
+}}}
+
+Membership tests.
+
+{{{
+
+>>> IPAddress('192.0.2.1') in IPNetwork('192.0.2.0/24')
+True
+
+>>> IPAddress('192.0.2.255') in IPNetwork('192.0.2.0/24')
+True
+
+>>> IPNetwork('192.0.2.0/24') in IPNetwork('192.0.2.0/23')
+True
+
+>>> IPNetwork('192.0.2.0/24') in IPNetwork('192.0.2.0/24')
+True
+
+>>> IPAddress('ffff::1') in IPNetwork('ffff::/127')
+True
+
+>>> IPNetwork('192.0.2.0/23') in IPNetwork('192.0.2.0/24')
+False
+
+}}}
+
+Equality tests.
+
+{{{
+
+>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.2.0/24')
+True
+
+>>> IPNetwork('192.0.2.0/24') is not IPNetwork('192.0.2.0/24')
+True
+
+>>> IPNetwork('192.0.2.0/24') != IPNetwork('192.0.2.0/24')
+False
+
+>>> IPNetwork('192.0.2.0/24') is IPNetwork('192.0.2.0/24')
+False
+
+>>> IPNetwork('fe80::/10') == IPNetwork('fe80::/10')
+True
+
+>>> IPNetwork('fe80::/10') is not IPNetwork('fe80::/10')
+True
+
+>>> IPNetwork('fe80::/10') != IPNetwork('fe80::/10')
+False
+
+>>> IPNetwork('fe80::/10') is IPNetwork('fe80::/10')
+False
+
+}}}
+
+Exclusion tests.
+
+{{{
+
+#   Equivalent to :-
+#   >>> set([1]) - set([1])
+#   set([1])
+>>> cidr_exclude('192.0.2.1/32', '192.0.2.1/32')
+[]
+
+#   Equivalent to :-
+#   >>> set([1,2]) - set([2])
+#   set([1])
+>>> cidr_exclude('192.0.2.0/31', '192.0.2.1/32')
+[IPNetwork('192.0.2.0/32')]
+
+#   Equivalent to :-
+#   >>> set([1,2,3,4,5,6,7,8]) - set([5,6,7,8])
+#   set([1, 2, 3, 4])
+>>> cidr_exclude('192.0.2.0/24', '192.0.2.128/25')
+[IPNetwork('192.0.2.0/25')]
+
+#   Equivalent to :-
+#   >>> set([1,2,3,4,5,6,7,8]) - set([5,6])
+#   set([1, 2, 3, 4, 7, 8])
+>>> cidr_exclude('192.0.2.0/24', '192.0.2.128/27')
+[IPNetwork('192.0.2.0/25'), IPNetwork('192.0.2.160/27'), IPNetwork('192.0.2.192/26')]
+
+#   Subtracting a larger range from a smaller one results in an empty
+#   list (rather than a negative CIDR - which would be rather odd)!
+#
+#   Equivalent to :-
+#   >>> set([1]) - set([1,2,3])
+#   set([])
+>>> cidr_exclude('192.0.2.1/32', '192.0.2.0/24')
+[]
+
+}}}
+
+Please Note: excluding IP subnets that are not within each other and have no overlaps should return the original target IP object.
+
+{{{
+
+#   Equivalent to :-
+#   >>> set([1,2,3]) - set([4])
+#   set([1,2,3])
+>>> cidr_exclude('192.0.2.0/28', '192.0.2.16/32')
+[IPNetwork('192.0.2.0/28')]
+
+#   Equivalent to :-
+#   >>> set([1]) - set([2,3,4])
+#   set([1])
+>>> cidr_exclude('192.0.1.255/32', '192.0.2.0/28')
+[IPNetwork('192.0.1.255/32')]
+
+}}}
+
+Merge tests.
+
+{{{
+
+>>> cidr_merge(['192.0.128.0/24', '192.0.129.0/24'])
+[IPNetwork('192.0.128.0/23')]
+
+>>> cidr_merge(['192.0.129.0/24', '192.0.130.0/24'])
+[IPNetwork('192.0.129.0/24'), IPNetwork('192.0.130.0/24')]
+
+>>> cidr_merge(['192.0.2.112/30', '192.0.2.116/31', '192.0.2.118/31'])
+[IPNetwork('192.0.2.112/29')]
+
+>>> cidr_merge(['192.0.2.112/30', '192.0.2.116/32', '192.0.2.118/31'])
+[IPNetwork('192.0.2.112/30'), IPNetwork('192.0.2.116/32'), IPNetwork('192.0.2.118/31')]
+
+>>> cidr_merge(['192.0.2.112/31', '192.0.2.116/31', '192.0.2.118/31'])
+[IPNetwork('192.0.2.112/31'), IPNetwork('192.0.2.116/30')]
+
+>>> cidr_merge(['192.0.1.254/31',
+... '192.0.2.0/28',
+... '192.0.2.16/28',
+... '192.0.2.32/28',
+... '192.0.2.48/28',
+... '192.0.2.64/28',
+... '192.0.2.80/28',
+... '192.0.2.96/28',
+... '192.0.2.112/28',
+... '192.0.2.128/28',
+... '192.0.2.144/28',
+... '192.0.2.160/28',
+... '192.0.2.176/28',
+... '192.0.2.192/28',
+... '192.0.2.208/28',
+... '192.0.2.224/28',
+... '192.0.2.240/28',
+... '192.0.3.0/28'])
+[IPNetwork('192.0.1.254/31'), IPNetwork('192.0.2.0/24'), IPNetwork('192.0.3.0/28')]
+
+}}}
+
+Extended merge tests.
+
+{{{
+
+>>> import random
+
+#   Start with a single /23 CIDR.
+
+>>> orig_cidr_ipv4 = IPNetwork('192.0.2.0/23')
+>>> orig_cidr_ipv6 = IPNetwork('::192.0.2.0/120')
+
+#   Split it into /28 subnet CIDRs (mix CIDR objects and CIDR strings).
+
+>>> cidr_subnets = []
+>>> cidr_subnets.extend([str(c) for c in orig_cidr_ipv4.subnet(28)])
+>>> cidr_subnets.extend(list(orig_cidr_ipv4.subnet(28)))
+>>> cidr_subnets.extend([str(c) for c in orig_cidr_ipv6.subnet(124)])
+>>> cidr_subnets.extend(list(orig_cidr_ipv6.subnet(124)))
+
+#   Add a couple of duplicates in to make sure summarization is working OK.
+
+>>> cidr_subnets.append('192.0.2.1/32')
+>>> cidr_subnets.append('192.0.2.128/25')
+>>> cidr_subnets.append('::192.0.2.92/128')
+
+#   Randomize the order of subnets.
+>>> random.shuffle(cidr_subnets)
+
+#   Perform summarization operation.
+>>> merged_cidrs = cidr_merge(cidr_subnets) 
+>>> merged_cidrs
+[IPNetwork('192.0.2.0/23'), IPNetwork('::192.0.2.0/120')]
+
+>>> merged_cidrs == [orig_cidr_ipv4, orig_cidr_ipv6]
+True
+
+}}}

netaddr/tests/2.x/ip/constructor.txt

@@ -0,0 +1,234 @@
+=IP Constructor Stress Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+IPAddress constructor - integer values.
+
+{{{
+
+>>> IPAddress(1)
+IPAddress('0.0.0.1')
+
+>>> IPAddress(1, 4)
+IPAddress('0.0.0.1')
+
+>>> IPAddress(1, 6)
+IPAddress('::1')
+
+>>> IPAddress(10)
+IPAddress('0.0.0.10')
+
+>>> IPAddress(0x1ffffffff)
+IPAddress('::1:ffff:ffff')
+
+>>> IPAddress(0xffffffff, 6)
+IPAddress('::255.255.255.255')
+
+>>> IPAddress(0x1ffffffff)
+IPAddress('::1:ffff:ffff')
+
+>>> IPAddress(2 ** 128 - 1)
+IPAddress('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
+
+}}}
+
+IPAddress constructor - IPv4 inet_aton behaviour (default).
+
+{{{
+
+#	Hexadecimal octets.
+>>> IPAddress('0x7f.0x1')
+IPAddress('127.0.0.1')
+
+>>> IPAddress('0x7f.0x0.0x0.0x1')
+IPAddress('127.0.0.1')
+
+#	Octal octets.
+>>> IPAddress('0177.01')
+IPAddress('127.0.0.1')
+
+#	Mixed octets.
+>>> IPAddress('0x7f.0.01')
+IPAddress('127.0.0.1')
+
+#	Partial addresses - pretty weird ...
+>>> IPAddress('127')
+IPAddress('0.0.0.127')
+
+>>> IPAddress('127')
+IPAddress('0.0.0.127')
+
+>>> IPAddress('127.1')
+IPAddress('127.0.0.1')
+
+>>> IPAddress('127.0.1')
+IPAddress('127.0.0.1')
+
+}}}
+
+IPAddress constructor - IPv4 inet_pton behaviour (stricter parser).
+
+{{{
+
+#	Octal octets.
+>>> IPAddress('0177.01', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '0177.01'
+
+#	Mixed octets.
+>>> IPAddress('0x7f.0.01', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '0x7f.0.01'
+
+#   Partial octets.
+>>> IPAddress('10', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '10'
+
+>>> IPAddress('10.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '10.1'
+
+>>> IPAddress('10.0.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '10.0.1'
+
+>>> IPAddress('10.0.0.1', flags=INET_PTON)
+IPAddress('10.0.0.1')
+
+}}}
+
+IPAddress constructor - zero filled octets.
+
+{{{
+
+#   This takes a lot of people by surprise ...
+>>> IPAddress('010.000.000.001')
+IPAddress('8.0.0.1')
+
+#   So, we need this!
+>>> IPAddress('010.000.000.001', flags=ZEROFILL)
+IPAddress('10.0.0.1')
+
+#   Zero-fill with inet_aton behaviour - partial octets are OK but zero-filled
+#   octets are interpreted as decimal ...
+>>> IPAddress('010.000.001', flags=ZEROFILL)
+IPAddress('10.0.0.1')
+
+#   Zero-fill with inet_pton behaviour - 4 octets only!
+>>> IPAddress('010.000.001', flags=INET_PTON|ZEROFILL)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '010.000.001'
+
+#   Zero-fill with inet_pton behaviour - 4 octets only!
+>>> IPAddress('010.000.000.001', flags=INET_PTON|ZEROFILL)
+IPAddress('10.0.0.1')
+
+#   To save some typing there are short versions of these flags.
+>>> IPAddress('010.000.000.001', flags=P|Z)
+IPAddress('10.0.0.1')
+
+}}}
+
+IP network construction.
+
+{{{
+
+>>> IPNetwork('192.0.2.0/24')
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('192.0.2.0/255.255.255.0')
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('192.0.2.0/0.0.0.255')
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork(IPNetwork('192.0.2.0/24'))
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork(IPNetwork('::192.0.2.0/120'))
+IPNetwork('::192.0.2.0/120')
+
+>>> IPNetwork(IPNetwork('192.0.2.0/24'))
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('::192.0.2.0/120')
+IPNetwork('::192.0.2.0/120')
+
+>>> IPNetwork('::192.0.2.0/120', 6)
+IPNetwork('::192.0.2.0/120')
+
+}}}
+
+Optional implicit IP network prefix selection rules.
+
+{{{
+
+>>> IPNetwork('192.0.2.0', implicit_prefix=True)
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('231.192.0.15', implicit_prefix=True)
+IPNetwork('231.192.0.15/4')
+
+>>> IPNetwork('10', implicit_prefix=True)
+IPNetwork('10.0.0.0/8')
+
+}}}
+
+Optional flags for tweaking IPNetwork constructor behaviour.
+
+{{{
+
+>>> IPNetwork('172.24.200')
+IPNetwork('172.24.200.0/32')
+
+>>> IPNetwork('172.24.200', implicit_prefix=True)
+IPNetwork('172.24.200.0/16')
+
+#	Truncate the host bits so we get a pure network.
+>>> IPNetwork('172.24.200', implicit_prefix=True, flags=NOHOST)
+IPNetwork('172.24.0.0/16')
+
+
+}}}
+
+Negative testing
+
+{{{
+
+>>> IPNetwork('foo')
+Traceback (most recent call last):
+...
+AddrFormatError: invalid IPNetwork foo
+
+}}}
+
+Netmasks
+
+{{{
+
+>>> IPAddress('1.1.1.1').netmask_bits()
+32
+
+>>> IPAddress('255.255.255.254').netmask_bits()
+31
+
+>>> IPAddress('255.255.255.0').netmask_bits()
+24
+
+>>> IPAddress('::').netmask_bits()
+128
+
+}}}

netaddr/tests/2.x/ip/formats.txt

@@ -0,0 +1,27 @@
+=IP formatting options=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+==IPAddress representations==
+
+{{{
+
+>>> hex(IPAddress(0))
+'0x0'
+
+>>> hex(IPAddress(0xffffffff))
+'0xffffffff'
+
+>>> oct(IPAddress(0))
+'0'
+
+>>> oct(IPAddress(0xffffffff))
+'037777777777'
+
+}}}

netaddr/tests/2.x/ip/functions.txt

@@ -0,0 +1,48 @@
+=IP Function Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+During a cidr merge operation, the address 0.0.0.0/0, representing the whole of the IPv4 address space, should swallow anything it is merged with.
+
+{{{
+
+>>> cidr_merge(['0.0.0.0/0', '0.0.0.0'])
+[IPNetwork('0.0.0.0/0')]
+
+>>> cidr_merge(['0.0.0.0/0', '255.255.255.255'])
+[IPNetwork('0.0.0.0/0')]
+
+>>> cidr_merge(['0.0.0.0/0', '192.0.2.0/24', '10.0.0.0/8'])
+[IPNetwork('0.0.0.0/0')]
+
+}}}
+
+Same goes for the IPv6 CIDR ::/0, representing the whole of the IPv6 address space.
+
+{{{
+
+>>> cidr_merge(['::/0', 'fe80::1'])
+[IPNetwork('::/0')]
+
+>>> cidr_merge(['::/0', '::'])
+[IPNetwork('::/0')]
+
+>>> cidr_merge(['::/0', '::192.0.2.0/124', 'ff00::101'])
+[IPNetwork('::/0')]
+
+}}}
+
+This also applies to mixed IPv4 and IPv6 address lists.
+
+{{{
+
+>>> cidr_merge(['0.0.0.0/0', '0.0.0.0', '::/0', '::'])
+[IPNetwork('0.0.0.0/0'), IPNetwork('::/0')]
+
+}}}

netaddr/tests/2.x/ip/ipglob.txt

@@ -0,0 +1,72 @@
+=IP Glob Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+IP Glob tests.
+
+{{{
+
+>>> cidr_to_glob('10.0.0.1/32')
+'10.0.0.1'
+
+>>> cidr_to_glob('192.0.2.0/24')
+'192.0.2.*'
+
+>>> cidr_to_glob('172.16.0.0/12')
+'172.16-31.*.*'
+
+>>> cidr_to_glob('0.0.0.0/0')
+'*.*.*.*'
+
+>>> glob_to_cidrs('10.0.0.1')
+[IPNetwork('10.0.0.1/32')]
+
+>>> glob_to_cidrs('192.0.2.*')
+[IPNetwork('192.0.2.0/24')]
+
+>>> glob_to_cidrs('172.16-31.*.*')
+[IPNetwork('172.16.0.0/12')]
+
+>>> glob_to_cidrs('*.*.*.*')
+[IPNetwork('0.0.0.0/0')]
+
+>>> glob_to_iptuple('*.*.*.*')
+(IPAddress('0.0.0.0'), IPAddress('255.255.255.255'))
+
+>>> iprange_to_globs('192.0.2.0', '192.0.2.255')
+['192.0.2.*']
+
+>>> iprange_to_globs('192.0.2.1', '192.0.2.15')
+['192.0.2.1-15']
+
+>>> iprange_to_globs('192.0.2.255', '192.0.4.1')
+['192.0.2.255', '192.0.3.*', '192.0.4.0-1']
+
+>>> iprange_to_globs('10.0.1.255', '10.0.255.255')
+['10.0.1.255', '10.0.2-3.*', '10.0.4-7.*', '10.0.8-15.*', '10.0.16-31.*', '10.0.32-63.*', '10.0.64-127.*', '10.0.128-255.*']
+
+}}}
+
+Validity tests.
+
+{{{
+
+>>> valid_glob('1.1.1.a')
+False
+
+>>> valid_glob('1.1.1.1/32')
+False
+
+>>> valid_glob('1.1.1.a-b')
+False
+
+>>> valid_glob('1.1.a-b.*')
+False
+
+}}}

netaddr/tests/2.x/ip/iprange.txt

@@ -0,0 +1,171 @@
+=IPRange Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Constructor tests.
+
+{{{
+
+>>> iprange = IPRange('192.0.2.1', '192.0.2.254')
+
+>>> iprange
+IPRange('192.0.2.1', '192.0.2.254')
+
+>>> '%s' % iprange
+'192.0.2.1-192.0.2.254'
+
+>>> IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+
+>>> IPRange('192.0.2.1', '192.0.2.1')
+IPRange('192.0.2.1', '192.0.2.1')
+
+>>> IPRange('208.049.164.000', '208.050.066.255', flags=ZEROFILL)
+IPRange('208.49.164.0', '208.50.66.255')
+
+}}}
+
+Bad constructor tests.
+
+{{{
+
+>>> IPRange('192.0.2.2', '192.0.2.1')
+Traceback (most recent call last):
+...
+AddrFormatError: lower bound IP greater than upper bound!
+
+>>> IPRange('::', '0.0.0.1')
+Traceback (most recent call last):
+...
+AddrFormatError: base address '0.0.0.1' is not IPv6
+
+>>> IPRange('0.0.0.0', '::1')
+Traceback (most recent call last):
+...
+AddrFormatError: base address '::1' is not IPv4
+
+}}}
+
+Indexing and slicing tests.
+
+{{{
+
+>>> iprange = IPRange('192.0.2.1', '192.0.2.254')
+
+>>> len(iprange)
+254
+
+>>> iprange.first == 3221225985
+True
+
+>>> iprange.last == 3221226238
+True
+
+>>> iprange[0]
+IPAddress('192.0.2.1')
+
+>>> iprange[-1]
+IPAddress('192.0.2.254')
+
+>>> iprange[512]
+Traceback (most recent call last):
+...
+IndexError: index out range for address range size!
+
+>>> list(iprange[0:3])
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3')]
+
+>>> list(iprange[0:10:2])
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.3'), IPAddress('192.0.2.5'), IPAddress('192.0.2.7'), IPAddress('192.0.2.9')]
+
+>>> list(iprange[0:1024:512])
+[IPAddress('192.0.2.1')]
+
+>>> IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')[0:10:2]
+Traceback (most recent call last):
+...
+TypeError: IPv6 slices are not supported!
+
+}}}
+
+Membership tests.
+
+{{{
+
+>>> IPRange('192.0.2.5', '192.0.2.10') in IPRange('192.0.2.1', '192.0.2.254')
+True
+
+>>> IPRange('fe80::1', 'fe80::fffe') in IPRange('fe80::', 'fe80::ffff:ffff:ffff:ffff')
+True
+
+>>> IPRange('192.0.2.5', '192.0.2.10') in IPRange('::', '::255.255.255.255')
+False
+
+}}}
+
+Sorting tests.
+
+{{{
+
+>>> ipranges = (IPRange('192.0.2.40', '192.0.2.50'), IPRange('192.0.2.20', '192.0.2.30'), IPRange('192.0.2.1', '192.0.2.254'),)
+
+>>> sorted(ipranges)
+[IPRange('192.0.2.1', '192.0.2.254'), IPRange('192.0.2.20', '192.0.2.30'), IPRange('192.0.2.40', '192.0.2.50')]
+
+>>> ipranges = list(ipranges)
+
+>>> ipranges.append(IPRange('192.0.2.45', '192.0.2.49'))
+
+>>> sorted(ipranges)
+[IPRange('192.0.2.1', '192.0.2.254'), IPRange('192.0.2.20', '192.0.2.30'), IPRange('192.0.2.40', '192.0.2.50'), IPRange('192.0.2.45', '192.0.2.49')]
+
+}}}
+
+CIDR interoperability tests.
+
+{{{
+
+>>> IPRange('192.0.2.5', '192.0.2.10').cidrs()
+[IPNetwork('192.0.2.5/32'), IPNetwork('192.0.2.6/31'), IPNetwork('192.0.2.8/31'), IPNetwork('192.0.2.10/32')]
+
+>>> IPRange('fe80::', 'fe80::ffff:ffff:ffff:ffff').cidrs()
+[IPNetwork('fe80::/64')]
+
+}}}
+
+Various additional tests.
+
+{{{
+
+>>> iprange.info
+{'IPv4': [{'date': '1993-05',
+ 'designation': 'Administered by ARIN',
+ 'prefix': '192/8',
+ 'status': 'Legacy',
+ 'whois': 'whois.arin.net'}]}
+
+>>> iprange.is_private()
+True
+
+>>> iprange.version
+4
+
+len() fails when the IPRange is longer than sys.maxint, which is quite likely with IPv6.
+>>> from netaddr.compat import _sys_maxint
+>>> r = IPRange(IPAddress("::0"), IPAddress(_sys_maxint, 6))
+>>> len(r)
+Traceback (most recent call last):
+  ...
+IndexError: range contains more than ...
+
+>>> r = IPRange(IPAddress("::0"), IPAddress(_sys_maxint - 1, 6))
+>>> len(r) == _sys_maxint
+True
+
+}}}

netaddr/tests/2.x/ip/matches.txt

@@ -0,0 +1,71 @@
+=IP Matching Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+>>> largest_matching_cidr('192.0.2.0', ['192.0.2.0'])
+IPNetwork('192.0.2.0/32')
+
+>>> largest_matching_cidr('192.0.2.0', ['10.0.0.1', '192.0.2.0'])
+IPNetwork('192.0.2.0/32')
+
+>>> largest_matching_cidr('192.0.2.0', ['10.0.0.1', '192.0.2.0', '224.0.0.1'])
+IPNetwork('192.0.2.0/32')
+
+>>> smallest_matching_cidr('192.0.2.0', ['10.0.0.1', '192.0.2.0', '224.0.0.1'])
+IPNetwork('192.0.2.0/32')
+
+>>> smallest_matching_cidr('192.0.2.32', ['0.0.0.0/0', '10.0.0.0/8', '192.0.0.0/8', '192.0.1.0/24', '192.0.2.0/24', '192.0.3.0/24'])
+IPNetwork('192.0.2.0/24')
+
+>>> all_matching_cidrs('192.0.2.32', ['0.0.0.0/0', '10.0.0.0/8', '192.0.0.0/8', '192.0.1.0/24', '192.0.2.0/24', '192.0.3.0/24'])
+[IPNetwork('0.0.0.0/0'), IPNetwork('192.0.0.0/8'), IPNetwork('192.0.2.0/24')]
+
+>>> smallest_matching_cidr('192.0.2.0', ['10.0.0.1', '224.0.0.1'])
+
+>>> largest_matching_cidr('192.0.2.0', ['10.0.0.1', '224.0.0.1'])
+
+>>> networks = [str(c) for c in IPNetwork('192.0.2.128/27').supernet(22)]
+
+>>> networks
+['192.0.0.0/22', '192.0.2.0/23', '192.0.2.0/24', '192.0.2.128/25', '192.0.2.128/26']
+
+>>> all_matching_cidrs('192.0.2.0', networks)
+[IPNetwork('192.0.0.0/22'), IPNetwork('192.0.2.0/23'), IPNetwork('192.0.2.0/24')]
+
+>>> smallest_matching_cidr('192.0.2.0', networks)
+IPNetwork('192.0.2.0/24')
+
+>>> largest_matching_cidr('192.0.2.0', networks)
+IPNetwork('192.0.0.0/22')
+
+}}}
+
+Checking matches with varying IP address versions.
+
+{{{
+>>> all_matching_cidrs('192.0.2.0', ['192.0.2.0/24'])
+[IPNetwork('192.0.2.0/24')]
+
+>>> all_matching_cidrs('192.0.2.0', ['::/96'])
+[]
+
+>>> all_matching_cidrs('::ffff:192.0.2.1', ['::ffff:192.0.2.0/96'])
+[IPNetwork('::ffff:192.0.2.0/96')]
+
+>>> all_matching_cidrs('::192.0.2.1', ['::192.0.2.0/96'])
+[IPNetwork('::192.0.2.0/96')]
+
+>>> all_matching_cidrs('::192.0.2.1', ['192.0.2.0/23'])
+[]
+
+>>> all_matching_cidrs('::192.0.2.1', ['192.0.2.0/24', '::192.0.2.0/120'])
+[IPNetwork('::192.0.2.0/120')]
+
+>>> all_matching_cidrs('::192.0.2.1', [IPNetwork('192.0.2.0/24'), IPNetwork('::192.0.2.0/120')])
+[IPNetwork('::192.0.2.0/120')]
+
+}}}

netaddr/tests/2.x/ip/multicast.txt

@@ -0,0 +1,30 @@
+=IP Multicast Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+>>> ip = IPAddress('239.192.0.1')
+
+>>> ip.is_multicast()
+True
+
+>>> ip = IPAddress(3221225984)
+
+>>> ip = IPAddress('224.0.1.173')
+
+>>> ip.info.IPv4[0].designation
+'Multicast'
+
+>>> ip.info.IPv4[0].prefix
+'224/8'
+
+>>> ip.info.IPv4[0].status
+'Reserved'
+
+>>> ip.info.Multicast[0].address
+'224.0.1.173'
+
+}}

netaddr/tests/2.x/ip/nmap.txt

@@ -0,0 +1,118 @@
+=nmap IP Range Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+nmap IP range validation.
+
+{{{
+
+>>> valid_nmap_range('192.0.2.1')
+True
+    
+>>> valid_nmap_range('192.0.2.0-31')
+True
+
+>>> valid_nmap_range('192.0.2-3.1-254')
+True
+
+>>> valid_nmap_range('0-255.0-255.0-255.0-255')
+True
+
+>>> valid_nmap_range('192.168.3-5,7.1')
+True
+
+>>> valid_nmap_range('192.168.3-5,7,10-12,13,14.1')
+True
+
+>>> valid_nmap_range(1)
+False
+
+>>> valid_nmap_range('1')
+False
+
+>>> valid_nmap_range([])
+False
+
+>>> valid_nmap_range({})
+False
+
+>>> valid_nmap_range('::')
+False
+
+>>> valid_nmap_range('255.255.255.256')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.0-256')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.-1-0')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.256-0')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.255-0')
+False
+
+>>> valid_nmap_range('a.b.c.d-e')
+False
+
+>>> valid_nmap_range('255.255.255.a-b')
+False
+
+}}}
+
+nmap IP range iteration.
+
+{{{
+
+>>> list(iter_nmap_range('192.0.2.1'))
+[IPAddress('192.0.2.1')]
+    
+>>> ip_list = list(iter_nmap_range('192.0.2.0-31'))
+>>> len(ip_list)
+32
+>>> ip_list
+[IPAddress('192.0.2.0'), IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3'), IPAddress('192.0.2.4'), IPAddress('192.0.2.5'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), IPAddress('192.0.2.8'), IPAddress('192.0.2.9'), IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPAddress('192.0.2.12'), IPAddress('192.0.2.13'), IPAddress('192.0.2.14'), IPAddress('192.0.2.15'), IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), IPAddress('192.0.2.18'), IPAddress('192.0.2.19'), IPAddress('192.0.2.20'), IPAddress('192.0.2.21'), IPAddress('192.0.2.22'), IPAddress('192.0.2.23'), IPAddress('192.0.2.24'), IPAddress('192.0.2.25'), IPAddress('192.0.2.26'), IPAddress('192.0.2.27'), IPAddress('192.0.2.28'), IPAddress('192.0.2.29'), IPAddress('192.0.2.30'), IPAddress('192.0.2.31')]
+
+>>> ip_list = list(iter_nmap_range('192.0.2-3.1-7'))
+>>> len(ip_list)
+14
+
+>>> list(iter_nmap_range('192.0.2.1-3,5,7-9'))
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3'), IPAddress('192.0.2.5'), IPAddress('192.0.2.7'), IPAddress('192.0.2.8'), IPAddress('192.0.2.9')]
+
+>>> for ip in ip_list:
+...     print ip
+...     
+192.0.2.1
+192.0.2.2
+192.0.2.3
+192.0.2.4
+192.0.2.5
+192.0.2.6
+192.0.2.7
+192.0.3.1
+192.0.3.2
+192.0.3.3
+192.0.3.4
+192.0.3.5
+192.0.3.6
+192.0.3.7
+
+>>> list(iter_nmap_range('::'))
+Traceback (most recent call last):
+...
+AddrFormatError: invalid nmap range: ::
+
+Remove duplicates, just like nmap does.
+>>> list(iter_nmap_range('10.0.0.42,42-42'))
+[IPAddress('10.0.0.42')]
+
+}}}

netaddr/tests/2.x/ip/pickling.txt

@@ -0,0 +1,214 @@
+=IP Persistence Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+>>> import pickle
+
+}}}
+
+IPAddress object pickling - IPv4.
+
+{{{
+
+>>> ip = IPAddress(3221225985)
+>>> ip
+IPAddress('192.0.2.1')
+
+>>> buf = pickle.dumps(ip)
+
+>>> ip2 = pickle.loads(buf)
+
+>>> ip2 == ip
+True
+
+>>> id(ip2) != id(ip)
+True
+
+>>> ip2.value == 3221225985
+True
+
+>>> ip2.version
+4
+
+>>> del ip, buf, ip2
+
+}}}
+
+IPAddress object pickling - IPv6.
+
+{{{
+
+>>> ip = IPAddress('::ffff:192.0.2.1')
+
+>>> ip
+IPAddress('::ffff:192.0.2.1')
+
+>>> ip.value == 281473902969345
+True
+
+>>> buf = pickle.dumps(ip)
+
+>>> ip2 = pickle.loads(buf)
+
+>>> ip2 == ip
+True
+
+>>> ip2.value == 281473902969345
+True
+
+>>> ip2.version
+6
+
+>>> del ip, buf, ip2
+
+}}}
+
+IPNetwork pickling - IPv4.
+
+{{{
+
+>>> cidr = IPNetwork('192.0.2.0/24')
+>>> cidr
+IPNetwork('192.0.2.0/24')
+
+>>> buf = pickle.dumps(cidr)
+
+>>> cidr2 = pickle.loads(buf)
+
+>>> cidr2 == cidr
+True
+
+>>> id(cidr2) != id(cidr)
+True
+
+>>> cidr2.value == 3221225984
+True
+
+>>> cidr2.prefixlen
+24
+
+>>> cidr2.version
+4
+
+>>> del cidr, buf, cidr2
+
+}}}
+
+IPNetwork object pickling - IPv6.
+
+{{{
+
+>>> cidr = IPNetwork('::ffff:192.0.2.0/120')
+
+>>> cidr
+IPNetwork('::ffff:192.0.2.0/120')
+
+>>> cidr.value == 281473902969344
+True
+
+>>> cidr.prefixlen
+120
+
+>>> buf = pickle.dumps(cidr)
+
+>>> cidr2 = pickle.loads(buf)
+
+>>> cidr2 == cidr
+True
+
+>>> cidr2.value == 281473902969344
+True
+
+>>> cidr2.prefixlen
+120
+
+>>> cidr2.version
+6
+
+>>> del cidr, buf, cidr2
+
+}}}
+
+}}}
+
+IPRange object pickling - IPv4.
+
+{{{
+
+>>> iprange = IPRange('192.0.2.1', '192.0.2.254')
+>>> iprange
+IPRange('192.0.2.1', '192.0.2.254')
+
+>>> iprange.first == 3221225985
+True
+
+>>> iprange.last == 3221226238
+True
+
+>>> iprange.version
+4
+
+>>> buf = pickle.dumps(iprange)
+
+>>> iprange2 = pickle.loads(buf)
+
+>>> iprange2 == iprange
+True
+
+>>> id(iprange2) != id(iprange)
+True
+
+>>> iprange2.first == 3221225985
+True
+
+>>> iprange2.last == 3221226238
+True
+
+>>> iprange2.version
+4
+
+>>> del iprange, buf, iprange2
+
+}}}
+
+IPRange object pickling - IPv6.
+
+{{{
+
+>>> iprange = IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+
+>>> iprange
+IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+
+>>> iprange.first == 281473902969345
+True
+
+>>> iprange.last == 281473902969598
+True
+
+>>> iprange.version
+6
+
+>>> buf = pickle.dumps(iprange)
+
+>>> iprange2 = pickle.loads(buf)
+
+>>> iprange2 == iprange
+True
+
+>>> iprange2.first == 281473902969345
+True
+
+>>> iprange2.last == 281473902969598
+True
+
+>>> iprange2.version
+6
+
+>>> del iprange, buf, iprange2
+
+}}}
+

netaddr/tests/2.x/ip/platform_darwin.txt

@@ -0,0 +1,90 @@
+=Mac OSX Specific Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Worst case IPv4 compatible IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::1', '::255.255.255.254'):
+...     ip
+...
+IPNetwork('::1/128')
+IPNetwork('::0.0.0.2/127')
+IPNetwork('::0.0.0.4/126')
+IPNetwork('::0.0.0.8/125')
+IPNetwork('::0.0.0.16/124')
+IPNetwork('::0.0.0.32/123')
+IPNetwork('::0.0.0.64/122')
+IPNetwork('::0.0.0.128/121')
+IPNetwork('::0.0.1.0/120')
+IPNetwork('::0.0.2.0/119')
+IPNetwork('::0.0.4.0/118')
+IPNetwork('::0.0.8.0/117')
+IPNetwork('::0.0.16.0/116')
+IPNetwork('::0.0.32.0/115')
+IPNetwork('::0.0.64.0/114')
+IPNetwork('::0.0.128.0/113')
+IPNetwork('::0.1.0.0/112')
+IPNetwork('::0.2.0.0/111')
+IPNetwork('::0.4.0.0/110')
+IPNetwork('::0.8.0.0/109')
+IPNetwork('::0.16.0.0/108')
+IPNetwork('::0.32.0.0/107')
+IPNetwork('::0.64.0.0/106')
+IPNetwork('::0.128.0.0/105')
+IPNetwork('::1.0.0.0/104')
+IPNetwork('::2.0.0.0/103')
+IPNetwork('::4.0.0.0/102')
+IPNetwork('::8.0.0.0/101')
+IPNetwork('::16.0.0.0/100')
+IPNetwork('::32.0.0.0/99')
+IPNetwork('::64.0.0.0/98')
+IPNetwork('::128.0.0.0/98')
+IPNetwork('::192.0.0.0/99')
+IPNetwork('::224.0.0.0/100')
+IPNetwork('::240.0.0.0/101')
+IPNetwork('::248.0.0.0/102')
+IPNetwork('::252.0.0.0/103')
+IPNetwork('::254.0.0.0/104')
+IPNetwork('::255.0.0.0/105')
+IPNetwork('::255.128.0.0/106')
+IPNetwork('::255.192.0.0/107')
+IPNetwork('::255.224.0.0/108')
+IPNetwork('::255.240.0.0/109')
+IPNetwork('::255.248.0.0/110')
+IPNetwork('::255.252.0.0/111')
+IPNetwork('::255.254.0.0/112')
+IPNetwork('::255.255.0.0/113')
+IPNetwork('::255.255.128.0/114')
+IPNetwork('::255.255.192.0/115')
+IPNetwork('::255.255.224.0/116')
+IPNetwork('::255.255.240.0/117')
+IPNetwork('::255.255.248.0/118')
+IPNetwork('::255.255.252.0/119')
+IPNetwork('::255.255.254.0/120')
+IPNetwork('::255.255.255.0/121')
+IPNetwork('::255.255.255.128/122')
+IPNetwork('::255.255.255.192/123')
+IPNetwork('::255.255.255.224/124')
+IPNetwork('::255.255.255.240/125')
+IPNetwork('::255.255.255.248/126')
+IPNetwork('::255.255.255.252/127')
+IPNetwork('::255.255.255.254/128')
+
+#   inet_pton has to be different on Mac OSX *sigh*
+>>> IPAddress('010.000.000.001', flags=INET_PTON)
+IPAddress('10.0.0.1')
+
+>>> from netaddr.strategy.ipv6 import int_to_str
+>>> int_to_str(0xffff)
+'::0.0.255.255'
+
+}}}
+

netaddr/tests/2.x/ip/platform_linux2.txt

@@ -0,0 +1,94 @@
+=Linux Specific Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Worst case IPv4 compatible IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::1', '::255.255.255.254'):
+...     ip
+...
+IPNetwork('::1/128')
+IPNetwork('::2/127')
+IPNetwork('::4/126')
+IPNetwork('::8/125')
+IPNetwork('::10/124')
+IPNetwork('::20/123')
+IPNetwork('::40/122')
+IPNetwork('::80/121')
+IPNetwork('::100/120')
+IPNetwork('::200/119')
+IPNetwork('::400/118')
+IPNetwork('::800/117')
+IPNetwork('::1000/116')
+IPNetwork('::2000/115')
+IPNetwork('::4000/114')
+IPNetwork('::8000/113')
+IPNetwork('::0.1.0.0/112')
+IPNetwork('::0.2.0.0/111')
+IPNetwork('::0.4.0.0/110')
+IPNetwork('::0.8.0.0/109')
+IPNetwork('::0.16.0.0/108')
+IPNetwork('::0.32.0.0/107')
+IPNetwork('::0.64.0.0/106')
+IPNetwork('::0.128.0.0/105')
+IPNetwork('::1.0.0.0/104')
+IPNetwork('::2.0.0.0/103')
+IPNetwork('::4.0.0.0/102')
+IPNetwork('::8.0.0.0/101')
+IPNetwork('::16.0.0.0/100')
+IPNetwork('::32.0.0.0/99')
+IPNetwork('::64.0.0.0/98')
+IPNetwork('::128.0.0.0/98')
+IPNetwork('::192.0.0.0/99')
+IPNetwork('::224.0.0.0/100')
+IPNetwork('::240.0.0.0/101')
+IPNetwork('::248.0.0.0/102')
+IPNetwork('::252.0.0.0/103')
+IPNetwork('::254.0.0.0/104')
+IPNetwork('::255.0.0.0/105')
+IPNetwork('::255.128.0.0/106')
+IPNetwork('::255.192.0.0/107')
+IPNetwork('::255.224.0.0/108')
+IPNetwork('::255.240.0.0/109')
+IPNetwork('::255.248.0.0/110')
+IPNetwork('::255.252.0.0/111')
+IPNetwork('::255.254.0.0/112')
+IPNetwork('::255.255.0.0/113')
+IPNetwork('::255.255.128.0/114')
+IPNetwork('::255.255.192.0/115')
+IPNetwork('::255.255.224.0/116')
+IPNetwork('::255.255.240.0/117')
+IPNetwork('::255.255.248.0/118')
+IPNetwork('::255.255.252.0/119')
+IPNetwork('::255.255.254.0/120')
+IPNetwork('::255.255.255.0/121')
+IPNetwork('::255.255.255.128/122')
+IPNetwork('::255.255.255.192/123')
+IPNetwork('::255.255.255.224/124')
+IPNetwork('::255.255.255.240/125')
+IPNetwork('::255.255.255.248/126')
+IPNetwork('::255.255.255.252/127')
+IPNetwork('::255.255.255.254/128')
+
+#   Sadly, inet_pton cannot help us here ...
+>>> IPAddress('010.000.000.001', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '010.000.000.001'
+
+>>> from netaddr.strategy.ipv6 import int_to_str
+>>> int_to_str(0xffff)
+'::ffff'
+
+}}}
+
+
+

netaddr/tests/2.x/ip/platform_win32.txt

@@ -0,0 +1,92 @@
+=Windows Specific Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Worst case IPv4 compatible IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::1', '::255.255.255.254'):
+...     ip
+...
+IPNetwork('::1/128')
+IPNetwork('::2/127')
+IPNetwork('::4/126')
+IPNetwork('::8/125')
+IPNetwork('::10/124')
+IPNetwork('::20/123')
+IPNetwork('::40/122')
+IPNetwork('::80/121')
+IPNetwork('::100/120')
+IPNetwork('::200/119')
+IPNetwork('::400/118')
+IPNetwork('::800/117')
+IPNetwork('::1000/116')
+IPNetwork('::2000/115')
+IPNetwork('::4000/114')
+IPNetwork('::8000/113')
+IPNetwork('::0.1.0.0/112')
+IPNetwork('::0.2.0.0/111')
+IPNetwork('::0.4.0.0/110')
+IPNetwork('::0.8.0.0/109')
+IPNetwork('::0.16.0.0/108')
+IPNetwork('::0.32.0.0/107')
+IPNetwork('::0.64.0.0/106')
+IPNetwork('::0.128.0.0/105')
+IPNetwork('::1.0.0.0/104')
+IPNetwork('::2.0.0.0/103')
+IPNetwork('::4.0.0.0/102')
+IPNetwork('::8.0.0.0/101')
+IPNetwork('::16.0.0.0/100')
+IPNetwork('::32.0.0.0/99')
+IPNetwork('::64.0.0.0/98')
+IPNetwork('::128.0.0.0/98')
+IPNetwork('::192.0.0.0/99')
+IPNetwork('::224.0.0.0/100')
+IPNetwork('::240.0.0.0/101')
+IPNetwork('::248.0.0.0/102')
+IPNetwork('::252.0.0.0/103')
+IPNetwork('::254.0.0.0/104')
+IPNetwork('::255.0.0.0/105')
+IPNetwork('::255.128.0.0/106')
+IPNetwork('::255.192.0.0/107')
+IPNetwork('::255.224.0.0/108')
+IPNetwork('::255.240.0.0/109')
+IPNetwork('::255.248.0.0/110')
+IPNetwork('::255.252.0.0/111')
+IPNetwork('::255.254.0.0/112')
+IPNetwork('::255.255.0.0/113')
+IPNetwork('::255.255.128.0/114')
+IPNetwork('::255.255.192.0/115')
+IPNetwork('::255.255.224.0/116')
+IPNetwork('::255.255.240.0/117')
+IPNetwork('::255.255.248.0/118')
+IPNetwork('::255.255.252.0/119')
+IPNetwork('::255.255.254.0/120')
+IPNetwork('::255.255.255.0/121')
+IPNetwork('::255.255.255.128/122')
+IPNetwork('::255.255.255.192/123')
+IPNetwork('::255.255.255.224/124')
+IPNetwork('::255.255.255.240/125')
+IPNetwork('::255.255.255.248/126')
+IPNetwork('::255.255.255.252/127')
+IPNetwork('::255.255.255.254/128')
+
+#   Sadly, inet_pton cannot help us here ...
+>>> IPAddress('010.000.000.001', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: failed to detect a valid IP address from '010.000.000.001'
+
+>>> from netaddr.strategy.ipv6 import int_to_str
+>>> int_to_str(0xffff)
+'::ffff'
+
+}}}
+

netaddr/tests/2.x/ip/rfc1924.txt

@@ -0,0 +1,33 @@
+=RFC 1924 Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+The example from the RFC.
+
+{{{
+
+>>> from netaddr.ip.rfc1924 import ipv6_to_base85, base85_to_ipv6
+
+>>> ip_addr = '1080::8:800:200c:417a'
+
+>>> ip_addr
+'1080::8:800:200c:417a'
+    
+>>> base85 = ipv6_to_base85(ip_addr)
+
+>>> base85
+'4)+k&C#VzJ4br>0wv%Yp'
+
+RFC specifies that "leading zeroes are never omitted"
+>>> ipv6_to_base85("::1")
+'00000000000000000001'
+
+>>> base85_to_ipv6(base85)
+'1080::8:800:200c:417a'
+
+Invalid length for a base85 encoded IPv6 address
+>>> base85_to_ipv6('not 20 chars')
+Traceback (most recent call last):
+AddrFormatError: Invalid base 85 IPv6 address: 'not 20 chars'
+
+}}}

netaddr/tests/2.x/ip/sets.txt

@@ -0,0 +1,526 @@
+First of all you need to pull the various netaddr classes and functions into your namespace.
+
+.. note:: Do this for the purpose of this tutorial only. In your own code, you should be explicit about the classes, functions and constants you import to avoid name clashes.
+
+>>> from netaddr import *
+
+----------------
+Creating IP sets
+----------------
+
+Here how to create IP sets.
+
+An empty set.
+
+>>> IPSet()
+IPSet([])
+>>> IPSet([])
+IPSet([])
+>>> len(IPSet([]))
+0
+
+You can specify either IP addresses and networks as strings. Alternatively, you
+can use IPAddress, IPNetwork, IPRange or other IPSet objects.
+
+>>> IPSet(['192.0.2.0'])
+IPSet(['192.0.2.0/32'])
+>>> IPSet([IPAddress('192.0.2.0')])
+IPSet(['192.0.2.0/32'])
+>>> IPSet([IPNetwork('192.0.2.0')])
+IPSet(['192.0.2.0/32'])
+>>> IPSet(IPNetwork('1234::/32'))
+IPSet(['1234::/32'])
+>>> IPSet([IPNetwork('192.0.2.0/24')])
+IPSet(['192.0.2.0/24'])
+>>> IPSet(IPSet(['192.0.2.0/32']))
+IPSet(['192.0.2.0/32'])
+>>> IPSet(IPRange("10.0.0.0", "10.0.1.31"))
+IPSet(['10.0.0.0/24', '10.0.1.0/27'])
+>>> IPSet(IPRange('0.0.0.0', '255.255.255.255'))
+IPSet(['0.0.0.0/0'])
+
+You can interate over all the IP addresses that are members of the IP set.
+
+>>> for ip in IPSet(['192.0.2.0/28', '::192.0.2.0/124']):
+...     print ip
+192.0.2.0
+192.0.2.1
+192.0.2.2
+192.0.2.3
+192.0.2.4
+192.0.2.5
+192.0.2.6
+192.0.2.7
+192.0.2.8
+192.0.2.9
+192.0.2.10
+192.0.2.11
+192.0.2.12
+192.0.2.13
+192.0.2.14
+192.0.2.15
+::192.0.2.0
+::192.0.2.1
+::192.0.2.2
+::192.0.2.3
+::192.0.2.4
+::192.0.2.5
+::192.0.2.6
+::192.0.2.7
+::192.0.2.8
+::192.0.2.9
+::192.0.2.10
+::192.0.2.11
+::192.0.2.12
+::192.0.2.13
+::192.0.2.14
+::192.0.2.15
+
+--------------------------------
+Adding and removing set elements
+--------------------------------
+
+>>> s1 = IPSet()
+>>> s1.add('192.0.2.0')
+>>> s1
+IPSet(['192.0.2.0/32'])
+>>> s1.remove('192.0.2.0')
+>>> s1
+IPSet([])
+>>> s1.add(IPRange("10.0.0.0", "10.0.0.255"))
+>>> s1
+IPSet(['10.0.0.0/24'])
+>>> s1.remove(IPRange("10.0.0.128", "10.10.10.10"))
+>>> s1
+IPSet(['10.0.0.0/25'])
+
+--------------
+Set membership
+--------------
+
+Here is a simple arbitrary IP address range.
+
+>>> iprange = IPRange('192.0.1.255', '192.0.2.16')
+
+We can see the CIDR networks that can existing with this defined range.
+
+>>> iprange.cidrs()
+[IPNetwork('192.0.1.255/32'), IPNetwork('192.0.2.0/28'), IPNetwork('192.0.2.16/32')]
+
+Here's an IP set.
+
+>>> ipset = IPSet(['192.0.2.0/28'])
+
+Now, let's iterate over the IP addresses in the arbitrary IP address range and see if they are found within the IP set.
+
+>>> for ip in iprange:
+...     print ip, ip in ipset
+192.0.1.255 False
+192.0.2.0 True
+192.0.2.1 True
+192.0.2.2 True
+192.0.2.3 True
+192.0.2.4 True
+192.0.2.5 True
+192.0.2.6 True
+192.0.2.7 True
+192.0.2.8 True
+192.0.2.9 True
+192.0.2.10 True
+192.0.2.11 True
+192.0.2.12 True
+192.0.2.13 True
+192.0.2.14 True
+192.0.2.15 True
+192.0.2.16 False
+
+More exotic IPSets
+
+>>> bigone = IPSet(['0.0.0.0/0'])
+>>> IPAddress("10.0.0.1") in bigone
+True
+>>> IPAddress("0.0.0.0") in bigone
+True
+>>> IPAddress("255.255.255") in bigone
+True
+>>> IPNetwork("10.0.0.0/24") in bigone
+True
+>>> IPAddress("::1") in bigone
+False
+
+>>> smallone = IPSet(["10.0.0.42/32"])
+>>> IPAddress("10.0.0.42") in smallone
+True
+>>> IPAddress("10.0.0.41") in smallone
+False
+>>> IPAddress("10.0.0.43") in smallone
+False
+>>> IPNetwork("10.0.0.42/32") in smallone
+True
+>>> IPNetwork("10.0.0.42/31") in smallone
+False
+
+-------------------------------------
+Unions, intersections and differences
+-------------------------------------
+
+Here are some examples of union operations performed on `IPSet` objects.
+
+>>> IPSet(['192.0.2.0'])
+IPSet(['192.0.2.0/32'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1'])
+IPSet(['192.0.2.0/31'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3'])
+IPSet(['192.0.2.0/31', '192.0.2.3/32'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3/30'])
+IPSet(['192.0.2.0/30'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3/31'])
+IPSet(['192.0.2.0/30'])
+
+>>> IPSet(['192.0.2.0/24']) | IPSet(['192.0.3.0/24']) | IPSet(['192.0.4.0/24'])
+IPSet(['192.0.2.0/23', '192.0.4.0/24'])
+
+Here is an example of the union, intersection and symmetric difference operations all in play at the same time.
+
+>>> adj_cidrs = list(IPNetwork('192.0.2.0/24').subnet(28))
+>>> even_cidrs = adj_cidrs[::2]
+>>> evens = IPSet(even_cidrs)
+>>> evens
+IPSet(['192.0.2.0/28', '192.0.2.32/28', '192.0.2.64/28', '192.0.2.96/28', '192.0.2.128/28', '192.0.2.160/28', '192.0.2.192/28', '192.0.2.224/28'])
+>>> IPSet(['192.0.2.0/24']) & evens
+IPSet(['192.0.2.0/28', '192.0.2.32/28', '192.0.2.64/28', '192.0.2.96/28', '192.0.2.128/28', '192.0.2.160/28', '192.0.2.192/28', '192.0.2.224/28'])
+>>> odds = IPSet(['192.0.2.0/24']) ^ evens
+>>> odds
+IPSet(['192.0.2.16/28', '192.0.2.48/28', '192.0.2.80/28', '192.0.2.112/28', '192.0.2.144/28', '192.0.2.176/28', '192.0.2.208/28', '192.0.2.240/28'])
+>>> evens | odds
+IPSet(['192.0.2.0/24'])
+>>> evens & odds
+IPSet([])
+>>> evens ^ odds
+IPSet(['192.0.2.0/24'])
+
+---------------------
+Supersets and subsets
+---------------------
+
+IP sets provide the ability to test whether a group of addresses ranges fit within the set of another group of address ranges.
+
+>>> s1 = IPSet(['192.0.2.0/24', '192.0.4.0/24'])
+>>> s2 = IPSet(['192.0.2.0', '192.0.4.0'])
+>>> s1
+IPSet(['192.0.2.0/24', '192.0.4.0/24'])
+>>> s2
+IPSet(['192.0.2.0/32', '192.0.4.0/32'])
+>>> s1.issuperset(s2)
+True
+>>> s2.issubset(s1)
+True
+>>> s2.issuperset(s1)
+False
+>>> s1.issubset(s2)
+False
+
+Here's a more complete example using various well known IPv4 address ranges.
+
+>>> ipv4_addr_space = IPSet(['0.0.0.0/0'])
+>>> private = IPSet(['10.0.0.0/8', '172.16.0.0/12', '192.0.2.0/24', '192.168.0.0/16', '239.192.0.0/14'])
+>>> reserved = IPSet(['225.0.0.0/8', '226.0.0.0/7', '228.0.0.0/6', '234.0.0.0/7', '236.0.0.0/7', '238.0.0.0/8', '240.0.0.0/4'])
+>>> unavailable = reserved | private
+>>> available = ipv4_addr_space ^ unavailable
+
+Let's see what we've got:
+
+>>> for cidr in available.iter_cidrs():
+...     print cidr, cidr[0], cidr[-1]
+0.0.0.0/5 0.0.0.0 7.255.255.255
+8.0.0.0/7 8.0.0.0 9.255.255.255
+11.0.0.0/8 11.0.0.0 11.255.255.255
+12.0.0.0/6 12.0.0.0 15.255.255.255
+16.0.0.0/4 16.0.0.0 31.255.255.255
+32.0.0.0/3 32.0.0.0 63.255.255.255
+64.0.0.0/2 64.0.0.0 127.255.255.255
+128.0.0.0/3 128.0.0.0 159.255.255.255
+160.0.0.0/5 160.0.0.0 167.255.255.255
+168.0.0.0/6 168.0.0.0 171.255.255.255
+172.0.0.0/12 172.0.0.0 172.15.255.255
+172.32.0.0/11 172.32.0.0 172.63.255.255
+172.64.0.0/10 172.64.0.0 172.127.255.255
+172.128.0.0/9 172.128.0.0 172.255.255.255
+173.0.0.0/8 173.0.0.0 173.255.255.255
+174.0.0.0/7 174.0.0.0 175.255.255.255
+176.0.0.0/4 176.0.0.0 191.255.255.255
+192.0.0.0/23 192.0.0.0 192.0.1.255
+192.0.3.0/24 192.0.3.0 192.0.3.255
+192.0.4.0/22 192.0.4.0 192.0.7.255
+192.0.8.0/21 192.0.8.0 192.0.15.255
+192.0.16.0/20 192.0.16.0 192.0.31.255
+192.0.32.0/19 192.0.32.0 192.0.63.255
+192.0.64.0/18 192.0.64.0 192.0.127.255
+192.0.128.0/17 192.0.128.0 192.0.255.255
+192.1.0.0/16 192.1.0.0 192.1.255.255
+192.2.0.0/15 192.2.0.0 192.3.255.255
+192.4.0.0/14 192.4.0.0 192.7.255.255
+192.8.0.0/13 192.8.0.0 192.15.255.255
+192.16.0.0/12 192.16.0.0 192.31.255.255
+192.32.0.0/11 192.32.0.0 192.63.255.255
+192.64.0.0/10 192.64.0.0 192.127.255.255
+192.128.0.0/11 192.128.0.0 192.159.255.255
+192.160.0.0/13 192.160.0.0 192.167.255.255
+192.169.0.0/16 192.169.0.0 192.169.255.255
+192.170.0.0/15 192.170.0.0 192.171.255.255
+192.172.0.0/14 192.172.0.0 192.175.255.255
+192.176.0.0/12 192.176.0.0 192.191.255.255
+192.192.0.0/10 192.192.0.0 192.255.255.255
+193.0.0.0/8 193.0.0.0 193.255.255.255
+194.0.0.0/7 194.0.0.0 195.255.255.255
+196.0.0.0/6 196.0.0.0 199.255.255.255
+200.0.0.0/5 200.0.0.0 207.255.255.255
+208.0.0.0/4 208.0.0.0 223.255.255.255
+224.0.0.0/8 224.0.0.0 224.255.255.255
+232.0.0.0/7 232.0.0.0 233.255.255.255
+239.0.0.0/9 239.0.0.0 239.127.255.255
+239.128.0.0/10 239.128.0.0 239.191.255.255
+239.196.0.0/14 239.196.0.0 239.199.255.255
+239.200.0.0/13 239.200.0.0 239.207.255.255
+239.208.0.0/12 239.208.0.0 239.223.255.255
+239.224.0.0/11 239.224.0.0 239.255.255.255
+
+>>> ipv4_addr_space ^ available
+IPSet(['10.0.0.0/8', '172.16.0.0/12', '192.0.2.0/24', '192.168.0.0/16', '225.0.0.0/8', '226.0.0.0/7', '228.0.0.0/6', '234.0.0.0/7', '236.0.0.0/7', '238.0.0.0/8', '239.192.0.0/14', '240.0.0.0/4'])
+
+
+------------------------------
+Combined IPv4 and IPv6 support
+------------------------------
+
+In keeping with netaddr's pragmatic approach, you are free to mix and match IPv4 and IPv6 within the same data structure.
+
+>>> s1 = IPSet(['192.0.2.0', '::192.0.2.0', '192.0.2.2', '::192.0.2.2'])
+>>> s2 = IPSet(['192.0.2.2', '::192.0.2.2', '192.0.2.4', '::192.0.2.4'])
+
+>>> s1
+IPSet(['192.0.2.0/32', '192.0.2.2/32', '::192.0.2.0/128', '::192.0.2.2/128'])
+>>> s2
+IPSet(['192.0.2.2/32', '192.0.2.4/32', '::192.0.2.2/128', '::192.0.2.4/128'])
+
+^^^^^^^^^^^^^^^^^^^^^^^
+IPv4 and IPv6 set union
+^^^^^^^^^^^^^^^^^^^^^^^
+
+>>> s1 | s2
+IPSet(['192.0.2.0/32', '192.0.2.2/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.2/128', '::192.0.2.4/128'])
+>>> s2 | s1
+IPSet(['192.0.2.0/32', '192.0.2.2/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.2/128', '::192.0.2.4/128'])
+
+^^^^^^^^^^^^^^^^
+set intersection
+^^^^^^^^^^^^^^^^
+
+>>> s1 & s2
+IPSet(['192.0.2.2/32', '::192.0.2.2/128'])
+
+^^^^^^^^^^^^^^
+set difference
+^^^^^^^^^^^^^^
+
+>>> s1 - s2
+IPSet(['192.0.2.0/32', '::192.0.2.0/128'])
+>>> s2 - s1
+IPSet(['192.0.2.4/32', '::192.0.2.4/128'])
+
+^^^^^^^^^^^^^^^^^^^^^^^^
+set symmetric difference
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+>>> s1 ^ s2
+IPSet(['192.0.2.0/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.4/128'])
+
+------------------
+Disjointed IP sets
+------------------
+
+>>> s1 = IPSet(['192.0.2.0', '192.0.2.1', '192.0.2.2'])
+>>> s2 = IPSet(['192.0.2.2', '192.0.2.3', '192.0.2.4'])
+>>> s1 & s2
+IPSet(['192.0.2.2/32'])
+>>> s1.isdisjoint(s2)
+False
+>>> s1 = IPSet(['192.0.2.0', '192.0.2.1'])
+>>> s2 = IPSet(['192.0.2.3', '192.0.2.4'])
+>>> s1 & s2
+IPSet([])
+>>> s1.isdisjoint(s2)
+True
+
+------------------
+Updating an IP set
+------------------
+
+As with a normal Python set you can also update one IP set with the contents of another.
+
+>>> s1 = IPSet(['192.0.2.0/25'])
+>>> s1
+IPSet(['192.0.2.0/25'])
+>>> s2 = IPSet(['192.0.2.128/25'])
+>>> s2
+IPSet(['192.0.2.128/25'])
+>>> s1.update(s2)
+>>> s1
+IPSet(['192.0.2.0/24'])
+>>> s1.update(['192.0.0.0/24', '192.0.1.0/24', '192.0.3.0/24'])
+>>> s1
+IPSet(['192.0.0.0/22'])
+
+>>> s2 = IPSet(['10.0.0.0/16'])
+>>> s2.update(IPRange('10.1.0.0', '10.1.255.255'))
+>>> s2
+IPSet(['10.0.0.0/15'])
+
+>>> s2.clear()
+>>> s2
+IPSet([])
+
+--------------------------------
+Removing elements from an IP set
+--------------------------------
+
+Removing an IP address from an IPSet will split the CIDR subnets within it into their constituent parts.
+
+Here we create a set representing the entire IPv4 address space.
+
+>>> s1 = IPSet(['0.0.0.0/0'])
+>>> s1
+IPSet(['0.0.0.0/0'])
+
+Then we strip off the last address.
+
+>>> s1.remove('255.255.255.255')
+
+Leaving us with:
+
+>>> s1
+IPSet(['0.0.0.0/1', '128.0.0.0/2', ..., '255.255.255.252/31', '255.255.255.254/32'])
+>>> list(s1.iter_cidrs())
+[IPNetwork('0.0.0.0/1'), IPNetwork('128.0.0.0/2'), ..., IPNetwork('255.255.255.252/31'), IPNetwork('255.255.255.254/32')]
+>>> len(list(s1.iter_cidrs()))
+32
+
+Let's check the result using the `cidr_exclude` function.
+
+>>> list(s1.iter_cidrs()) == cidr_exclude('0.0.0.0/0', '255.255.255.255')
+True
+
+Next, let's remove the first address from the original range.
+
+>>> s1.remove('0.0.0.0')
+
+This fractures the CIDR subnets further.
+
+>>> s1
+IPSet(['0.0.0.1/32', '0.0.0.2/31', ..., '255.255.255.252/31', '255.255.255.254/32'])
+>>> len(list(s1.iter_cidrs()))
+62
+
+You can keep doing this but be aware that large IP sets can take up a lot of memory if they contain many thousands of entries.
+
+----------------------------
+Adding elements to an IP set
+----------------------------
+
+Let's fix up the fractured IP set from the previous section by re-adding the IP addresses we removed.
+
+>>> s1.add('255.255.255.255')
+>>> s1
+IPSet(['0.0.0.1/32', '0.0.0.2/31', ..., '64.0.0.0/2', '128.0.0.0/1'])
+
+Getting better.
+
+>>> list(s1.iter_cidrs())
+[IPNetwork('0.0.0.1/32'), IPNetwork('0.0.0.2/31'), ..., IPNetwork('64.0.0.0/2'), IPNetwork('128.0.0.0/1')]
+
+>>> len(list(s1.iter_cidrs()))
+32
+
+Add back the other IP address.
+
+>>> s1.add('0.0.0.0')
+
+And we're back to our original address.
+
+>>> s1
+IPSet(['0.0.0.0/0'])
+
+--------------------------------
+Convert an IP set to an IP Range
+--------------------------------
+Sometimes you may want to convert an IPSet back to an IPRange.
+
+>>> s1 = IPSet(['10.0.0.0/25', '10.0.0.128/25'])
+>>> s1.iprange()
+IPRange('10.0.0.0', '10.0.0.255')
+
+This only works if the IPSet is contiguous
+
+>>> s1.iscontiguous()
+True
+>>> s1.remove('10.0.0.16')
+>>> s1
+IPSet(['10.0.0.0/28', '10.0.0.17/32', '10.0.0.18/31', '10.0.0.20/30', '10.0.0.24/29', '10.0.0.32/27', '10.0.0.64/26', '10.0.0.128/25'])
+>>> s1.iscontiguous()
+False
+>>> s1.iprange()
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ValueError: IPSet is not contiguous
+
+If it is not contiguous, you can still convert the IPSet, but you will get multiple IPRanges.
+>>> list(s1.iter_ipranges())
+[IPRange('10.0.0.0', '10.0.0.15'), IPRange('10.0.0.17', '10.0.0.255')]
+
+>>> s2 = IPSet(['0.0.0.0/0'])
+>>> s2.iscontiguous()
+True
+>>> s2.iprange()
+IPRange('0.0.0.0', '255.255.255.255')
+
+>>> s3 = IPSet()
+>>> s3.iscontiguous()
+True
+>>> s3.iprange()
+
+>>> s4 = IPSet(IPRange('10.0.0.0', '10.0.0.8'))
+>>> s4.iscontiguous()
+True
+
+----------------------
+Pickling IPSet objects
+----------------------
+
+As with all other netaddr classes, you can use ``pickle`` to persist IP sets for later use.
+
+>>> import pickle
+>>> ip_data = IPSet(['10.0.0.0/16', 'fe80::/64'])
+>>> buf = pickle.dumps(ip_data)
+>>> ip_data_unpickled = pickle.loads(buf)
+>>> ip_data == ip_data_unpickled
+True
+
+----------------------
+Compare IPSet objects
+----------------------
+
+>>> x = IPSet(['fc00::/2'])
+>>> y = IPSet(['fc00::/3'])
+
+>>> x > y
+True
+
+>>> x < y
+False
+
+>>> x != y
+True

netaddr/tests/2.x/ip/sets_non_sphinx.txt

@@ -0,0 +1,166 @@
+Since "sets.txt" is used by Sphinx to build the documentation, those test cases for IPSet that should not become part of the documenation go here. The tests for Python3 are not imported by Sphinx, though.
+
+>>> from netaddr import *
+
+--------------------------------
+Adding and removing set elements
+--------------------------------
+
+>>> s1 = IPSet(['10.0.0.0/25'])
+
+This hits a special case in IPSet._compact_single_network()
+>>> s1.add('10.0.0.0/24')
+>>> s1
+IPSet(['10.0.0.0/24'])
+
+Various places must also accept integers.
+>>> integer1 = int(IPAddress('10.0.0.1'))
+>>> integer2 = int(IPAddress('fe80::'))
+>>> integer3 = int(IPAddress('10.0.0.2'))
+>>> s2 = IPSet([integer1, integer2])
+>>> s2
+IPSet(['10.0.0.1/32', 'fe80::/128'])
+>>> s2.add(integer3)
+>>> s2
+IPSet(['10.0.0.1/32', '10.0.0.2/32', 'fe80::/128'])
+>>> s2.remove(integer2)
+>>> s2
+IPSet(['10.0.0.1/32', '10.0.0.2/32'])
+>>> s2.update([integer2])
+>>> s2
+IPSet(['10.0.0.1/32', '10.0.0.2/32', 'fe80::/128'])
+
+------------------------------
+Combined IPv4 and IPv6 support
+------------------------------
+
+In keeping with netaddr's pragmatic approach, you are free to mix and match IPv4 and IPv6 within the same data structure.
+
+>>> s1 = IPSet(['192.0.2.0', '::192.0.2.0', '192.0.2.2', '::192.0.2.2'])
+>>> s2 = IPSet(['192.0.2.2', '::192.0.2.2', '192.0.2.4', '::192.0.2.4'])
+
+IPSets with IPNetworks that need to be merged or split (sometimes multiple times) during various set operations.
+IPNetwork('10.0.0.64/30') is the same as IPRange('10.0.0.64', '10.0.0.67')
+>>> s3 = IPSet(['0.0.0.1', '10.0.0.64/30', '255.255.255.1'])
+>>> s4 = IPSet(['10.0.0.64', '10.0.0.66'])
+>>> s4b = IPSet(['10.0.0.64', '10.0.0.66', '111.111.111.111'])
+>>> s5 = IPSet(['10.0.0.65', '10.0.0.67'])
+
+The documentation show various "s1 <operator> s2" examples. Tests below check that "s2 <operator> s1" also works. Additionally, operations on s3, s4... are performed.
+
+IPSets must be usable in boolean context, even when they are very large.
+>>> s6 = IPSet(['2405:8100::/32'])
+>>> bool(s6)
+True
+>>> bool(IPSet())
+False
+
+^^^^^^^^^^^^^^^^
+set intersection
+^^^^^^^^^^^^^^^^
+>>> s2 & s1
+IPSet(['192.0.2.2/32', '::192.0.2.2/128'])
+
+>>> s3 & s4
+IPSet(['10.0.0.64/32', '10.0.0.66/32'])
+>>> s4 & s3
+IPSet(['10.0.0.64/32', '10.0.0.66/32'])
+
+>>> s3 & s5
+IPSet(['10.0.0.65/32', '10.0.0.67/32'])
+>>> s5 & s3
+IPSet(['10.0.0.65/32', '10.0.0.67/32'])
+
+^^^^^^^^^^^^^^
+set difference
+^^^^^^^^^^^^^^
+
+>>> s3 - s4
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+>>> s4 - s3
+IPSet([])
+>>> s3 - s4b
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+
+>>> s3 - s5
+IPSet(['0.0.0.1/32', '10.0.0.64/32', '10.0.0.66/32', '255.255.255.1/32'])
+>>> s5 - s3
+IPSet([])
+
+
+^^^^^^^^^^^^^^^^^^^^^^^^
+set symmetric difference
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+>>> s2 ^ s1
+IPSet(['192.0.2.0/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.4/128'])
+
+>>> IPSet([]) ^ IPSet([])
+IPSet([])
+>>> IPSet(['0.0.0.1/32']) ^ IPSet([])
+IPSet(['0.0.0.1/32'])
+>>> IPSet(['0.0.0.1/32']) ^ IPSet(['0.0.0.1/32'])
+IPSet([])
+
+>>> s3 ^ s4
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+>>> s4 ^ s3
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+>>> s3 ^ s4b
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '111.111.111.111/32', '255.255.255.1/32'])
+
+>>> s3 ^ s5
+IPSet(['0.0.0.1/32', '10.0.0.64/32', '10.0.0.66/32', '255.255.255.1/32'])
+>>> s5 ^ s3
+IPSet(['0.0.0.1/32', '10.0.0.64/32', '10.0.0.66/32', '255.255.255.1/32'])
+
+--------------------------------
+Convert an IP set to an IP Range
+--------------------------------
+>>> list(IPSet().iter_ipranges())
+[]
+
+>>> list(IPSet([IPAddress('10.0.0.1')]).iter_ipranges())
+[IPRange('10.0.0.1', '10.0.0.1')]
+
+Adjacent, non-mergable CIDRs must be merged by iter_ipranges().
+>>> list(IPSet([IPAddress('10.0.0.1'), IPAddress('10.0.0.2')]).iter_ipranges())
+[IPRange('10.0.0.1', '10.0.0.2')]
+
+IPv4 and IPv6 addresses must not be merged.
+>>> list(IPSet([IPAddress(1, 4), IPAddress(1, 6)]).iter_ipranges())
+[IPRange('0.0.0.1', '0.0.0.1'), IPRange('::1', '::1')]
+
+len() fails when the IPSet is longer than sys.maxint, which is quite likely with IPv6.
+>>> from netaddr.compat import _sys_maxint
+>>> s = IPSet(IPRange(IPAddress("::0"), IPAddress(_sys_maxint, 6)))
+>>> len(s)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  ...
+IndexError: range contains more than ...
+
+>>> s = IPSet(IPRange(IPAddress("::0"), IPAddress(_sys_maxint - 1, 6)))
+>>> len(s) == _sys_maxint
+True
+
+------------------
+Various exceptions
+------------------
+
+>>> s1 = IPSet(['10.0.0.1'])
+
+>>> hash(s1)
+Traceback (most recent call last):
+TypeError: IP sets are unhashable!
+
+>>> s1.update(42)
+Traceback (most recent call last):
+TypeError: an iterable was expected!
+
+In the following cases, the exceptions are caught and translated to booleans.
+>>> s1 == 42
+False
+>>> s1 != 42
+True
+

netaddr/tests/2.x/ip/socket_fallback.txt

@@ -0,0 +1,88 @@
+=Socket Fallback Module Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.fbsocket import *
+
+}}}
+
+IPv6 '::' compression algorithm tests.
+
+{{{
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:0:0:0:0:0'))
+'::'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:0:0:0:0:A'))
+'::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:0:0:0:0:0'))
+'a::'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:A:0:0:0:0:0'))
+'a:0:a::'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:0:0:0:0:A'))
+'a::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:A:0:0:0:0:0:A'))
+'0:a::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:A:0:0:0:0:A'))
+'a:0:a::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:A:0:0:0:A'))
+'::a:0:0:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:0:A:0:0:A'))
+'::a:0:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:0:0:A:0:A'))
+'a::a:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:A:0:0:A:0'))
+'a::a:0:0:a:0'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:A:0:A:0:A:0'))
+'a:0:a:0:a:0:a:0'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:A:0:A:0:A:0:A'))
+'0:a:0:a:0:a:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '1080:0:0:0:8:800:200C:417A'))
+'1080::8:800:200c:417a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'FEDC:BA98:7654:3210:FEDC:BA98:7654:3210'))
+'fedc:ba98:7654:3210:fedc:ba98:7654:3210'
+
+}}}
+
+IPv4 failure tests
+
+{{{
+
+>>> inet_ntoa(1)
+Traceback (most recent call last):
+...
+TypeError: string type expected, not <type 'int'>
+
+
+>>> inet_ntoa('\x00')
+Traceback (most recent call last):
+...
+ValueError: invalid length of packed IP address string
+
+}}}
+
+IPv6 failure tests.
+
+{{{
+
+>>> inet_pton(AF_INET6, '::0x07f')
+Traceback (most recent call last):
+...
+ValueError: illegal IP address string '::0x07f'
+
+}}}

netaddr/tests/2.x/ip/subnet.txt

@@ -0,0 +1,108 @@
+=IP Subnet Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Incrementing IP objects.
+
+{{{
+
+>>> ip = IPNetwork('192.0.2.0/28')
+>>> for i in range(16):
+...     str(ip)
+...     ip += 1
+'192.0.2.0/28'
+'192.0.2.16/28'
+'192.0.2.32/28'
+'192.0.2.48/28'
+'192.0.2.64/28'
+'192.0.2.80/28'
+'192.0.2.96/28'
+'192.0.2.112/28'
+'192.0.2.128/28'
+'192.0.2.144/28'
+'192.0.2.160/28'
+'192.0.2.176/28'
+'192.0.2.192/28'
+'192.0.2.208/28'
+'192.0.2.224/28'
+'192.0.2.240/28'
+
+>>> ip = IPNetwork('2001:470:1f04::/48')
+>>> for i in ip.subnet(128):
+...     print i
+...     break
+2001:470:1f04::/128
+
+}}}
+
+IP address and subnet sortability.
+
+{{{
+
+>>> ip_list = []
+
+>>> for subnet in IPNetwork('192.0.2.0/24').subnet(28, 3):
+...     ip_list.append(subnet)
+...     ip_list.extend([ip for ip in subnet])
+
+>>> for addr in sorted(ip_list):
+...     print '%r' % addr
+IPNetwork('192.0.2.0/28')
+IPAddress('192.0.2.0')
+IPAddress('192.0.2.1')
+IPAddress('192.0.2.2')
+IPAddress('192.0.2.3')
+IPAddress('192.0.2.4')
+IPAddress('192.0.2.5')
+IPAddress('192.0.2.6')
+IPAddress('192.0.2.7')
+IPAddress('192.0.2.8')
+IPAddress('192.0.2.9')
+IPAddress('192.0.2.10')
+IPAddress('192.0.2.11')
+IPAddress('192.0.2.12')
+IPAddress('192.0.2.13')
+IPAddress('192.0.2.14')
+IPAddress('192.0.2.15')
+IPNetwork('192.0.2.16/28')
+IPAddress('192.0.2.16')
+IPAddress('192.0.2.17')
+IPAddress('192.0.2.18')
+IPAddress('192.0.2.19')
+IPAddress('192.0.2.20')
+IPAddress('192.0.2.21')
+IPAddress('192.0.2.22')
+IPAddress('192.0.2.23')
+IPAddress('192.0.2.24')
+IPAddress('192.0.2.25')
+IPAddress('192.0.2.26')
+IPAddress('192.0.2.27')
+IPAddress('192.0.2.28')
+IPAddress('192.0.2.29')
+IPAddress('192.0.2.30')
+IPAddress('192.0.2.31')
+IPNetwork('192.0.2.32/28')
+IPAddress('192.0.2.32')
+IPAddress('192.0.2.33')
+IPAddress('192.0.2.34')
+IPAddress('192.0.2.35')
+IPAddress('192.0.2.36')
+IPAddress('192.0.2.37')
+IPAddress('192.0.2.38')
+IPAddress('192.0.2.39')
+IPAddress('192.0.2.40')
+IPAddress('192.0.2.41')
+IPAddress('192.0.2.42')
+IPAddress('192.0.2.43')
+IPAddress('192.0.2.44')
+IPAddress('192.0.2.45')
+IPAddress('192.0.2.46')
+IPAddress('192.0.2.47')
+
+}}}

netaddr/tests/2.x/ip/tutorial.txt

@@ -0,0 +1,743 @@
+First of all you need to pull the various netaddr classes and functions into your namespace.
+
+.. note:: Do this for the purpose of this tutorial only. In your own code, you should be explicit about the classes, functions and constants you import to avoid name clashes.
+
+>>> from netaddr import *
+
+We also import the standard library module `pprint` to help format our output.
+
+>>> import pprint
+
+----------------
+Basic operations
+----------------
+
+The following `IPAddress` object represents a single IP address.
+
+>>> ip = IPAddress('192.0.2.1')
+>>> ip.version
+4
+
+The `repr()` call returns a Python statement that can be used to reconstruct an equivalent IP address object state from scratch when run in the Python interpreter.
+
+>>> repr(ip)
+"IPAddress('192.0.2.1')"
+>>> ip
+IPAddress('192.0.2.1')
+
+Access in the string context returns the IP object as a string value.
+
+>>> str(ip)
+'192.0.2.1'
+>>> '%s' % ip
+'192.0.2.1'
+>>> ip.format()  # only really useful for IPv6 addresses.
+'192.0.2.1'
+
+------------------------
+Numerical representation
+------------------------
+
+You can view an IP address in various other formats.
+
+>>> int(ip) == 3221225985
+True
+>>> hex(ip)
+'0xc0000201'
+>>> ip.bin
+'0b11000000000000000000001000000001'
+>>> ip.bits()
+'11000000.00000000.00000010.00000001'
+>>> ip.words == (192, 0, 2, 1)
+True
+
+---------------------------------
+Representing networks and subnets
+---------------------------------
+
+`IPNetwork` objects are used to represent subnets, networks or VLANs that accept CIDR prefixes and netmasks.
+
+>>> ip = IPNetwork('192.0.2.1')
+>>> ip.ip
+IPAddress('192.0.2.1')
+>>> ip.network, ip.broadcast
+(IPAddress('192.0.2.1'), IPAddress('192.0.2.1'))
+>>> ip.netmask, ip.hostmask
+(IPAddress('255.255.255.255'), IPAddress('0.0.0.0'))
+>>> ip.size
+1
+
+In this case, the network and broadcast address are the same, akin to a host route.
+
+>>> ip = IPNetwork('192.0.2.0/24')
+>>> ip.ip
+IPAddress('192.0.2.0')
+>>> ip.network, ip.broadcast
+(IPAddress('192.0.2.0'), IPAddress('192.0.2.255'))
+>>> ip.netmask, ip.hostmask
+(IPAddress('255.255.255.0'), IPAddress('0.0.0.255'))
+>>> ip.size
+256
+
+And finally, this IPNetwork object represents an IP address that belongs to a given IP subnet.
+
+>>> ip = IPNetwork('192.0.3.112/22')
+>>> ip.ip
+IPAddress('192.0.3.112')
+>>> ip.network, ip.broadcast
+(IPAddress('192.0.0.0'), IPAddress('192.0.3.255'))
+>>> ip.netmask, ip.hostmask
+(IPAddress('255.255.252.0'), IPAddress('0.0.3.255'))
+>>> ip.size
+1024
+
+Internally, each IPNetwork object only stores 3 values :-
+
+  * the IP address value as an unsigned integer
+  * a reference to the IP protocol module for the IP version being represented
+  * the CIDR prefix bitmask
+  
+All the other values are calculated on-the-fly on access.
+
+It is possible to adjust the IP address value and the CIDR prefix after object instantiation.
+
+>>> ip = IPNetwork('0.0.0.0/0')
+>>> ip
+IPNetwork('0.0.0.0/0')
+>>> ip.value = 3221225985
+>>> ip
+IPNetwork('192.0.2.1/0')
+>>> ip.prefixlen
+0
+>>> ip.prefixlen = 23
+>>> ip
+IPNetwork('192.0.2.1/23')
+
+There is also a property that lets you access the *true* CIDR address which removes all host bits from the network address based on the CIDR subnet prefix.
+
+>>> ip.cidr
+IPNetwork('192.0.2.0/23')
+
+This is handy for specifying some networking configurations correctly.
+
+If you want to access information about each of the various IP addresses that form the IP subnet, this is available by performing pass through calls to sub methods of each `IPAddress` object.
+
+For example if you want to see a binary digit representation of each address you can do the following.
+
+>>> ip.ip.bits()
+'11000000.00000000.00000010.00000001'
+>>> ip.network.bits()
+'11000000.00000000.00000010.00000000'
+>>> ip.netmask.bits()
+'11111111.11111111.11111110.00000000'
+>>> ip.broadcast.bits()
+'11000000.00000000.00000011.11111111'
+
+------------
+IPv6 support
+------------
+
+Full support for IPv6 is provided. Let's try a few examples:
+
+>>> ip = IPAddress(0, 6)
+>>> ip
+IPAddress('::')
+>>> ip = IPNetwork('fe80::dead:beef/64')
+>>> str(ip), ip.prefixlen, ip.version
+('fe80::dead:beef/64', 64, 6)
+>>> int(ip.ip) == 338288524927261089654018896845083623151
+True
+>>> hex(ip.ip)
+'0xfe8000000000000000000000deadbeef'
+
+Bit-style output isn't as quite as friendly as hexadecimal for such a long numbers, but here the proof that it works!
+
+>>> ip.ip.bits()
+'1111111010000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:1101111010101101:1011111011101111'
+
+Here are some networking details for an IPv6 subnet.
+
+>>> ip.network, ip.broadcast, ip.netmask, ip.hostmask
+(IPAddress('fe80::'), IPAddress('fe80::ffff:ffff:ffff:ffff'), IPAddress('ffff:ffff:ffff:ffff::'), IPAddress('::ffff:ffff:ffff:ffff'))
+
+--------------------------------------
+Interoperability between IPv4 and IPv6 
+--------------------------------------
+
+It is likely that with IPv6 becoming more prevalent, you'll want to be able to interoperate between IPv4 and IPv6 address seemlessly.
+
+Here are a couple of methods that help achieve this.
+
+^^^^^^^^^^^^^^^^^^^^^^^
+IPv4 to IPv6 conversion
+^^^^^^^^^^^^^^^^^^^^^^^
+
+>>> IPAddress('192.0.2.15').ipv4()
+IPAddress('192.0.2.15')
+>>> ip = IPAddress('192.0.2.15').ipv6()
+>>> ip
+IPAddress('::ffff:192.0.2.15')
+>>> ip.is_ipv4_mapped()
+True
+>>> ip.is_ipv4_compat()
+False
+
+>>> IPAddress('192.0.2.15').ipv6(ipv4_compatible=True)
+IPAddress('::192.0.2.15')
+>>> IPAddress('192.0.2.15').ipv6(ipv4_compatible=True).is_ipv4_compat()
+True
+>>> IPAddress('192.0.2.15').ipv6(True)
+IPAddress('::192.0.2.15')
+>>> ip = IPNetwork('192.0.2.1/23')
+>>> ip.ipv4()
+IPNetwork('192.0.2.1/23')
+>>> ip.ipv6()
+IPNetwork('::ffff:192.0.2.1/119')
+>>> ip.ipv6(ipv4_compatible=True)
+IPNetwork('::192.0.2.1/119')
+
+^^^^^^^^^^^^^^^^^^^^^^^
+IPv6 to IPv4 conversion
+^^^^^^^^^^^^^^^^^^^^^^^
+
+>>> IPNetwork('::ffff:192.0.2.1/119').ipv6()
+IPNetwork('::ffff:192.0.2.1/119')
+>>> IPNetwork('::ffff:192.0.2.1/119').ipv6(ipv4_compatible=True)
+IPNetwork('::192.0.2.1/119')
+>>> IPNetwork('::ffff:192.0.2.1/119').ipv4()
+IPNetwork('192.0.2.1/23')
+>>> IPNetwork('::192.0.2.1/119').ipv4()
+IPNetwork('192.0.2.1/23')
+
+Note that the IP object returns IPv4 "mapped" addresses by default in preference to IPv4 "compatible" ones. This has been chosen purposefully as the latter form has been deprecated (see RFC 4291 for details).
+
+---------------
+List operations
+---------------
+
+If you treat an `IPNetwork` object as if it were a standard Python list object it will give you access to a list of individual IP address objects. This of course is illusory and they are not created until you access them.
+
+>>> ip = IPNetwork('192.0.2.16/29')
+
+Accessing an IP object using the `list()` context invokes the default generator which returns a list of all IP objects in the range specified by the IP object's subnet.
+
+>>> ip_list = list(ip)
+>>> len(ip_list)
+8
+>>> ip_list
+[IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), ..., IPAddress('192.0.2.22'), IPAddress('192.0.2.23')]
+
+The length of that list is 8 individual IP addresses.
+
+>>> len(ip)
+8
+
+^^^^^^^^
+Indexing
+^^^^^^^^
+
+You can use standard index access to IP addresses in the subnet.
+
+>>> ip[0]
+IPAddress('192.0.2.16')
+>>> ip[1]
+IPAddress('192.0.2.17')
+>>> ip[-1]
+IPAddress('192.0.2.23')
+
+^^^^^^^
+Slicing
+^^^^^^^
+
+You can also use list slices on IP addresses in the subnet.
+
+>>> ip[0:4]
+<generator object ...>
+
+The slice is a generator function. This was done to save time and system resources as some slices can end up being very large for certain subnets! 
+
+Here is how you'd access all elements in a slice.
+
+>>> list(ip[0:4])
+[IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), IPAddress('192.0.2.18'), IPAddress('192.0.2.19')]
+
+Extended slicing is also supported.
+
+>>> list(ip[0::2])
+[IPAddress('192.0.2.16'), IPAddress('192.0.2.18'), IPAddress('192.0.2.20'), IPAddress('192.0.2.22')]
+
+List reversal.
+
+>>> list(ip[-1::-1])
+[IPAddress('192.0.2.23'), IPAddress('192.0.2.22'), ..., IPAddress('192.0.2.17'), IPAddress('192.0.2.16')]
+
+Use of generators ensures working with large IP subnets is efficient.
+
+>>> for ip in IPNetwork('192.0.2.0/23'):
+...    print '%s' % ip
+...
+192.0.2.0
+192.0.2.1
+192.0.2.2
+192.0.2.3
+...
+192.0.3.252
+192.0.3.253
+192.0.3.254
+192.0.3.255
+
+In IPv4 networks you only usually assign the addresses between the network and broadcast addresses to actual host interfaces on systems.
+
+Here is the iterator provided for accessing these IP addresses :-
+
+>>> for ip in IPNetwork('192.0.2.0/23').iter_hosts():
+...     print '%s' % ip
+...
+192.0.2.1
+192.0.2.2
+192.0.2.3
+192.0.2.4
+...
+192.0.3.251
+192.0.3.252
+192.0.3.253
+192.0.3.254
+
+---------------------------------
+Sorting IP addresses and networks
+---------------------------------
+
+It is fairly common and useful to be able to sort IP addresses and networks canonically.
+
+Here is how sorting works with individual addresses.
+
+>>> import random
+>>> ip_list = list(IPNetwork('192.0.2.128/28'))
+>>> random.shuffle(ip_list)
+>>> sorted(ip_list)
+[IPAddress('192.0.2.128'), IPAddress('192.0.2.129'), ..., IPAddress('192.0.2.142'), IPAddress('192.0.2.143')]
+
+For convenience, you are able to sort IP subnets at the same time as addresses and they can be combinations of IPv4 and IPv6 addresses at the same time as well (IPv4 addresses and network appear before IPv6 ones).
+
+>>> ip_list = [
+... IPAddress('192.0.2.130'),
+... IPAddress('10.0.0.1'),
+... IPNetwork('192.0.2.128/28'),
+... IPNetwork('192.0.3.0/24'),
+... IPNetwork('192.0.2.0/24'),
+... IPNetwork('fe80::/64'),
+... IPAddress('::'),
+... IPNetwork('172.24/12')]
+>>> random.shuffle(ip_list)
+>>> ip_list.sort()
+>>> pprint.pprint(ip_list)
+[IPAddress('10.0.0.1'),
+ IPNetwork('172.24.0.0/12'),
+ IPNetwork('192.0.2.0/24'),
+ IPNetwork('192.0.2.128/28'),
+ IPAddress('192.0.2.130'),
+ IPNetwork('192.0.3.0/24'),
+ IPAddress('::'),
+ IPNetwork('fe80::/64')]
+
+Notice how overlapping subnets also sort in order from largest to smallest.
+
+-----------------------------------------
+Summarizing list of addresses and subnets
+-----------------------------------------
+
+Another useful operation is the ability to summarize groups of IP subnets and addresses, merging them together where possible to create the smallest possible list of CIDR subnets.
+
+You do this in netaddr using the `cidr_merge()` function.
+
+First we create a list of IP objects that contains a good mix of individual addresses and subnets, along with some string based IP address values for good measure. To make things more interesting some IPv6 addresses are thrown in as well.
+
+>>> ip_list = [ip for ip in IPNetwork('fe80::/120')]
+>>> ip_list.append(IPNetwork('192.0.2.0/24'))
+>>> ip_list.extend([str(ip) for ip in IPNetwork('192.0.3.0/24')])
+>>> ip_list.append(IPNetwork('192.0.4.0/25'))
+>>> ip_list.append(IPNetwork('192.0.4.128/25'))
+>>> len(ip_list)
+515
+>>> cidr_merge(ip_list)
+[IPNetwork('192.0.2.0/23'), IPNetwork('192.0.4.0/24'), IPNetwork('fe80::/120')]
+
+Useful isn't it?
+
+---------------------
+Supernets and subnets
+---------------------
+
+It is quite common to have a large CIDR subnet that you may want to split up into multiple smaller component blocks to better manage your network allocations, firewall rules etcc and netaddr gives you the tools required to do this.
+
+Here we take a large /16 private class B network block and split it up into a set of smaller 512 sized blocks.
+
+>>> ip = IPNetwork('172.24.0.0/16')
+>>> ip.subnet(23)
+<generator object ...>
+
+Once again, this method produces and iterator because of the possibility for a large number of return values depending on this subnet size specified.
+
+>>> subnets = list(ip.subnet(23))
+>>> len(subnets)
+128
+>>> subnets
+[IPNetwork('172.24.0.0/23'), IPNetwork('172.24.2.0/23'), IPNetwork('172.24.4.0/23'), ..., IPNetwork('172.24.250.0/23'), IPNetwork('172.24.252.0/23'), IPNetwork('172.24.254.0/23')]
+
+It is also possible to retrieve the list of supernets that a given IP address or subnet belongs to. You can also specify an optional limit.
+ 
+>>> ip = IPNetwork('192.0.2.114')
+>>> supernets = ip.supernet(22)
+>>> pprint.pprint(supernets)
+[IPNetwork('192.0.0.0/22'),
+ IPNetwork('192.0.2.0/23'),
+ IPNetwork('192.0.2.0/24'),
+ IPNetwork('192.0.2.0/25'),
+ IPNetwork('192.0.2.64/26'),
+ IPNetwork('192.0.2.96/27'),
+ IPNetwork('192.0.2.112/28'),
+ IPNetwork('192.0.2.112/29'),
+ IPNetwork('192.0.2.112/30'),
+ IPNetwork('192.0.2.114/31')]
+
+Here, we return a list rather than a generator because the potential list of values is of a predictable size (no more than 31 subnets for an IPv4 address and 127 for IPv6).
+
+---------------------------------------
+Support for non-standard address ranges
+---------------------------------------
+
+While CIDR is a useful way to describe networks succinctly, it is often necessary (particularly with IPv4 which predates the CIDR specification) to be able to generate lists of IP addresses that have an arbitrary start and end address that do not fall on strict bit mask boundaries.
+
+The `iter_iprange()` function allow you to do just this.
+
+>>> ip_list = list(iter_iprange('192.0.2.1', '192.0.2.14'))
+>>> len(ip_list)
+14
+>>> ip_list
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), ..., IPAddress('192.0.2.13'), IPAddress('192.0.2.14')]
+
+It is equally nice to know what the actual list of CIDR subnets is that would correctly cover this non-aligned range of addresses.
+
+Here `cidr_merge()` comes to the rescue once more.
+
+>>> cidr_merge(ip_list)
+[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/30'), IPNetwork('192.0.2.12/31'), IPNetwork('192.0.2.14/32')]
+
+--------------------------------------------
+Dealing with older IP network specifications
+--------------------------------------------
+
+Until the advent of the CIDR specification it was common to infer the netmask of an IPv4 address based on its first octet using an set of classful rules (first defined in RFC 791).
+
+You frequently come across reference to them in various RFCs and they are well supported by a number of software libraries. For completeness, rather than leave out this important (but now somewhat historical) set of rules, they are supported via the cryptically named `cidr_abbrev_to_verbose()` function.
+
+Here is an example of these rules for the whole of the IPv4 address space.
+
+>>> cidrs = [cidr_abbrev_to_verbose(octet) for octet in range(0, 256)]
+>>> pprint.pprint(cidrs)
+['0.0.0.0/8',
+...
+ '127.0.0.0/8',
+ '128.0.0.0/16',
+...
+ '191.0.0.0/16',
+ '192.0.0.0/24',
+...
+ '223.0.0.0/24',
+ '224.0.0.0/4',
+...
+ '239.0.0.0/4',
+ '240.0.0.0/32',
+...
+ '255.0.0.0/32']
+>>> len(cidrs)
+256
+
+-------------------------
+IP address categorisation
+-------------------------
+
+IP addresses fall into several categories, not all of which are suitable for assignment as host addresses.
+
+^^^^^^^
+Unicast
+^^^^^^^
+
+>>> IPAddress('192.0.2.1').is_unicast()
+True
+>>> IPAddress('fe80::1').is_unicast()
+True
+
+^^^^^^^^^
+Multicast
+^^^^^^^^^
+
+Used to indentify multicast groups (see RFC 2365 and 3171 for more info).
+
+>>> IPAddress('239.192.0.1').is_multicast()
+True
+>>> IPAddress('ff00::1').is_multicast()
+True
+
+^^^^^^^
+Private
+^^^^^^^
+
+Found on intranets and used behind NAT routers.
+
+>>> IPAddress('172.24.0.1').is_private()
+True
+>>> IPAddress('10.0.0.1').is_private()
+True
+>>> IPAddress('192.168.0.1').is_private()
+True
+>>> IPAddress('fc00::1').is_private()
+True
+
+^^^^^^^^
+Reserved
+^^^^^^^^
+
+Addresses in reserved ranges are not available for general use.
+
+>>> IPAddress('253.0.0.1').is_reserved()
+True
+
+^^^^^^
+Public
+^^^^^^
+
+Addresses accessible via the Internet.
+
+.. note:: circa the end of 2011 all IPv4 addresses had been allocated to the Regional Internet Registrars. A booming after market in IPv4 addresses has started. There is still plenty of life left in this protocol version yet :)
+
+>>> ip = IPAddress('62.125.24.5')
+>>> ip.is_unicast() and not ip.is_private()
+True
+
+^^^^^^^^
+Netmasks
+^^^^^^^^
+
+A bitmask used to divide an IP address into its network address and host address.
+
+>>> IPAddress('255.255.254.0').is_netmask()
+True
+
+^^^^^^^^^
+Hostmasks
+^^^^^^^^^
+
+Similar to a netmask but with the all the bits flipped the opposite way.
+
+>>> IPAddress('0.0.1.255').is_hostmask()
+True
+
+^^^^^^^^
+Loopback
+^^^^^^^^
+
+These addresses are used internally within an IP network stack and packets sent to these addresses are not distributed via a physical network connection.
+
+>>> IPAddress('127.0.0.1').is_loopback()
+True
+>>> IPAddress('::1').is_loopback()
+True
+
+----------------------
+Comparing IP addresses
+----------------------
+
+`IPAddress` objects can be compared with each other. As an `IPAddress` object can represent both an individual IP address and an implicit network, it pays to get both sides of your comparison into the same terms before you compare them to avoid odd results.
+
+Here are some comparisons of individual IP address to get the ball rolling.
+
+>>> IPAddress('192.0.2.1') == IPAddress('192.0.2.1')
+True
+>>> IPAddress('192.0.2.1') < IPAddress('192.0.2.2')
+True
+>>> IPAddress('192.0.2.2') > IPAddress('192.0.2.1')
+True
+>>> IPAddress('192.0.2.1') != IPAddress('192.0.2.1')
+False
+>>> IPAddress('192.0.2.1') >= IPAddress('192.0.2.1')
+True
+>>> IPAddress('192.0.2.2') >= IPAddress('192.0.2.1')
+True
+>>> IPAddress('192.0.2.1') <= IPAddress('192.0.2.1')
+True
+>>> IPAddress('192.0.2.1') <= IPAddress('192.0.2.2')
+True
+
+Now, lets try something a little more interesting.
+
+>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.2.112/24')
+True
+
+Hmmmmmmmm... looks a bit odd doesn't it? That's because by default, IP objects compare their subnets (or lower and upper boundaries) rather than their individual IP address values.
+
+The solution to this situation is very simple. Knowing this default behaviour, just be explicit about exactly which portion of each IP object you'd like to compare using pass-through properties.
+
+>>> IPNetwork('192.0.2.0/24').ip == IPNetwork('192.0.2.112/24').ip
+False
+>>> IPNetwork('192.0.2.0/24').ip < IPNetwork('192.0.2.112/24').ip
+True
+
+That's more like it. You can also be explicit about comparing networks in this way if you so wish (although it is not strictly necessary).
+
+>>> IPNetwork('192.0.2.0/24').cidr == IPNetwork('192.0.2.112/24').cidr
+True
+
+Armed with this information here are some examples of network comparisons.
+
+>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.3.0/24')
+False
+>>> IPNetwork('192.0.2.0/24') < IPNetwork('192.0.3.0/24')
+True
+>>> IPNetwork('192.0.2.0/24') < IPNetwork('192.0.3.0/24')
+True
+
+This will inevitably raise questions about comparing IPAddress (scalar) objects and IPNetwork (vector) objects with each other (or at least it should).
+
+Here is how netaddr chooses to address this situation.
+
+>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')
+False
+>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32')
+True
+
+An IP network or subnet is different from an individual IP address and therefore cannot be (directly) compared.
+
+If you want to compare them successfully, you must be explicit about which aspect of the IP network you wish to match against the IP address in question.
+
+You can use the index of the first or last address if it is a /32 like so :-
+
+>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')[0]
+True
+>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')[-1]
+True
+>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32')[0]
+False
+
+You can also use the base address if this is what you wish to compare :-
+
+>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32').ip
+True
+>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32').ip
+False
+
+While this may seem a bit pointless at first, netaddr strives to keep IP addresses and network separate from one another while still allowing reasonable interoperability.
+
+-----------
+DNS support
+-----------
+
+It is a common administrative task to generate reverse IP lookups for DNS. This is particularly arduous for IPv6 addresses.
+
+Here is how you do this using an IPAddress object's `reverse_dns()` method.
+
+>>> IPAddress('172.24.0.13').reverse_dns
+'13.0.24.172.in-addr.arpa.'
+>>> IPAddress('fe80::feeb:daed').reverse_dns
+'d.e.a.d.b.e.e.f.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa.'
+
+Note that ``ip6.int`` is not used as this has been deprecated (see RFC 3152 for details).
+
+---------------------------
+Non standard address ranges
+---------------------------
+
+As CIDR is a relative newcomer given the long history of IP version 4 you are quite likely to come across systems and documentation which make reference to IP address ranges in formats other than CIDR. Converting from these arbitrary range types to CIDR and back again isn't a particularly fun task. Fortunately, netaddr tries to make this job easy for you with two purpose built classes.
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Arbitrary IP address ranges
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can represent an arbitrary IP address range using a lower and upper bound address in the form of an IPRange object.
+
+>>> r1 = IPRange('192.0.2.1', '192.0.2.15')
+>>> r1
+IPRange('192.0.2.1', '192.0.2.15')
+
+You can iterate across and index these ranges just like and IPNetwork object.
+
+Importantly, you can also convert it to it's CIDR equivalent.
+
+>>> r1.cidrs()
+[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/29')]
+
+Here is how individual IPRange and IPNetwork compare.
+
+>>> IPRange('192.0.2.0', '192.0.2.255') != IPNetwork('192.0.2.0/24')
+False
+>>> IPRange('192.0.2.0', '192.0.2.255') == IPNetwork('192.0.2.0/24')
+True
+
+You may wish to compare an IP range against a list of IPAddress and IPNetwork
+objects.
+
+>>> r1 = IPRange('192.0.2.1', '192.0.2.15')
+>>> addrs = list(r1)
+>>> addrs 
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3'), IPAddress('192.0.2.4'), IPAddress('192.0.2.5'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), IPAddress('192.0.2.8'), IPAddress('192.0.2.9'), IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPAddress('192.0.2.12'), IPAddress('192.0.2.13'), IPAddress('192.0.2.14'), IPAddress('192.0.2.15')]
+>>> r1 == addrs  
+False
+
+Oops! Not quite what we were looking for or expecting.
+
+The way to do this is to get either side of the comparison operation into the same terms.
+
+>>> list(r1) == addrs
+True
+
+That's more like it.
+
+The same goes for IPNetwork objects.
+
+>>> subnets = r1.cidrs()
+>>> subnets
+[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/29')]
+>>> r1 == subnets
+False
+>>> r1.cidrs() == subnets
+True
+
+The above works if the list you are comparing contains one type or the other, but what if you have a mixed list of `IPAddress`, `IPNetwork` and string addresses?
+
+Time for some slightly more powerful operations. Let's make use of a new class for dealing with groups of IP addresses and subnets. The IPSet class.
+
+>>> ips = [IPAddress('192.0.2.1'), '192.0.2.2/31', IPNetwork('192.0.2.4/31'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), '192.0.2.8', '192.0.2.9', IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPNetwork('192.0.2.12/30')]
+>>> s1 = IPSet(r1.cidrs()) 
+>>> s2 = IPSet(ips)
+>>> s2
+IPSet(['192.0.2.1/32', '192.0.2.2/31', '192.0.2.4/30', '192.0.2.8/29'])
+>>> s1 == s2
+True
+
+Let's remove one of the element from one of the IPSet objects and see what happens.
+
+>>> s2.pop()
+IPNetwork('192.0.2.4/30')
+>>> s1 == s2
+False
+
+This is perhaps a somewhat contrived example but it just shows you some of the capabilities on offer.
+
+See the IPSet tutorial :doc:`tutorial_03` for more details on that class.
+
+^^^^^^^^^^^^^^
+IP Glob ranges
+^^^^^^^^^^^^^^
+
+netaddr also supports a user friendly form of specifying IP address ranges using a "glob" style syntax.
+
+.. note:: At present only IPv4 globs are supported.
+
+>>> IPGlob('192.0.2.*') == IPNetwork('192.0.2.0/24')
+True
+
+IPGlob('192.0.2.*') != IPNetwork('192.0.2.0/24')
+False
+
+As `IPGlob` is a subclass of `IPRange`, all of the same operations apply.
+

netaddr/tests/2.x/strategy/eui48.txt

@@ -0,0 +1,96 @@
+=IEEE EUI-48 Strategy Module=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.strategy.eui48 import *
+
+}}}
+
+==Basic Smoke Tests==
+
+{{{
+
+>>> b = '00000000-00001111-00011111-00010010-11100111-00110011'
+>>> i = 64945841971
+>>> t = (0x0, 0x0f, 0x1f, 0x12, 0xe7, 0x33)
+>>> s = '00-0F-1F-12-E7-33'
+>>> p = '\x00\x0f\x1f\x12\xe73'
+
+>>> bits_to_int(b) == 64945841971
+True
+
+>>> int_to_bits(i) == b
+True
+
+>>> int_to_str(i)
+'00-0F-1F-12-E7-33'
+
+>>> int_to_words(i)
+(0, 15, 31, 18, 231, 51)
+
+>>> int_to_packed(i)
+'\x00\x0f\x1f\x12\xe73'
+
+>>> str_to_int(s) == 64945841971
+True
+
+>>> words_to_int(t) == 64945841971
+True
+
+>>> words_to_int(list(t)) == 64945841971
+True
+
+>>> packed_to_int(p) == 64945841971
+True
+
+}}}
+
+==Smoke Tests With Alternate Dialects==
+
+{{{
+
+>>> b = '00000000:00001111:00011111:00010010:11100111:00110011'
+>>> i = 64945841971
+>>> t = (0x0, 0x0f, 0x1f, 0x12, 0xe7, 0x33)
+>>> s = '0:f:1f:12:e7:33'
+>>> p = '\x00\x0f\x1f\x12\xe73'
+
+>>> bits_to_int(b, mac_unix) == 64945841971
+True
+
+>>> int_to_bits(i, mac_unix) == b
+True
+
+>>> int_to_str(i, mac_unix)
+'0:f:1f:12:e7:33'
+
+>>> int_to_str(i, mac_cisco)
+'000f.1f12.e733'
+
+>>> int_to_str(i, mac_unix)
+'0:f:1f:12:e7:33'
+
+>>> int_to_str(i, mac_unix_expanded)
+'00:0f:1f:12:e7:33'
+
+>>> int_to_words(i, mac_unix)
+(0, 15, 31, 18, 231, 51)
+
+>>> int_to_packed(i)
+'\x00\x0f\x1f\x12\xe73'
+
+>>> str_to_int(s) == 64945841971
+True
+
+>>> words_to_int(t, mac_unix) == 64945841971
+True
+
+>>> words_to_int(list(t), mac_unix) == 64945841971
+True
+
+>>> packed_to_int(p) == 64945841971
+True
+
+}}}

netaddr/tests/2.x/strategy/ipv4.txt

@@ -0,0 +1,130 @@
+=IP version 4 Strategy Module=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+Uses TEST-NET references throughout, as described in RFC 3330.
+
+{{{
+
+>>> from netaddr.strategy.ipv4 import *
+
+}}}
+
+==Basic Smoke Tests==
+
+{{{
+
+>>> b = '11000000.00000000.00000010.00000001'
+>>> i = 3221225985
+>>> t = (192, 0, 2, 1)
+>>> s = '192.0.2.1'
+>>> p = '\xc0\x00\x02\x01'
+>>> bin_val = '0b11000000000000000000001000000001'
+
+>>> bits_to_int(b) == 3221225985
+True
+
+>>> int_to_bits(i)
+'11000000.00000000.00000010.00000001'
+
+>>> int_to_str(i)
+'192.0.2.1'
+
+>>> int_to_words(i) == (192, 0, 2, 1)
+True
+
+>>> int_to_packed(i)
+'\xc0\x00\x02\x01'
+
+>>> int_to_bin(i)
+'0b11000000000000000000001000000001'
+
+>>> int_to_bin(i)
+'0b11000000000000000000001000000001'
+
+>>> bin_to_int(bin_val) == 3221225985
+True
+
+>>> words_to_int(t) == 3221225985
+True
+
+>>> words_to_int(list(t)) == 3221225985
+True
+
+>>> packed_to_int(p) == 3221225985
+True
+
+>>> valid_bin(bin_val)
+True
+
+}}}
+
+== inet_aton() Behavioural Tests ==
+
+inet_aton() is a very old system call and is very permissive with regard to what is assume is a valid IPv4 address. Unfortunately, it is also the most widely used by system software used in software today, so netaddr supports this behaviour by default.
+
+{{{
+
+>>> str_to_int('127') == 127
+True
+
+>>> str_to_int('0x7f') == 127
+True
+
+>>> str_to_int('0177') == 127
+True
+
+>>> str_to_int('127.1') == 2130706433
+True
+
+>>> str_to_int('0x7f.1') == 2130706433
+True
+
+>>> str_to_int('0177.1') == 2130706433
+True
+
+>>> str_to_int('127.0.0.1') == 2130706433
+True
+
+}}}
+
+== inet_pton() Behavioural Tests ==
+
+inet_pton() is a newer system call that supports both IPv4 and IPv6. It is a lot more strict about what it deems to be a valid IPv4 address and doesn't support many of the features found in inet_aton() such as support for non- decimal octets, partial numbers of octets, etc.
+
+{{{
+
+>>> str_to_int('127', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: '127' is not a valid IPv4 address string!
+
+>>> str_to_int('0x7f', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: '0x7f' is not a valid IPv4 address string!
+
+>>> str_to_int('0177', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: '0177' is not a valid IPv4 address string!
+
+>>> str_to_int('127.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: '127.1' is not a valid IPv4 address string!
+
+>>> str_to_int('0x7f.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: '0x7f.1' is not a valid IPv4 address string!
+
+>>> str_to_int('0177.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+AddrFormatError: '0177.1' is not a valid IPv4 address string!
+
+>>> str_to_int('127.0.0.1', flags=INET_PTON) == 2130706433
+True
+
+}}}

netaddr/tests/2.x/strategy/ipv6.txt

@@ -0,0 +1,290 @@
+=IP version 6 Strategy Module=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.strategy.ipv6 import *
+
+}}}
+
+==Basic Smoke Tests==
+
+{{{
+
+>>> b = '0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:1111111111111111:1111111111111110'
+>>> i = 4294967294
+>>> t = (0, 0, 0, 0, 0, 0, 0xffff, 0xfffe)
+>>> s = '::255.255.255.254'
+>>> p = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xfe'
+
+>>> bits_to_int(b) == 4294967294
+True
+
+>>> int_to_bits(i) == b
+True
+
+>>> int_to_str(i)
+'::255.255.255.254'
+
+>>> int_to_words(i)
+(0, 0, 0, 0, 0, 0, 65535, 65534)
+
+>>> int_to_packed(i)
+'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xfe'
+
+>>> str_to_int(s) == 4294967294
+True
+
+>>> words_to_int(t) == 4294967294
+True
+
+>>> words_to_int(list(t)) == 4294967294
+True
+
+>>> packed_to_int(p) == 4294967294
+True
+
+}}}
+
+==More Specific IPv6 Tests==
+
+IPv6 string address variants that are all equivalent.
+
+{{{
+
+>>> i = 42540766411282592856903984951992014763
+>>> str_to_int('2001:0db8:0000:0000:0000:0000:1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8:0000:0000:0000::1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8:0:0:0:0:1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8:0:0::1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8::1428:57ab') == i
+True
+
+>>> str_to_int('2001:0DB8:0000:0000:0000:0000:1428:57AB') == i
+True
+
+>>> str_to_int('2001:DB8::1428:57AB') == i
+True
+
+}}}
+
+Intensive IPv6 string address validation testing.
+
+Positive tests.
+
+{{{
+
+>>> valid_addrs = (
+... #   RFC 4291
+... #   Long forms.
+... 'FEDC:BA98:7654:3210:FEDC:BA98:7654:3210',
+... '1080:0:0:0:8:800:200C:417A',   #   a unicast address
+... 'FF01:0:0:0:0:0:0:43',      	#   a multicast address
+... '0:0:0:0:0:0:0:1',          	#   the loopback address
+... '0:0:0:0:0:0:0:0',          	#   the unspecified addresses
+...
+... #   Short forms.
+... '1080::8:800:200C:417A',    	#   a unicast address
+... 'FF01::43',                 	#   a multicast address
+... '::1',                      	#   the loopback address
+... '::',                       	#   the unspecified addresses
+...
+... #   IPv4 compatible forms.
+... '::192.0.2.1',
+... '::ffff:192.0.2.1',
+... '0:0:0:0:0:0:192.0.2.1',
+... '0:0:0:0:0:FFFF:192.0.2.1',
+... '0:0:0:0:0:0:13.1.68.3',
+... '0:0:0:0:0:FFFF:129.144.52.38',
+... '::13.1.68.3',
+... '::FFFF:129.144.52.38',
+...
+... #   Other tests.
+... '1::',
+... '::ffff',
+... 'ffff::',
+... 'ffff::ffff',
+... '0:1:2:3:4:5:6:7',
+... '8:9:a:b:c:d:e:f',
+... '0:0:0:0:0:0:0:0',
+... 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
+... )
+
+>>> for addr in valid_addrs:
+...    addr, valid_str(addr) 
+('FEDC:BA98:7654:3210:FEDC:BA98:7654:3210', True)
+('1080:0:0:0:8:800:200C:417A', True)
+('FF01:0:0:0:0:0:0:43', True)
+('0:0:0:0:0:0:0:1', True)
+('0:0:0:0:0:0:0:0', True)
+('1080::8:800:200C:417A', True)
+('FF01::43', True)
+('::1', True)
+('::', True)
+('::192.0.2.1', True)
+('::ffff:192.0.2.1', True)
+('0:0:0:0:0:0:192.0.2.1', True)
+('0:0:0:0:0:FFFF:192.0.2.1', True)
+('0:0:0:0:0:0:13.1.68.3', True)
+('0:0:0:0:0:FFFF:129.144.52.38', True)
+('::13.1.68.3', True)
+('::FFFF:129.144.52.38', True)
+('1::', True)
+('::ffff', True)
+('ffff::', True)
+('ffff::ffff', True)
+('0:1:2:3:4:5:6:7', True)
+('8:9:a:b:c:d:e:f', True)
+('0:0:0:0:0:0:0:0', True)
+('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', True)
+
+}}}
+
+Negative tests.
+
+{{{
+
+>>> invalid_addrs = (
+... 'g:h:i:j:k:l:m:n',      #   bad chars.
+... '0:0:0:0:0:0:0:0:0'     #   too long,
+... '',                     #   empty string
+... #   Unexpected types.
+... [],
+... (),
+... {},
+... True,
+... False,
+... )
+
+>>> for addr in invalid_addrs:
+...    addr, valid_str(addr)
+('g:h:i:j:k:l:m:n', False)
+('0:0:0:0:0:0:0:0:0', False)
+([], False)
+((), False)
+({}, False)
+(True, False)
+(False, False)
+
+}}}
+
+String compaction tests.
+
+{{{
+
+>>> valid_addrs = {
+... #   RFC 4291
+... 'FEDC:BA98:7654:3210:FEDC:BA98:7654:3210' : 'fedc:ba98:7654:3210:fedc:ba98:7654:3210',
+... '1080:0:0:0:8:800:200C:417A' : '1080::8:800:200c:417a', #   a unicast address
+... 'FF01:0:0:0:0:0:0:43' : 'ff01::43', #   a multicast address
+... '0:0:0:0:0:0:0:1' : '::1',          #   the loopback address
+... '0:0:0:0:0:0:0:0' : '::',           #   the unspecified addresses
+... }
+
+>>> for long_form, short_form in valid_addrs.items():
+...	    int_val = str_to_int(long_form)
+...	    calc_short_form = int_to_str(int_val)
+...	    calc_short_form == short_form
+True
+True
+True
+True
+True
+
+}}}
+
+IPv6 mapped and compatible IPv4 string formatting.
+
+{{{
+
+>>> int_to_str(0xffffff)
+'::0.255.255.255'
+>>> int_to_str(0xffffffff)
+'::255.255.255.255'
+
+>>> int_to_str(0x1ffffffff)
+'::1:ffff:ffff'
+
+>>> int_to_str(0xffffffffffff)
+'::ffff:255.255.255.255'
+
+>>> int_to_str(0xfffeffffffff)
+'::fffe:ffff:ffff'
+
+>>> int_to_str(0xffffffffffff)
+'::ffff:255.255.255.255'
+
+>>> int_to_str(0xfffffffffff1)
+'::ffff:255.255.255.241'
+
+>>> int_to_str(0xfffffffffffe)
+'::ffff:255.255.255.254'
+
+>>> int_to_str(0xffffffffff00)
+'::ffff:255.255.255.0'
+
+>>> int_to_str(0xffffffff0000)
+'::ffff:255.255.0.0'
+
+>>> int_to_str(0xffffff000000)
+'::ffff:255.0.0.0'
+
+>>> int_to_str(0xffff000000)
+'::ff:ff00:0'
+
+>>> int_to_str(0xffff00000000)
+'::ffff:0.0.0.0'
+
+>>> int_to_str(0x1ffff00000000)
+'::1:ffff:0:0'
+
+>>> int_to_str(0xffff00000000)
+'::ffff:0.0.0.0'
+
+}}}
+
+== str_to_int() Behavioural Tests (legacy_mode switch) ==
+
+The legacy_mode switch on str_to_int() is for interface compatibility only and should not effect the behaviour of this method whether set to True or False.
+
+{{{
+
+>>> str_to_int('::127') == 295
+True
+
+>>> str_to_int('::0x7f')
+Traceback (most recent call last):
+...
+AddrFormatError: '::0x7f' is not a valid IPv6 address string!
+
+>>> str_to_int('::0177') == 375
+True
+
+>>> str_to_int('::127.1')
+Traceback (most recent call last):
+...
+AddrFormatError: '::127.1' is not a valid IPv6 address string!
+
+>>> str_to_int('::0x7f.1')
+Traceback (most recent call last):
+...
+AddrFormatError: '::0x7f.1' is not a valid IPv6 address string!
+
+>>> str_to_int('::0177.1')
+Traceback (most recent call last):
+...
+AddrFormatError: '::0177.1' is not a valid IPv6 address string!
+
+>>> str_to_int('::127.0.0.1') == 2130706433
+True
+
+}}}

netaddr/tests/3.x/core/compat.txt

@@ -0,0 +1,104 @@
+=Python 2.x and 3.x compatibility tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.compat import _sys_maxint, _is_str, _is_int, _callable
+
+>>> from netaddr.compat import _func_doc, _dict_keys, _dict_items
+
+>>> from netaddr.compat import _iter_dict_keys, _bytes_join, _zip, _range
+
+>>> from netaddr.compat import _iter_range, _func_name, _func_doc
+
+#   string and integer detection tests.
+>>> _is_int(_sys_maxint)
+True
+
+>>> _is_str(_sys_maxint)
+False
+
+>>> _is_str('')
+True
+
+>>> _is_str(''.encode())
+True
+
+#   byte string join tests.
+>>> str_8bit = _bytes_join(['a'.encode(), 'b'.encode(), 'c'.encode()])
+
+>>> str_8bit == 'abc'.encode()
+True
+
+>>> "b'abc'" == '%r' % str_8bit
+True
+
+#   dict operation tests.
+>>> d = { 'a' : 0, 'b' : 1, 'c' : 2 }
+
+>>> sorted(_dict_keys(d)) == ['a', 'b', 'c']
+True
+
+>>> sorted(_dict_items(d)) == [('a', 0), ('b', 1), ('c', 2)]
+True
+
+#   zip() BIF tests.
+>>> l2 = _zip([0], [1])
+
+>>> hasattr(_zip(l2), 'pop')
+True
+
+>>> l2 == [(0, 1)]
+True
+
+#   range/xrange() tests.
+>>> l1 = _range(3)
+
+>>> isinstance(l1, list)
+True
+
+>>> hasattr(l1, 'pop')
+True
+
+>>> l1 == [0, 1, 2]
+True
+
+>>> it = _iter_range(3)
+
+>>> isinstance(it, list)
+False
+
+>>> hasattr(it, '__iter__')
+True
+
+>>> it == [0, 1, 2]
+False
+
+>>> list(it) == [0, 1, 2]
+True
+
+#   callable() and function meta-data tests.
+>>> i = 1
+>>> def f1():
+...     """docstring"""
+...     pass
+
+>>> f2 = lambda x: x
+
+>>> _callable(i)
+False
+
+>>> _callable(f1)
+True
+
+>>> _callable(f2)
+True
+
+>>> _func_name(f1) == 'f1'
+True
+
+>>> _func_doc(f1) == 'docstring'
+True
+
+}}}

netaddr/tests/3.x/core/pubsub.txt

@@ -0,0 +1,48 @@
+=Publish / Subscribe DP Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+Basic Publisher and Subscriber object tests.
+
+{{{
+
+>>> from netaddr.core import Publisher, Subscriber, PrettyPrinter
+>>> import pprint
+
+>>> class Subject(Publisher):
+...     pass
+
+
+>>> class Observer(Subscriber):
+...     def __init__(self, id):
+...         self.id = id
+...
+...     def update(self, data):
+...         return repr(self), pprint.pformat(data)
+...
+...     def __repr__(self):
+...         return '%s(%r)' % (self.__class__.__name__, self.id)
+...
+
+>>> s = Subject()
+
+>>> s.attach(Observer('foo'))
+>>> s.attach(Observer('bar'))
+
+#FIXME: >>> pp = PrettyPrinter()
+#FIXME: >>> s.attach(pp)
+
+>>> data = [{'foo': 42}, {'list': [1,'2', list(range(10))]}, {'strings': ['foo', 'bar', 'baz', 'quux']}]
+>>> s.notify(data)
+
+#FIXME: >>> s.detach(pp)
+>>> s.notify(['foo', 'bar', 'baz'])
+
+>>> s.attach('foo')
+Traceback (most recent call last):
+...
+TypeError: 'foo' does not support required interface!
+
+>>> s.detach('foo')
+
+}}}

netaddr/tests/3.x/eui/eui.txt

@@ -0,0 +1,207 @@
+=IEEE EUI-64 Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+IEEE EUI-64 tests.
+
+{{{
+
+>>> eui = EUI('00-1B-77-FF-FE-49-54-FD')
+>>> eui
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> eui.oui
+OUI('00-1B-77')
+
+>>> eui.ei
+'FF-FE-49-54-FD'
+
+>>> eui.eui64()
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> mac = EUI('00-0F-1F-12-E7-33')
+>>> ip = mac.ipv6_link_local()
+>>> ip
+IPAddress('fe80::20f:1fff:fe12:e733')
+>>> ip.is_link_local()
+True
+
+>>> mac.eui64()
+EUI('00-0F-1F-FF-FE-12-E7-33')
+
+}}}
+
+Individual Address Block tests.
+
+{{{
+
+>>> lower_eui = EUI('00-50-C2-05-C0-00')
+>>> upper_eui = EUI('00-50-C2-05-CF-FF')
+
+>>> lower_eui.is_iab()
+True
+
+>>> str(lower_eui.oui)
+'00-50-C2'
+
+>>> str(lower_eui.iab)
+'00-50-C2-05-C0-00'
+
+>>> lower_eui.ei
+'05-C0-00'
+
+>>> int(lower_eui.oui) == 0x0050c2
+True
+
+>>> int(lower_eui.iab) == 0x0050c205c
+True
+
+>>> upper_eui.is_iab()
+True
+
+>>> str(upper_eui.oui)
+'00-50-C2'
+
+>>> str(upper_eui.iab)
+'00-50-C2-05-C0-00'
+
+>>> upper_eui.ei
+'05-CF-FF'
+
+>>> int(upper_eui.oui) == 0x0050c2
+True
+
+>>> int(upper_eui.iab) == 0x0050c205c
+True
+
+}}}
+
+Constructor tests.
+
+{{{
+
+>>> eui = EUI('00-90-96-AF-CC-39')
+
+>>> eui == EUI('0-90-96-AF-CC-39')
+True
+
+>>> eui == EUI('00-90-96-af-cc-39')
+True
+
+>>> eui == EUI('00:90:96:AF:CC:39')
+True
+
+>>> eui == EUI('00:90:96:af:cc:39')
+True
+
+>>> eui == EUI('0090-96AF-CC39')
+True
+
+>>> eui == EUI('0090:96af:cc39')
+True
+
+>>> eui == EUI('009096-AFCC39')
+True
+
+>>> eui == EUI('009096:AFCC39')
+True
+
+>>> eui == EUI('009096AFCC39')
+True
+
+>>> eui == EUI('009096afcc39')
+True
+
+>>> EUI('01-00-00-00-00-00') == EUI('010000000000')
+True
+
+>>> EUI('01-00-00-00-00-00') == EUI('10000000000')
+True
+
+>>> EUI('01-00-00-01-00-00') == EUI('010000:010000')
+True
+
+>>> EUI('01-00-00-01-00-00') == EUI('10000:10000')
+True
+
+}}}
+
+EUI-48 and EUI-64 indentifiers of the same value are *not* equivalent.
+
+{{{
+
+>>> eui48 = EUI('01-00-00-01-00-00')
+>>> int(eui48) == 1099511693312
+True
+
+>>> eui64 = EUI('00-00-01-00-00-01-00-00')
+>>> int(eui64) == 1099511693312
+True
+
+>>> eui48 == eui64
+False
+
+}}}
+ 
+Sortability
+
+{{{
+
+>>> import random
+
+>>> eui_list = [EUI(0, 64), EUI(0), EUI(0xffffffffffff, dialect=mac_unix), EUI(0x1000000000000)]
+
+>>> random.shuffle(eui_list)
+
+>>> eui_list.sort()
+
+>>> for eui in eui_list:
+... 	str(eui), eui.version
+('00-00-00-00-00-00', 48)
+('ff:ff:ff:ff:ff:ff', 48)
+('00-00-00-00-00-00-00-00', 64)
+('00-01-00-00-00-00-00-00', 64)
+
+}}}
+
+Persistence
+
+{{{
+
+>>> import pickle
+
+>>> eui1 = EUI('00-00-00-01-02-03')
+>>> eui2 = pickle.loads(pickle.dumps(eui1))
+>>> eui1 == eui2
+True
+
+>>> eui1 = EUI('00-00-00-01-02-03', dialect=mac_cisco)
+>>> eui2 = pickle.loads(pickle.dumps(eui1))
+>>> eui1 == eui2
+True
+
+>>> eui1.dialect == eui2.dialect
+True
+
+>>> oui1 = EUI('00-00-00-01-02-03').oui
+>>> oui2 = pickle.loads(pickle.dumps(oui1))
+>>> oui1 == oui2
+True
+>>> oui1.records == oui2.records
+True
+
+>>> iab1 = EUI('00-50-C2-00-1F-FF').iab
+>>> iab2 = pickle.loads(pickle.dumps(iab1))
+>>> iab1 == iab2
+True
+>>> iab1.record == iab2.record
+True
+
+}}}
+

netaddr/tests/3.x/eui/eui64.txt

@@ -0,0 +1,67 @@
+=IEEE EUI-64 Identifier Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Basic operations.
+
+{{{
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+>>> mac
+EUI('00-1B-77-49-54-FD')
+
+>>> eui = mac.eui64()
+>>> eui
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> eui.eui64()
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> int(eui) == 7731765737772285
+True
+
+>>> eui.packed
+b'\x00\x1bw\xff\xfeIT\xfd'
+
+>>> eui.bin  
+'0b11011011101111111111111111110010010010101010011111101'
+
+>>> eui.bits()
+'00000000-00011011-01110111-11111111-11111110-01001001-01010100-11111101'
+
+}}}
+
+IPv6 interoperability
+
+{{{
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+
+>>> eui = mac.eui64()
+
+>>> mac
+EUI('00-1B-77-49-54-FD')
+
+>>> eui
+EUI('00-1B-77-FF-FE-49-54-FD')
+
+>>> mac.modified_eui64()
+EUI('02-1B-77-FF-FE-49-54-FD')
+
+>>> mac.ipv6_link_local()
+IPAddress('fe80::21b:77ff:fe49:54fd')
+
+>>> eui.ipv6_link_local()
+IPAddress('fe80::21b:77ff:fe49:54fd')
+
+>>> mac.ipv6(0x12340000000000000000000000000000)
+IPAddress('1234::21b:77ff:fe49:54fd')
+
+>>> eui.ipv6(0x12340000000000000000000000000000)
+IPAddress('1234::21b:77ff:fe49:54fd')

netaddr/tests/3.x/eui/pubsub.txt

@@ -0,0 +1,56 @@
+=IEEE Publish/Subscribe Parser Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+Basic OUIIndexParser and FileIndexer object tests.
+
+{{{ 
+
+>>> from netaddr.eui.ieee import OUIIndexParser, IABIndexParser, FileIndexer
+>>> from io import StringIO
+
+>>> infile = StringIO()
+>>> outfile = StringIO()
+>>> infile.write("""
+... 00-CA-FE   (hex)        ACME CORPORATION
+... 00CAFE     (base 16)        ACME CORPORATION
+... 				1 MAIN STREET
+... 				SPRINGFIELD
+... 				UNITED STATES
+... """)
+211
+>>> infile.seek(0)
+0
+>>> iab_parser = OUIIndexParser(infile)
+>>> iab_parser.attach(FileIndexer(outfile))
+>>> iab_parser.parse()
+>>> print(outfile.getvalue())
+51966,1,210
+<BLANKLINE>
+
+}}}
+
+Basic IABIndexParser and FileIndexer object tests.
+
+{{{ 
+
+>>> infile = StringIO()
+>>> outfile = StringIO()
+>>> infile.write("""
+... 00-50-C2   (hex)        ACME CORPORATION
+... ABC000-ABCFFF     (base 16)        ACME CORPORATION
+...                 1 MAIN STREET
+...                 SPRINGFIELD
+...                 UNITED STATES
+... """)
+182
+>>> infile.seek(0)
+0
+>>> iab_parser = IABIndexParser(infile)
+>>> iab_parser.attach(FileIndexer(outfile))
+>>> iab_parser.parse()
+>>> print(outfile.getvalue())
+84683452,1,181
+<BLANKLINE>
+
+}}}

netaddr/tests/3.x/eui/tutorial.txt

@@ -0,0 +1,258 @@
+=EUI (MAC) Address Tutorial=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+==Basic Operations==
+
+This EUI object represents a MAC address.
+
+{{{
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+
+}}}
+
+Standard repr() access returns a Python statement that can reconstruct the MAC address object from scratch if executed in the Python interpreter.
+
+{{{
+
+>>> mac
+EUI('00-1B-77-49-54-FD')
+
+}}}
+
+Accessing the EUI object in the string context.
+
+{{{
+
+>>> str(mac)
+'00-1B-77-49-54-FD'
+
+>>> '%s' % mac
+'00-1B-77-49-54-FD'
+
+}}}
+
+Here are a few other common properties.
+
+{{{
+
+>>> str(mac), str(mac.oui), mac.ei, mac.version
+('00-1B-77-49-54-FD', '00-1B-77', '49-54-FD', 48)
+
+}}}
+
+==MAC Address Numerical Representations==
+
+You can view an individual IP address in various other formats.
+
+{{{
+
+>>> int(mac) == 117965411581
+True
+
+>>> hex(mac)
+'0x1b774954fd'
+
+>>> oct(mac)
+'0o1556722252375'
+
+>>> mac.bits()
+'00000000-00011011-01110111-01001001-01010100-11111101'
+
+>>> mac.bin
+'0b1101101110111010010010101010011111101'
+
+}}}
+
+==MAC Address Formatting==
+
+It is very common to see MAC address in many different formats other than the standard IEEE EUI-48.
+
+The EUI class constructor handles all these common forms.
+
+{{{
+
+>>> EUI('00-1B-77-49-54-FD')
+EUI('00-1B-77-49-54-FD')
+
+IEEE EUI-48 lowercase format.
+
+>>> EUI('00-1b-77-49-54-fd')
+EUI('00-1B-77-49-54-FD')
+
+Common UNIX format.
+
+>>> EUI('0:1b:77:49:54:fd')
+EUI('00-1B-77-49-54-FD')
+
+Cisco triple hextet format.
+
+>>> EUI('001b:7749:54fd')
+EUI('00-1B-77-49-54-FD')
+
+>>> EUI('1b:7749:54fd')
+EUI('00-1B-77-49-54-FD')
+
+>>> EUI('1B:7749:54FD')
+EUI('00-1B-77-49-54-FD')
+
+Bare MAC addresses (no delimiters).
+
+>>> EUI('001b774954fd')
+EUI('00-1B-77-49-54-FD')
+
+>>> EUI('01B774954FD')
+EUI('00-1B-77-49-54-FD')
+
+PostreSQL format (found in documentation).
+
+>>> EUI('001B77:4954FD')
+EUI('00-1B-77-49-54-FD')
+
+}}}
+
+It is equally possible to specify a selected format for your MAC string output in the form of a 'dialect' class. It's use is similar to the dialect class used in the Python standard library csv module.
+
+{{{
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+
+>>> mac
+EUI('00-1B-77-49-54-FD')
+
+>>> mac.dialect = mac_unix
+>>> mac
+EUI('0:1b:77:49:54:fd')
+
+>>> mac.dialect = mac_unix_expanded
+>>> mac
+EUI('00:1b:77:49:54:fd')
+
+>>> mac.dialect = mac_cisco
+>>> mac
+EUI('001b.7749.54fd')
+
+>>> mac.dialect = mac_bare
+>>> mac
+EUI('001B774954FD')
+
+>>> mac.dialect = mac_pgsql
+>>> mac
+EUI('001b77:4954fd')
+
+}}}
+
+You can of course, create your own dialect classes to customise the MAC formatting if the standard ones do not suit your needs.
+
+Here's a tweaked UNIX MAC dialect that generates uppercase, zero-filled octets.
+
+{{{
+
+>>> class mac_custom(mac_unix): pass
+>>> mac_custom.word_fmt = '%.2X'
+>>> mac = EUI('00-1B-77-49-54-FD', dialect=mac_custom)
+>>> mac
+EUI('00:1B:77:49:54:FD')
+
+}}}
+
+==Looking Up EUI Organisational Data==
+
+EUI objects provide an interface to the OUI (Organisationally Unique Identifier) and IAB (Individual Address Block) registration databases available from the IEEE.
+
+Here is how you query an OUI with the EUI interface.
+
+{{{ 
+
+>>> mac = EUI('00-1B-77-49-54-FD')
+>>> oui = mac.oui
+>>> oui
+OUI('00-1B-77')
+
+>>> oui.registration().address
+['Lot 8, Jalan Hi-Tech 2/3', 'Kulim Hi-Tech Park', 'Kulim Kedah 09000', 'MALAYSIA']
+
+>>> oui.registration().org
+'Intel Corporate'
+
+}}}
+
+You can also use OUI objects directly without going through the EUI interface.
+
+A few OUI records have multiple registrations against them. I'm not sure if this is recording historical information or just a quirk of the IEEE reigstration process.
+
+This example show you how you access them individually by specifying an index number.
+
+{{{
+
+>>> oui = OUI(524336)   #   OUI constructor accepts integer values too.
+
+>>> oui
+OUI('08-00-30')
+
+>>> oui.registration(0).address
+['2380 N. ROSE AVENUE', 'OXNARD CA 93010', 'UNITED STATES']
+
+>>> oui.registration(0).org
+'NETWORK RESEARCH CORPORATION'
+
+>>> oui.registration(0).oui
+'08-00-30'
+
+>>> oui.registration(1).address
+['CH-1211 GENEVE 23', 'SUISSE/SWITZ', 'SWITZERLAND']
+
+>>> oui.registration(1).org
+'CERN'
+
+>>> oui.registration(1).oui
+'08-00-30'
+
+>>> oui.registration(2).address
+['GPO BOX 2476V', 'MELBOURNE VIC 3001', 'AUSTRALIA']
+
+>>> oui.registration(2).org
+'ROYAL MELBOURNE INST OF TECH'
+
+>>> oui.registration(2).oui
+'08-00-30'
+
+>>> for i in range(oui.reg_count):
+...     str(oui), oui.registration(i).org
+...
+('08-00-30', 'NETWORK RESEARCH CORPORATION')
+('08-00-30', 'CERN')
+('08-00-30', 'ROYAL MELBOURNE INST OF TECH')
+
+}}}
+
+Here is how you query an IAB with the EUI interface.
+
+{{{ 
+
+>>> mac = EUI('00-50-C2-00-0F-01')
+
+>>> mac.is_iab()
+True
+
+>>> iab = mac.iab
+
+>>> iab
+IAB('00-50-C2-00-00-00')
+
+>>> iab.registration()
+{'address': ['1241 Superieor Ave E', 'Cleveland OH 44114', 'UNITED STATES'],
+ 'iab': '00-50-C2-00-00-00',
+ ...
+ 'offset': 123,
+ 'org': 'T.L.S. Corp.',
+ 'size': 139}
+
+}}}

netaddr/tests/3.x/ip/abbreviated.txt

@@ -0,0 +1,202 @@
+=Abbreviated CIDR Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Abbreviation tests.
+
+{{{
+
+>>> ranges = (
+... (IPAddress('::'), IPAddress('::')),
+... (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')),
+... (IPAddress('::'), IPAddress('::255.255.255.255')),
+... (IPAddress('0.0.0.0'), IPAddress('0.0.0.0')),
+... )
+
+>>> sorted(ranges)
+[(IPAddress('0.0.0.0'), IPAddress('0.0.0.0')), (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')), (IPAddress('::'), IPAddress('::')), (IPAddress('::'), IPAddress('::255.255.255.255'))]
+
+#   Integer values.
+>>> cidr_abbrev_to_verbose(-1)
+-1
+
+#   Class A
+>>> cidr_abbrev_to_verbose(0)
+'0.0.0.0/8'
+>>> cidr_abbrev_to_verbose(10)
+'10.0.0.0/8'
+>>> cidr_abbrev_to_verbose(127)
+'127.0.0.0/8'
+
+#   Class B
+>>> cidr_abbrev_to_verbose(128)
+'128.0.0.0/16'
+>>> cidr_abbrev_to_verbose(191)
+'191.0.0.0/16'
+
+#   Class C
+>>> cidr_abbrev_to_verbose(192)
+'192.0.0.0/24'
+>>> cidr_abbrev_to_verbose(223)
+'223.0.0.0/24'
+
+#   Class D (multicast)
+>>> cidr_abbrev_to_verbose(224)
+'224.0.0.0/4'
+>>> cidr_abbrev_to_verbose(225)
+'225.0.0.0/4'
+>>> cidr_abbrev_to_verbose(239)
+'239.0.0.0/4'
+
+#   Class E (reserved)
+>>> cidr_abbrev_to_verbose(240)
+'240.0.0.0/32'
+>>> cidr_abbrev_to_verbose(254)
+'254.0.0.0/32'
+>>> cidr_abbrev_to_verbose(255)
+'255.0.0.0/32'
+>>> cidr_abbrev_to_verbose(256)
+256
+
+#   String values.
+>>> cidr_abbrev_to_verbose('-1')
+'-1'
+
+#   Class A
+>>> cidr_abbrev_to_verbose('0')
+'0.0.0.0/8'
+>>> cidr_abbrev_to_verbose('10')
+'10.0.0.0/8'
+>>> cidr_abbrev_to_verbose('127')
+'127.0.0.0/8'
+
+#   Class B
+>>> cidr_abbrev_to_verbose('128')
+'128.0.0.0/16'
+>>> cidr_abbrev_to_verbose('191')
+'191.0.0.0/16'
+
+#   Class C
+>>> cidr_abbrev_to_verbose('192')
+'192.0.0.0/24'
+>>> cidr_abbrev_to_verbose('223')
+'223.0.0.0/24'
+
+#   Class D (multicast)
+>>> cidr_abbrev_to_verbose('224')
+'224.0.0.0/4'
+>>> cidr_abbrev_to_verbose('225')
+'225.0.0.0/4'
+>>> cidr_abbrev_to_verbose('239')
+'239.0.0.0/4'
+
+#   Class E (reserved)
+>>> cidr_abbrev_to_verbose('240')
+'240.0.0.0/32'
+>>> cidr_abbrev_to_verbose('254')
+'254.0.0.0/32'
+>>> cidr_abbrev_to_verbose('255')
+'255.0.0.0/32'
+>>> cidr_abbrev_to_verbose('256')
+'256'
+
+>>> cidr_abbrev_to_verbose('128/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('128.0/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('128.0.0.0/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('128.0.0/8')
+'128.0.0.0/8'
+>>> cidr_abbrev_to_verbose('192.168')
+'192.168.0.0/24'
+>>> cidr_abbrev_to_verbose('192.0.2')
+'192.0.2.0/24'
+>>> cidr_abbrev_to_verbose('192.0.2.0')
+'192.0.2.0/24'
+>>> cidr_abbrev_to_verbose('0.0.0.0')
+'0.0.0.0/8'
+
+#   No IPv6 support current.
+>>> cidr_abbrev_to_verbose('::/128')
+'::/128'
+
+#   IPv6 proper, not IPv4 mapped?
+>>> cidr_abbrev_to_verbose('::10/128')
+'::10/128'
+>>> cidr_abbrev_to_verbose('0.0.0.0.0')
+'0.0.0.0.0'
+>>> cidr_abbrev_to_verbose('')
+''
+>>> cidr_abbrev_to_verbose(None)
+
+>>> cidr_abbrev_to_verbose([])
+[]
+>>> cidr_abbrev_to_verbose({})
+{}
+
+}}}
+
+Negative testing.
+
+{{{
+
+>>> cidr_abbrev_to_verbose('192.0.2.0')
+'192.0.2.0/24'
+
+>>> cidr_abbrev_to_verbose('192.0.2.0/32')
+'192.0.2.0/32'
+
+#FIXME: >>> cidr_abbrev_to_verbose('192.0.2.0/33')
+Traceback (most recent call last):
+...
+ValueError: prefixlen in address '192.0.2.0/33' out of range for IPv4!
+
+}}}
+
+IPv4 octet expansion routine.
+
+{{{
+
+>>> from netaddr.strategy import ipv4
+
+>>> ipv4.expand_partial_address('10')
+'10.0.0.0'
+
+>>> ipv4.expand_partial_address('10.1')
+'10.1.0.0'
+
+>>> ipv4.expand_partial_address('192.168.1')
+'192.168.1.0'
+
+}}}
+
+IPNetwork constructor testing.
+
+{{{
+
+>>> IPNetwork('192.168/16')
+IPNetwork('192.168.0.0/16')
+
+>>> IPNetwork('192.168.0.15')
+IPNetwork('192.168.0.15/32')
+
+>>> IPNetwork('192.168')
+IPNetwork('192.168.0.0/32')
+
+>>> IPNetwork('192.168', implicit_prefix=True)
+IPNetwork('192.168.0.0/24')
+
+>>> IPNetwork('192.168', True)
+IPNetwork('192.168.0.0/24')
+
+>>> IPNetwork('10.0.0.1', True)
+IPNetwork('10.0.0.1/8')
+
+}}}

netaddr/tests/3.x/ip/binops.txt

@@ -0,0 +1,68 @@
+=Binary and numerical operations on IP addresses=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+==Addition and Subtraction ==
+
+{{{
+
+>>> IPAddress('192.0.2.0') + 1
+IPAddress('192.0.2.1')
+
+>>> 1 + IPAddress('192.0.2.0')
+IPAddress('192.0.2.1')
+
+>>> IPAddress('192.0.2.1') - 1
+IPAddress('192.0.2.0')
+
+>>> IPAddress('192.0.0.0') + IPAddress('0.0.0.42')
+IPAddress('192.0.0.42')
+
+>>> IPAddress('192.0.0.42') - IPAddress('0.0.0.42')
+IPAddress('192.0.0.0')
+
+
+>>> 1 - IPAddress('192.0.2.1')
+Traceback (most recent call last):
+...
+IndexError: result outside valid IP address boundary!
+
+>>> ip = IPAddress('10.0.0.1')
+>>> ip += 1
+>>> ip
+IPAddress('10.0.0.2')
+>>> ip -= 1
+>>> ip
+IPAddress('10.0.0.1')
+>>> ip += IPAddress('0.0.0.42')
+>>> ip
+IPAddress('10.0.0.43')
+>>> ip -= IPAddress('0.0.0.43')
+>>> ip
+IPAddress('10.0.0.0')
+
+}}}
+
+==Binary operations==
+
+{{{
+
+>>> IPAddress('192.0.2.15') & IPAddress('255.255.255.0')
+IPAddress('192.0.2.0')
+
+>>> IPAddress('255.255.0.0') | IPAddress('0.0.255.255')
+IPAddress('255.255.255.255')
+
+>>> IPAddress('255.255.0.0') ^ IPAddress('255.0.0.0')
+IPAddress('0.255.0.0')
+
+>>> IPAddress('1.2.3.4').packed
+b'\x01\x02\x03\x04'
+
+}}}

netaddr/tests/3.x/ip/boundaries.txt

@@ -0,0 +1,170 @@
+=IP Range Boundary Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+>>> import pprint
+
+}}}
+
+`iter_iprange()` iterator boundary tests.
+
+{{{
+
+>>> pprint.pprint(list(iter_iprange('192.0.2.0', '192.0.2.7')))
+[IPAddress('192.0.2.0'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6'),
+ IPAddress('192.0.2.7')]
+
+>>> pprint.pprint(list(iter_iprange('::ffff:192.0.2.0', '::ffff:192.0.2.7')))
+[IPAddress('::ffff:192.0.2.0'),
+ IPAddress('::ffff:192.0.2.1'),
+ IPAddress('::ffff:192.0.2.2'),
+ IPAddress('::ffff:192.0.2.3'),
+ IPAddress('::ffff:192.0.2.4'),
+ IPAddress('::ffff:192.0.2.5'),
+ IPAddress('::ffff:192.0.2.6'),
+ IPAddress('::ffff:192.0.2.7')]
+
+
+}}}
+
+`IPNetwork()` iterator boundary tests.
+
+{{{
+
+>>> pprint.pprint(list(IPNetwork('192.0.2.0/29')[0:-1]))
+[IPAddress('192.0.2.0'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6')]
+
+>>> pprint.pprint(list(IPNetwork('192.0.2.0/29')[::-1]))
+[IPAddress('192.0.2.7'),
+ IPAddress('192.0.2.6'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.0')]
+ 
+For IPv4, network (first) and broadcast (last) address must be skipped.
+>>> pprint.pprint(list(IPNetwork('192.0.2.0/29').iter_hosts()))
+[IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6')]
+
+For IPv6, Subnet-Router anycast address (first) must be skipped.
+>>> pprint.pprint(list(IPNetwork('::ffff:192.0.2.0/125').iter_hosts()))
+[IPAddress('::ffff:192.0.2.1'),
+ IPAddress('::ffff:192.0.2.2'),
+ IPAddress('::ffff:192.0.2.3'),
+ IPAddress('::ffff:192.0.2.4'),
+ IPAddress('::ffff:192.0.2.5'),
+ IPAddress('::ffff:192.0.2.6'),
+ IPAddress('::ffff:192.0.2.7')]
+
+Very small IPNetworks do contain some IP addresses
+>>> list(IPNetwork("192.168.0.0/31"))
+[IPAddress('192.168.0.0'), IPAddress('192.168.0.1')]
+>>> list(IPNetwork("1234::/128"))
+[IPAddress('1234::')]
+
+But they have no IPs that can be assigned to hosts.
+>>> list(IPNetwork("1234::/128").iter_hosts())
+[]
+>>> list(IPNetwork("192.168.0.0/31").iter_hosts())
+[]
+
+}}}
+
+`IPRange()` iterator boundary tests.
+
+{{{
+
+>>> pprint.pprint(list(IPRange('192.0.2.0', '192.0.2.7')))
+[IPAddress('192.0.2.0'),
+ IPAddress('192.0.2.1'),
+ IPAddress('192.0.2.2'),
+ IPAddress('192.0.2.3'),
+ IPAddress('192.0.2.4'),
+ IPAddress('192.0.2.5'),
+ IPAddress('192.0.2.6'),
+ IPAddress('192.0.2.7')]
+
+>>> pprint.pprint(list(IPRange('::ffff:192.0.2.0', '::ffff:192.0.2.7')))
+[IPAddress('::ffff:192.0.2.0'),
+ IPAddress('::ffff:192.0.2.1'),
+ IPAddress('::ffff:192.0.2.2'),
+ IPAddress('::ffff:192.0.2.3'),
+ IPAddress('::ffff:192.0.2.4'),
+ IPAddress('::ffff:192.0.2.5'),
+ IPAddress('::ffff:192.0.2.6'),
+ IPAddress('::ffff:192.0.2.7')]
+
+}}}
+
+Boolean contexts.
+
+{{{
+
+>>> bool(IPAddress('0.0.0.0'))
+False
+
+>>> bool(IPAddress('0.0.0.1'))
+True
+
+>>> bool(IPAddress('255.255.255.255'))
+True
+
+>>> bool(IPNetwork('0.0.0.0/0'))
+True
+
+>>> bool(IPNetwork('::/0'))
+True
+
+>>> bool(IPRange('0.0.0.0', '255.255.255.255'))
+True
+
+>>> bool(IPRange('0.0.0.0', '0.0.0.0'))
+True
+
+>>> bool(IPGlob('*.*.*.*'))
+True
+
+>>> bool(IPGlob('0.0.0.0'))
+True
+
+}}}
+
+`IPAddress()` negative increment tests.
+
+{{{
+
+>>> ip = IPAddress('0.0.0.0')
+>>> ip += -1
+Traceback (most recent call last):
+...
+IndexError: result outside valid IP address boundary!
+
+>>> ip = IPAddress('255.255.255.255')
+>>> ip -= -1
+Traceback (most recent call last):
+...
+IndexError: result outside valid IP address boundary!
+
+}}}

netaddr/tests/3.x/ip/cidr.txt

@@ -0,0 +1,449 @@
+=CIDR Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+==Basic IP Range Tuple Sorting==
+
+{{{
+
+>>> ranges = (
+... (IPAddress('::'), IPAddress('::')),
+... (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')),
+... (IPAddress('::'), IPAddress('::255.255.255.255')),
+... (IPAddress('0.0.0.0'), IPAddress('0.0.0.0')),
+... )
+
+>>> sorted(ranges)
+[(IPAddress('0.0.0.0'), IPAddress('0.0.0.0')), (IPAddress('0.0.0.0'), IPAddress('255.255.255.255')), (IPAddress('::'), IPAddress('::')), (IPAddress('::'), IPAddress('::255.255.255.255'))]
+
+}}}
+
+Worst case IPv4 range to CIDR conversion.
+
+{{{
+
+>>> for ip in iprange_to_cidrs('0.0.0.1', '255.255.255.254'):
+...     ip
+...
+IPNetwork('0.0.0.1/32')
+IPNetwork('0.0.0.2/31')
+IPNetwork('0.0.0.4/30')
+IPNetwork('0.0.0.8/29')
+IPNetwork('0.0.0.16/28')
+IPNetwork('0.0.0.32/27')
+IPNetwork('0.0.0.64/26')
+IPNetwork('0.0.0.128/25')
+IPNetwork('0.0.1.0/24')
+IPNetwork('0.0.2.0/23')
+IPNetwork('0.0.4.0/22')
+IPNetwork('0.0.8.0/21')
+IPNetwork('0.0.16.0/20')
+IPNetwork('0.0.32.0/19')
+IPNetwork('0.0.64.0/18')
+IPNetwork('0.0.128.0/17')
+IPNetwork('0.1.0.0/16')
+IPNetwork('0.2.0.0/15')
+IPNetwork('0.4.0.0/14')
+IPNetwork('0.8.0.0/13')
+IPNetwork('0.16.0.0/12')
+IPNetwork('0.32.0.0/11')
+IPNetwork('0.64.0.0/10')
+IPNetwork('0.128.0.0/9')
+IPNetwork('1.0.0.0/8')
+IPNetwork('2.0.0.0/7')
+IPNetwork('4.0.0.0/6')
+IPNetwork('8.0.0.0/5')
+IPNetwork('16.0.0.0/4')
+IPNetwork('32.0.0.0/3')
+IPNetwork('64.0.0.0/2')
+IPNetwork('128.0.0.0/2')
+IPNetwork('192.0.0.0/3')
+IPNetwork('224.0.0.0/4')
+IPNetwork('240.0.0.0/5')
+IPNetwork('248.0.0.0/6')
+IPNetwork('252.0.0.0/7')
+IPNetwork('254.0.0.0/8')
+IPNetwork('255.0.0.0/9')
+IPNetwork('255.128.0.0/10')
+IPNetwork('255.192.0.0/11')
+IPNetwork('255.224.0.0/12')
+IPNetwork('255.240.0.0/13')
+IPNetwork('255.248.0.0/14')
+IPNetwork('255.252.0.0/15')
+IPNetwork('255.254.0.0/16')
+IPNetwork('255.255.0.0/17')
+IPNetwork('255.255.128.0/18')
+IPNetwork('255.255.192.0/19')
+IPNetwork('255.255.224.0/20')
+IPNetwork('255.255.240.0/21')
+IPNetwork('255.255.248.0/22')
+IPNetwork('255.255.252.0/23')
+IPNetwork('255.255.254.0/24')
+IPNetwork('255.255.255.0/25')
+IPNetwork('255.255.255.128/26')
+IPNetwork('255.255.255.192/27')
+IPNetwork('255.255.255.224/28')
+IPNetwork('255.255.255.240/29')
+IPNetwork('255.255.255.248/30')
+IPNetwork('255.255.255.252/31')
+IPNetwork('255.255.255.254/32')
+
+}}}
+
+Worst case IPv4 mapped IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::ffff:1', '::ffff:255.255.255.254'):
+...     ip
+...
+IPNetwork('::255.255.0.1/128')
+IPNetwork('::255.255.0.2/127')
+IPNetwork('::255.255.0.4/126')
+IPNetwork('::255.255.0.8/125')
+IPNetwork('::255.255.0.16/124')
+IPNetwork('::255.255.0.32/123')
+IPNetwork('::255.255.0.64/122')
+IPNetwork('::255.255.0.128/121')
+IPNetwork('::255.255.1.0/120')
+IPNetwork('::255.255.2.0/119')
+IPNetwork('::255.255.4.0/118')
+IPNetwork('::255.255.8.0/117')
+IPNetwork('::255.255.16.0/116')
+IPNetwork('::255.255.32.0/115')
+IPNetwork('::255.255.64.0/114')
+IPNetwork('::255.255.128.0/113')
+IPNetwork('::1:0:0/96')
+IPNetwork('::2:0:0/95')
+IPNetwork('::4:0:0/94')
+IPNetwork('::8:0:0/93')
+IPNetwork('::10:0:0/92')
+IPNetwork('::20:0:0/91')
+IPNetwork('::40:0:0/90')
+IPNetwork('::80:0:0/89')
+IPNetwork('::100:0:0/88')
+IPNetwork('::200:0:0/87')
+IPNetwork('::400:0:0/86')
+IPNetwork('::800:0:0/85')
+IPNetwork('::1000:0:0/84')
+IPNetwork('::2000:0:0/83')
+IPNetwork('::4000:0:0/82')
+IPNetwork('::8000:0:0/82')
+IPNetwork('::c000:0:0/83')
+IPNetwork('::e000:0:0/84')
+IPNetwork('::f000:0:0/85')
+IPNetwork('::f800:0:0/86')
+IPNetwork('::fc00:0:0/87')
+IPNetwork('::fe00:0:0/88')
+IPNetwork('::ff00:0:0/89')
+IPNetwork('::ff80:0:0/90')
+IPNetwork('::ffc0:0:0/91')
+IPNetwork('::ffe0:0:0/92')
+IPNetwork('::fff0:0:0/93')
+IPNetwork('::fff8:0:0/94')
+IPNetwork('::fffc:0:0/95')
+IPNetwork('::fffe:0:0/96')
+IPNetwork('::ffff:0.0.0.0/97')
+IPNetwork('::ffff:128.0.0.0/98')
+IPNetwork('::ffff:192.0.0.0/99')
+IPNetwork('::ffff:224.0.0.0/100')
+IPNetwork('::ffff:240.0.0.0/101')
+IPNetwork('::ffff:248.0.0.0/102')
+IPNetwork('::ffff:252.0.0.0/103')
+IPNetwork('::ffff:254.0.0.0/104')
+IPNetwork('::ffff:255.0.0.0/105')
+IPNetwork('::ffff:255.128.0.0/106')
+IPNetwork('::ffff:255.192.0.0/107')
+IPNetwork('::ffff:255.224.0.0/108')
+IPNetwork('::ffff:255.240.0.0/109')
+IPNetwork('::ffff:255.248.0.0/110')
+IPNetwork('::ffff:255.252.0.0/111')
+IPNetwork('::ffff:255.254.0.0/112')
+IPNetwork('::ffff:255.255.0.0/113')
+IPNetwork('::ffff:255.255.128.0/114')
+IPNetwork('::ffff:255.255.192.0/115')
+IPNetwork('::ffff:255.255.224.0/116')
+IPNetwork('::ffff:255.255.240.0/117')
+IPNetwork('::ffff:255.255.248.0/118')
+IPNetwork('::ffff:255.255.252.0/119')
+IPNetwork('::ffff:255.255.254.0/120')
+IPNetwork('::ffff:255.255.255.0/121')
+IPNetwork('::ffff:255.255.255.128/122')
+IPNetwork('::ffff:255.255.255.192/123')
+IPNetwork('::ffff:255.255.255.224/124')
+IPNetwork('::ffff:255.255.255.240/125')
+IPNetwork('::ffff:255.255.255.248/126')
+IPNetwork('::ffff:255.255.255.252/127')
+IPNetwork('::ffff:255.255.255.254/128')
+
+}}}
+
+RFC 4291 CIDR tests.
+
+{{{
+
+>>> str(IPNetwork('2001:0DB8:0000:CD30:0000:0000:0000:0000/60'))
+'2001:db8:0:cd30::/60'
+
+>>> str(IPNetwork('2001:0DB8::CD30:0:0:0:0/60'))
+'2001:db8:0:cd30::/60'
+
+>>> str(IPNetwork('2001:0DB8:0:CD30::/60'))
+'2001:db8:0:cd30::/60'
+
+}}}
+
+Equality tests.
+
+{{{
+
+>>> IPNetwork('192.0.2.0/255.255.254.0') == IPNetwork('192.0.2.0/23')
+True
+
+>>> IPNetwork('192.0.2.65/255.255.254.0') == IPNetwork('192.0.2.0/23')
+True
+
+>>> IPNetwork('192.0.2.65/255.255.254.0') == IPNetwork('192.0.2.65/23')
+True
+
+>>> IPNetwork('192.0.2.65/255.255.255.0') == IPNetwork('192.0.2.0/23')
+False
+
+>>> IPNetwork('192.0.2.65/255.255.254.0') == IPNetwork('192.0.2.65/24')
+False
+
+}}}
+
+Slicing tests.
+
+{{{
+
+>>> ip = IPNetwork('192.0.2.0/23')
+>>> ip.first == 3221225984
+True
+
+>>> ip.last == 3221226495
+True
+
+>>> ip[0]
+IPAddress('192.0.2.0')
+
+>>> ip[-1]
+IPAddress('192.0.3.255')
+
+>>> list(ip[::128])
+[IPAddress('192.0.2.0'), IPAddress('192.0.2.128'), IPAddress('192.0.3.0'), IPAddress('192.0.3.128')]
+
+>>> ip = IPNetwork('fe80::/10')
+>>> ip[0]
+IPAddress('fe80::')
+
+>>> ip[-1]
+IPAddress('febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
+
+>>> ip.size == 332306998946228968225951765070086144
+True
+
+>>> list(ip[0:5:1])
+Traceback (most recent call last):
+...
+TypeError: IPv6 slices are not supported!
+
+
+}}}
+
+Membership tests.
+
+{{{
+
+>>> IPAddress('192.0.2.1') in IPNetwork('192.0.2.0/24')
+True
+
+>>> IPAddress('192.0.2.255') in IPNetwork('192.0.2.0/24')
+True
+
+>>> IPNetwork('192.0.2.0/24') in IPNetwork('192.0.2.0/23')
+True
+
+>>> IPNetwork('192.0.2.0/24') in IPNetwork('192.0.2.0/24')
+True
+
+>>> IPAddress('ffff::1') in IPNetwork('ffff::/127')
+True
+
+>>> IPNetwork('192.0.2.0/23') in IPNetwork('192.0.2.0/24')
+False
+
+}}}
+
+Equality tests.
+
+{{{
+
+>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.2.0/24')
+True
+
+>>> IPNetwork('192.0.2.0/24') is not IPNetwork('192.0.2.0/24')
+True
+
+>>> IPNetwork('192.0.2.0/24') != IPNetwork('192.0.2.0/24')
+False
+
+>>> IPNetwork('192.0.2.0/24') is IPNetwork('192.0.2.0/24')
+False
+
+>>> IPNetwork('fe80::/10') == IPNetwork('fe80::/10')
+True
+
+>>> IPNetwork('fe80::/10') is not IPNetwork('fe80::/10')
+True
+
+>>> IPNetwork('fe80::/10') != IPNetwork('fe80::/10')
+False
+
+>>> IPNetwork('fe80::/10') is IPNetwork('fe80::/10')
+False
+
+}}}
+
+Exclusion tests.
+
+{{{
+
+#   Equivalent to :-
+#   >>> set([1]) - set([1])
+#   set([1])
+>>> cidr_exclude('192.0.2.1/32', '192.0.2.1/32')
+[]
+
+#   Equivalent to :-
+#   >>> set([1,2]) - set([2])
+#   set([1])
+>>> cidr_exclude('192.0.2.0/31', '192.0.2.1/32')
+[IPNetwork('192.0.2.0/32')]
+
+#   Equivalent to :-
+#   >>> set([1,2,3,4,5,6,7,8]) - set([5,6,7,8])
+#   set([1, 2, 3, 4])
+>>> cidr_exclude('192.0.2.0/24', '192.0.2.128/25')
+[IPNetwork('192.0.2.0/25')]
+
+#   Equivalent to :-
+#   >>> set([1,2,3,4,5,6,7,8]) - set([5,6])
+#   set([1, 2, 3, 4, 7, 8])
+>>> cidr_exclude('192.0.2.0/24', '192.0.2.128/27')
+[IPNetwork('192.0.2.0/25'), IPNetwork('192.0.2.160/27'), IPNetwork('192.0.2.192/26')]
+
+#   Subtracting a larger range from a smaller one results in an empty
+#   list (rather than a negative CIDR - which would be rather odd)!
+#
+#   Equivalent to :-
+#   >>> set([1]) - set([1,2,3])
+#   set([])
+>>> cidr_exclude('192.0.2.1/32', '192.0.2.0/24')
+[]
+
+}}}
+
+Please Note: excluding IP subnets that are not within each other and have no overlaps should return the original target IP object.
+
+{{{
+
+#   Equivalent to :-
+#   >>> set([1,2,3]) - set([4])
+#   set([1,2,3])
+>>> cidr_exclude('192.0.2.0/28', '192.0.2.16/32')
+[IPNetwork('192.0.2.0/28')]
+
+#   Equivalent to :-
+#   >>> set([1]) - set([2,3,4])
+#   set([1])
+>>> cidr_exclude('192.0.1.255/32', '192.0.2.0/28')
+[IPNetwork('192.0.1.255/32')]
+
+}}}
+
+Merge tests.
+
+{{{
+
+>>> cidr_merge(['192.0.128.0/24', '192.0.129.0/24'])
+[IPNetwork('192.0.128.0/23')]
+
+>>> cidr_merge(['192.0.129.0/24', '192.0.130.0/24'])
+[IPNetwork('192.0.129.0/24'), IPNetwork('192.0.130.0/24')]
+
+>>> cidr_merge(['192.0.2.112/30', '192.0.2.116/31', '192.0.2.118/31'])
+[IPNetwork('192.0.2.112/29')]
+
+>>> cidr_merge(['192.0.2.112/30', '192.0.2.116/32', '192.0.2.118/31'])
+[IPNetwork('192.0.2.112/30'), IPNetwork('192.0.2.116/32'), IPNetwork('192.0.2.118/31')]
+
+>>> cidr_merge(['192.0.2.112/31', '192.0.2.116/31', '192.0.2.118/31'])
+[IPNetwork('192.0.2.112/31'), IPNetwork('192.0.2.116/30')]
+
+>>> cidr_merge(['192.0.1.254/31',
+... '192.0.2.0/28',
+... '192.0.2.16/28',
+... '192.0.2.32/28',
+... '192.0.2.48/28',
+... '192.0.2.64/28',
+... '192.0.2.80/28',
+... '192.0.2.96/28',
+... '192.0.2.112/28',
+... '192.0.2.128/28',
+... '192.0.2.144/28',
+... '192.0.2.160/28',
+... '192.0.2.176/28',
+... '192.0.2.192/28',
+... '192.0.2.208/28',
+... '192.0.2.224/28',
+... '192.0.2.240/28',
+... '192.0.3.0/28'])
+[IPNetwork('192.0.1.254/31'), IPNetwork('192.0.2.0/24'), IPNetwork('192.0.3.0/28')]
+
+}}}
+
+Extended merge tests.
+
+{{{
+
+>>> import random
+
+#   Start with a single /23 CIDR.
+
+>>> orig_cidr_ipv4 = IPNetwork('192.0.2.0/23')
+>>> orig_cidr_ipv6 = IPNetwork('::192.0.2.0/120')
+
+#   Split it into /28 subnet CIDRs (mix CIDR objects and CIDR strings).
+
+>>> cidr_subnets = []
+>>> cidr_subnets.extend([str(c) for c in orig_cidr_ipv4.subnet(28)])
+>>> cidr_subnets.extend(list(orig_cidr_ipv4.subnet(28)))
+>>> cidr_subnets.extend([str(c) for c in orig_cidr_ipv6.subnet(124)])
+>>> cidr_subnets.extend(list(orig_cidr_ipv6.subnet(124)))
+
+#   Add a couple of duplicates in to make sure summarization is working OK.
+
+>>> cidr_subnets.append('192.0.2.1/32')
+>>> cidr_subnets.append('192.0.2.128/25')
+>>> cidr_subnets.append('::192.0.2.92/128')
+
+#   Randomize the order of subnets.
+>>> random.shuffle(cidr_subnets)
+
+#   Perform summarization operation.
+>>> merged_cidrs = cidr_merge(cidr_subnets) 
+>>> merged_cidrs
+[IPNetwork('192.0.2.0/23'), IPNetwork('::192.0.2.0/120')]
+
+>>> merged_cidrs == [orig_cidr_ipv4, orig_cidr_ipv6]
+True
+
+}}}

netaddr/tests/3.x/ip/constructor.txt

@@ -0,0 +1,234 @@
+=IP Constructor Stress Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+IPAddress constructor - integer values.
+
+{{{
+
+>>> IPAddress(1)
+IPAddress('0.0.0.1')
+
+>>> IPAddress(1, 4)
+IPAddress('0.0.0.1')
+
+>>> IPAddress(1, 6)
+IPAddress('::1')
+
+>>> IPAddress(10)
+IPAddress('0.0.0.10')
+
+>>> IPAddress(0x1ffffffff)
+IPAddress('::1:ffff:ffff')
+
+>>> IPAddress(0xffffffff, 6)
+IPAddress('::255.255.255.255')
+
+>>> IPAddress(0x1ffffffff)
+IPAddress('::1:ffff:ffff')
+
+>>> IPAddress(2 ** 128 - 1)
+IPAddress('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
+
+}}}
+
+IPAddress constructor - IPv4 inet_aton behaviour (default).
+
+{{{
+
+#	Hexadecimal octets.
+>>> IPAddress('0x7f.0x1')
+IPAddress('127.0.0.1')
+
+>>> IPAddress('0x7f.0x0.0x0.0x1')
+IPAddress('127.0.0.1')
+
+#	Octal octets.
+>>> IPAddress('0177.01')
+IPAddress('127.0.0.1')
+
+#	Mixed octets.
+>>> IPAddress('0x7f.0.01')
+IPAddress('127.0.0.1')
+
+#	Partial addresses - pretty weird ...
+>>> IPAddress('127')
+IPAddress('0.0.0.127')
+
+>>> IPAddress('127')
+IPAddress('0.0.0.127')
+
+>>> IPAddress('127.1')
+IPAddress('127.0.0.1')
+
+>>> IPAddress('127.0.1')
+IPAddress('127.0.0.1')
+
+}}}
+
+IPAddress constructor - IPv4 inet_pton behaviour (stricter parser).
+
+{{{
+
+#	Octal octets.
+>>> IPAddress('0177.01', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '0177.01'
+
+#	Mixed octets.
+>>> IPAddress('0x7f.0.01', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '0x7f.0.01'
+
+#   Partial octets.
+>>> IPAddress('10', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '10'
+
+>>> IPAddress('10.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '10.1'
+
+>>> IPAddress('10.0.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '10.0.1'
+
+>>> IPAddress('10.0.0.1', flags=INET_PTON)
+IPAddress('10.0.0.1')
+
+}}}
+
+IPAddress constructor - zero filled octets.
+
+{{{
+
+#   This takes a lot of people by surprise ...
+>>> IPAddress('010.000.000.001')
+IPAddress('8.0.0.1')
+
+#   So, we need this!
+>>> IPAddress('010.000.000.001', flags=ZEROFILL)
+IPAddress('10.0.0.1')
+
+#   Zero-fill with inet_aton behaviour - partial octets are OK but zero-filled
+#   octets are interpreted as decimal ...
+>>> IPAddress('010.000.001', flags=ZEROFILL)
+IPAddress('10.0.0.1')
+
+#   Zero-fill with inet_pton behaviour - 4 octets only!
+>>> IPAddress('010.000.001', flags=INET_PTON|ZEROFILL)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '010.000.001'
+
+#   Zero-fill with inet_pton behaviour - 4 octets only!
+>>> IPAddress('010.000.000.001', flags=INET_PTON|ZEROFILL)
+IPAddress('10.0.0.1')
+
+#   To save some typing there are short versions of these flags.
+>>> IPAddress('010.000.000.001', flags=P|Z)
+IPAddress('10.0.0.1')
+
+}}}
+
+IP network construction.
+
+{{{
+
+>>> IPNetwork('192.0.2.0/24')
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('192.0.2.0/255.255.255.0')
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('192.0.2.0/0.0.0.255')
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork(IPNetwork('192.0.2.0/24'))
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork(IPNetwork('::192.0.2.0/120'))
+IPNetwork('::192.0.2.0/120')
+
+>>> IPNetwork(IPNetwork('192.0.2.0/24'))
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('::192.0.2.0/120')
+IPNetwork('::192.0.2.0/120')
+
+>>> IPNetwork('::192.0.2.0/120', 6)
+IPNetwork('::192.0.2.0/120')
+
+}}}
+
+Optional implicit IP network prefix selection rules.
+
+{{{
+
+>>> IPNetwork('192.0.2.0', implicit_prefix=True)
+IPNetwork('192.0.2.0/24')
+
+>>> IPNetwork('231.192.0.15', implicit_prefix=True)
+IPNetwork('231.192.0.15/4')
+
+>>> IPNetwork('10', implicit_prefix=True)
+IPNetwork('10.0.0.0/8')
+
+}}}
+
+Optional flags for tweaking IPNetwork constructor behaviour.
+
+{{{
+
+>>> IPNetwork('172.24.200')
+IPNetwork('172.24.200.0/32')
+
+>>> IPNetwork('172.24.200', implicit_prefix=True)
+IPNetwork('172.24.200.0/16')
+
+#	Truncate the host bits so we get a pure network.
+>>> IPNetwork('172.24.200', implicit_prefix=True, flags=NOHOST)
+IPNetwork('172.24.0.0/16')
+
+
+}}}
+
+Negative testing
+
+{{{
+
+>>> IPNetwork('foo')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: invalid IPNetwork foo
+
+}}}
+
+Netmasks
+
+{{{
+
+>>> IPAddress('1.1.1.1').netmask_bits()
+32
+
+>>> IPAddress('255.255.255.254').netmask_bits()
+31
+
+>>> IPAddress('255.255.255.0').netmask_bits()
+24
+
+>>> IPAddress('::').netmask_bits()
+128
+
+}}}

netaddr/tests/3.x/ip/formats.txt

@@ -0,0 +1,27 @@
+=IP formatting options=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+==IPAddress representations==
+
+{{{
+
+>>> hex(IPAddress(0))
+'0x0'
+
+>>> hex(IPAddress(0xffffffff))
+'0xffffffff'
+
+>>> oct(IPAddress(0))
+'0o0'
+
+>>> oct(IPAddress(0xffffffff))
+'0o37777777777'
+
+}}}

netaddr/tests/3.x/ip/functions.txt

@@ -0,0 +1,48 @@
+=IP Function Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+During a cidr merge operation, the address 0.0.0.0/0, representing the whole of the IPv4 address space, should swallow anything it is merged with.
+
+{{{
+
+>>> cidr_merge(['0.0.0.0/0', '0.0.0.0'])
+[IPNetwork('0.0.0.0/0')]
+
+>>> cidr_merge(['0.0.0.0/0', '255.255.255.255'])
+[IPNetwork('0.0.0.0/0')]
+
+>>> cidr_merge(['0.0.0.0/0', '192.0.2.0/24', '10.0.0.0/8'])
+[IPNetwork('0.0.0.0/0')]
+
+}}}
+
+Same goes for the IPv6 CIDR ::/0, representing the whole of the IPv6 address space.
+
+{{{
+
+>>> cidr_merge(['::/0', 'fe80::1'])
+[IPNetwork('::/0')]
+
+>>> cidr_merge(['::/0', '::'])
+[IPNetwork('::/0')]
+
+>>> cidr_merge(['::/0', '::192.0.2.0/124', 'ff00::101'])
+[IPNetwork('::/0')]
+
+}}}
+
+This also applies to mixed IPv4 and IPv6 address lists.
+
+{{{
+
+>>> cidr_merge(['0.0.0.0/0', '0.0.0.0', '::/0', '::'])
+[IPNetwork('0.0.0.0/0'), IPNetwork('::/0')]
+
+}}}

netaddr/tests/3.x/ip/ipglob.txt

@@ -0,0 +1,72 @@
+=IP Glob Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+IP Glob tests.
+
+{{{
+
+>>> cidr_to_glob('10.0.0.1/32')
+'10.0.0.1'
+
+>>> cidr_to_glob('192.0.2.0/24')
+'192.0.2.*'
+
+>>> cidr_to_glob('172.16.0.0/12')
+'172.16-31.*.*'
+
+>>> cidr_to_glob('0.0.0.0/0')
+'*.*.*.*'
+
+>>> glob_to_cidrs('10.0.0.1')
+[IPNetwork('10.0.0.1/32')]
+
+>>> glob_to_cidrs('192.0.2.*')
+[IPNetwork('192.0.2.0/24')]
+
+>>> glob_to_cidrs('172.16-31.*.*')
+[IPNetwork('172.16.0.0/12')]
+
+>>> glob_to_cidrs('*.*.*.*')
+[IPNetwork('0.0.0.0/0')]
+
+>>> glob_to_iptuple('*.*.*.*')
+(IPAddress('0.0.0.0'), IPAddress('255.255.255.255'))
+
+>>> iprange_to_globs('192.0.2.0', '192.0.2.255')
+['192.0.2.*']
+
+>>> iprange_to_globs('192.0.2.1', '192.0.2.15')
+['192.0.2.1-15']
+
+>>> iprange_to_globs('192.0.2.255', '192.0.4.1')
+['192.0.2.255', '192.0.3.*', '192.0.4.0-1']
+
+>>> iprange_to_globs('10.0.1.255', '10.0.255.255')
+['10.0.1.255', '10.0.2-3.*', '10.0.4-7.*', '10.0.8-15.*', '10.0.16-31.*', '10.0.32-63.*', '10.0.64-127.*', '10.0.128-255.*']
+
+}}}
+
+Validity tests.
+
+{{{
+
+>>> valid_glob('1.1.1.a')
+False
+
+>>> valid_glob('1.1.1.1/32')
+False
+
+>>> valid_glob('1.1.1.a-b')
+False
+
+>>> valid_glob('1.1.a-b.*')
+False
+
+}}}

netaddr/tests/3.x/ip/iprange.txt

@@ -0,0 +1,171 @@
+=IPRange Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Constructor tests.
+
+{{{
+
+>>> iprange = IPRange('192.0.2.1', '192.0.2.254')
+
+>>> iprange
+IPRange('192.0.2.1', '192.0.2.254')
+
+>>> '%s' % iprange
+'192.0.2.1-192.0.2.254'
+
+>>> IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+
+>>> IPRange('192.0.2.1', '192.0.2.1')
+IPRange('192.0.2.1', '192.0.2.1')
+
+>>> IPRange('208.049.164.000', '208.050.066.255', flags=ZEROFILL)
+IPRange('208.49.164.0', '208.50.66.255')
+
+}}}
+
+Bad constructor tests.
+
+{{{
+
+>>> IPRange('192.0.2.2', '192.0.2.1')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: lower bound IP greater than upper bound!
+
+>>> IPRange('::', '0.0.0.1')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: base address '0.0.0.1' is not IPv6
+
+>>> IPRange('0.0.0.0', '::1')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: base address '::1' is not IPv4
+
+}}}
+
+Indexing and slicing tests.
+
+{{{
+
+>>> iprange = IPRange('192.0.2.1', '192.0.2.254')
+
+>>> len(iprange)
+254
+
+>>> iprange.first == 3221225985
+True
+
+>>> iprange.last == 3221226238
+True
+
+>>> iprange[0]
+IPAddress('192.0.2.1')
+
+>>> iprange[-1]
+IPAddress('192.0.2.254')
+
+>>> iprange[512]
+Traceback (most recent call last):
+...
+IndexError: index out range for address range size!
+
+>>> list(iprange[0:3])
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3')]
+
+>>> list(iprange[0:10:2])
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.3'), IPAddress('192.0.2.5'), IPAddress('192.0.2.7'), IPAddress('192.0.2.9')]
+
+>>> list(iprange[0:1024:512])
+[IPAddress('192.0.2.1')]
+
+>>> IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')[0:10:2]
+Traceback (most recent call last):
+...
+TypeError: IPv6 slices are not supported!
+
+}}}
+
+Membership tests.
+
+{{{
+
+>>> IPRange('192.0.2.5', '192.0.2.10') in IPRange('192.0.2.1', '192.0.2.254')
+True
+
+>>> IPRange('fe80::1', 'fe80::fffe') in IPRange('fe80::', 'fe80::ffff:ffff:ffff:ffff')
+True
+
+>>> IPRange('192.0.2.5', '192.0.2.10') in IPRange('::', '::255.255.255.255')
+False
+
+}}}
+
+Sorting tests.
+
+{{{
+
+>>> ipranges = (IPRange('192.0.2.40', '192.0.2.50'), IPRange('192.0.2.20', '192.0.2.30'), IPRange('192.0.2.1', '192.0.2.254'),)
+
+>>> sorted(ipranges)
+[IPRange('192.0.2.1', '192.0.2.254'), IPRange('192.0.2.20', '192.0.2.30'), IPRange('192.0.2.40', '192.0.2.50')]
+
+>>> ipranges = list(ipranges)
+
+>>> ipranges.append(IPRange('192.0.2.45', '192.0.2.49'))
+
+>>> sorted(ipranges)
+[IPRange('192.0.2.1', '192.0.2.254'), IPRange('192.0.2.20', '192.0.2.30'), IPRange('192.0.2.40', '192.0.2.50'), IPRange('192.0.2.45', '192.0.2.49')]
+
+}}}
+
+CIDR interoperability tests.
+
+{{{
+
+>>> IPRange('192.0.2.5', '192.0.2.10').cidrs()
+[IPNetwork('192.0.2.5/32'), IPNetwork('192.0.2.6/31'), IPNetwork('192.0.2.8/31'), IPNetwork('192.0.2.10/32')]
+
+>>> IPRange('fe80::', 'fe80::ffff:ffff:ffff:ffff').cidrs()
+[IPNetwork('fe80::/64')]
+
+}}}
+
+Various additional tests.
+
+{{{
+
+>>> iprange.info
+{'IPv4': [{'date': '1993-05',
+ 'designation': 'Administered by ARIN',
+ 'prefix': '192/8',
+ 'status': 'Legacy',
+ 'whois': 'whois.arin.net'}]}
+
+>>> iprange.is_private()
+True
+
+>>> iprange.version
+4
+
+len() fails when the IPRange is longer than sys.maxint, which is quite likely with IPv6.
+>>> from netaddr.compat import _sys_maxint
+>>> r = IPRange(IPAddress("::0"), IPAddress(_sys_maxint, 6))
+>>> len(r)
+Traceback (most recent call last):
+  ...
+IndexError: range contains more than ...
+
+>>> r = IPRange(IPAddress("::0"), IPAddress(_sys_maxint - 1, 6))
+>>> len(r) == _sys_maxint
+True
+
+}}}

netaddr/tests/3.x/ip/matches.txt

@@ -0,0 +1,71 @@
+=IP Matching Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+>>> largest_matching_cidr('192.0.2.0', ['192.0.2.0'])
+IPNetwork('192.0.2.0/32')
+
+>>> largest_matching_cidr('192.0.2.0', ['10.0.0.1', '192.0.2.0'])
+IPNetwork('192.0.2.0/32')
+
+>>> largest_matching_cidr('192.0.2.0', ['10.0.0.1', '192.0.2.0', '224.0.0.1'])
+IPNetwork('192.0.2.0/32')
+
+>>> smallest_matching_cidr('192.0.2.0', ['10.0.0.1', '192.0.2.0', '224.0.0.1'])
+IPNetwork('192.0.2.0/32')
+
+>>> smallest_matching_cidr('192.0.2.32', ['0.0.0.0/0', '10.0.0.0/8', '192.0.0.0/8', '192.0.1.0/24', '192.0.2.0/24', '192.0.3.0/24'])
+IPNetwork('192.0.2.0/24')
+
+>>> all_matching_cidrs('192.0.2.32', ['0.0.0.0/0', '10.0.0.0/8', '192.0.0.0/8', '192.0.1.0/24', '192.0.2.0/24', '192.0.3.0/24'])
+[IPNetwork('0.0.0.0/0'), IPNetwork('192.0.0.0/8'), IPNetwork('192.0.2.0/24')]
+
+>>> smallest_matching_cidr('192.0.2.0', ['10.0.0.1', '224.0.0.1'])
+
+>>> largest_matching_cidr('192.0.2.0', ['10.0.0.1', '224.0.0.1'])
+
+>>> networks = [str(c) for c in IPNetwork('192.0.2.128/27').supernet(22)]
+
+>>> networks
+['192.0.0.0/22', '192.0.2.0/23', '192.0.2.0/24', '192.0.2.128/25', '192.0.2.128/26']
+
+>>> all_matching_cidrs('192.0.2.0', networks)
+[IPNetwork('192.0.0.0/22'), IPNetwork('192.0.2.0/23'), IPNetwork('192.0.2.0/24')]
+
+>>> smallest_matching_cidr('192.0.2.0', networks)
+IPNetwork('192.0.2.0/24')
+
+>>> largest_matching_cidr('192.0.2.0', networks)
+IPNetwork('192.0.0.0/22')
+
+}}}
+
+Checking matches with varying IP address versions.
+
+{{{
+>>> all_matching_cidrs('192.0.2.0', ['192.0.2.0/24'])
+[IPNetwork('192.0.2.0/24')]
+
+>>> all_matching_cidrs('192.0.2.0', ['::/96'])
+[]
+
+>>> all_matching_cidrs('::ffff:192.0.2.1', ['::ffff:192.0.2.0/96'])
+[IPNetwork('::ffff:192.0.2.0/96')]
+
+>>> all_matching_cidrs('::192.0.2.1', ['::192.0.2.0/96'])
+[IPNetwork('::192.0.2.0/96')]
+
+>>> all_matching_cidrs('::192.0.2.1', ['192.0.2.0/23'])
+[]
+
+>>> all_matching_cidrs('::192.0.2.1', ['192.0.2.0/24', '::192.0.2.0/120'])
+[IPNetwork('::192.0.2.0/120')]
+
+>>> all_matching_cidrs('::192.0.2.1', [IPNetwork('192.0.2.0/24'), IPNetwork('::192.0.2.0/120')])
+[IPNetwork('::192.0.2.0/120')]
+
+}}}

netaddr/tests/3.x/ip/multicast.txt

@@ -0,0 +1,30 @@
+=IP Multicast Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+>>> ip = IPAddress('239.192.0.1')
+
+>>> ip.is_multicast()
+True
+
+>>> ip = IPAddress(3221225984)
+
+>>> ip = IPAddress('224.0.1.173')
+
+>>> ip.info.IPv4[0].designation
+'Multicast'
+
+>>> ip.info.IPv4[0].prefix
+'224/8'
+
+>>> ip.info.IPv4[0].status
+'Reserved'
+
+>>> ip.info.Multicast[0].address
+'224.0.1.173'
+
+}}}

netaddr/tests/3.x/ip/nmap.txt

@@ -0,0 +1,118 @@
+=nmap IP Range Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+nmap IP range validation.
+
+{{{
+
+>>> valid_nmap_range('192.0.2.1')
+True
+    
+>>> valid_nmap_range('192.0.2.0-31')
+True
+
+>>> valid_nmap_range('192.0.2-3.1-254')
+True
+
+>>> valid_nmap_range('0-255.0-255.0-255.0-255')
+True
+
+>>> valid_nmap_range('192.168.3-5,7.1')
+True
+
+>>> valid_nmap_range('192.168.3-5,7,10-12,13,14.1')
+True
+
+>>> valid_nmap_range(1)
+False
+
+>>> valid_nmap_range('1')
+False
+
+>>> valid_nmap_range([])
+False
+
+>>> valid_nmap_range({})
+False
+
+>>> valid_nmap_range('::')
+False
+
+>>> valid_nmap_range('255.255.255.256')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.0-256')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.-1-0')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.256-0')
+False
+
+>>> valid_nmap_range('0-255.0-255.0-255.255-0')
+False
+
+>>> valid_nmap_range('a.b.c.d-e')
+False
+
+>>> valid_nmap_range('255.255.255.a-b')
+False
+
+}}}
+
+nmap IP range iteration.
+
+{{{
+
+>>> list(iter_nmap_range('192.0.2.1'))
+[IPAddress('192.0.2.1')]
+    
+>>> ip_list = list(iter_nmap_range('192.0.2.0-31'))
+>>> len(ip_list)
+32
+>>> ip_list
+[IPAddress('192.0.2.0'), IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3'), IPAddress('192.0.2.4'), IPAddress('192.0.2.5'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), IPAddress('192.0.2.8'), IPAddress('192.0.2.9'), IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPAddress('192.0.2.12'), IPAddress('192.0.2.13'), IPAddress('192.0.2.14'), IPAddress('192.0.2.15'), IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), IPAddress('192.0.2.18'), IPAddress('192.0.2.19'), IPAddress('192.0.2.20'), IPAddress('192.0.2.21'), IPAddress('192.0.2.22'), IPAddress('192.0.2.23'), IPAddress('192.0.2.24'), IPAddress('192.0.2.25'), IPAddress('192.0.2.26'), IPAddress('192.0.2.27'), IPAddress('192.0.2.28'), IPAddress('192.0.2.29'), IPAddress('192.0.2.30'), IPAddress('192.0.2.31')]
+
+>>> ip_list = list(iter_nmap_range('192.0.2-3.1-7'))
+>>> len(ip_list)
+14
+
+>>> list(iter_nmap_range('192.0.2.1-3,5,7-9'))
+[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3'), IPAddress('192.0.2.5'), IPAddress('192.0.2.7'), IPAddress('192.0.2.8'), IPAddress('192.0.2.9')]
+
+>>> for ip in ip_list:
+...     print(ip)
+...     
+192.0.2.1
+192.0.2.2
+192.0.2.3
+192.0.2.4
+192.0.2.5
+192.0.2.6
+192.0.2.7
+192.0.3.1
+192.0.3.2
+192.0.3.3
+192.0.3.4
+192.0.3.5
+192.0.3.6
+192.0.3.7
+
+>>> list(iter_nmap_range('::'))
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: invalid nmap range: ::
+
+Remove duplicates, just like nmap does.
+>>> list(iter_nmap_range('10.0.0.42,42-42'))
+[IPAddress('10.0.0.42')]
+
+}}}

netaddr/tests/3.x/ip/pickling.txt

@@ -0,0 +1,214 @@
+=IP Persistence Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+>>> import pickle
+
+}}}
+
+IPAddress object pickling - IPv4.
+
+{{{
+
+>>> ip = IPAddress(3221225985)
+>>> ip
+IPAddress('192.0.2.1')
+
+>>> buf = pickle.dumps(ip)
+
+>>> ip2 = pickle.loads(buf)
+
+>>> ip2 == ip
+True
+
+>>> id(ip2) != id(ip)
+True
+
+>>> ip2.value == 3221225985
+True
+
+>>> ip2.version
+4
+
+>>> del ip, buf, ip2
+
+}}}
+
+IPAddress object pickling - IPv6.
+
+{{{
+
+>>> ip = IPAddress('::ffff:192.0.2.1')
+
+>>> ip
+IPAddress('::ffff:192.0.2.1')
+
+>>> ip.value == 281473902969345
+True
+
+>>> buf = pickle.dumps(ip)
+
+>>> ip2 = pickle.loads(buf)
+
+>>> ip2 == ip
+True
+
+>>> ip2.value == 281473902969345
+True
+
+>>> ip2.version
+6
+
+>>> del ip, buf, ip2
+
+}}}
+
+IPNetwork pickling - IPv4.
+
+{{{
+
+>>> cidr = IPNetwork('192.0.2.0/24')
+>>> cidr
+IPNetwork('192.0.2.0/24')
+
+>>> buf = pickle.dumps(cidr)
+
+>>> cidr2 = pickle.loads(buf)
+
+>>> cidr2 == cidr
+True
+
+>>> id(cidr2) != id(cidr)
+True
+
+>>> cidr2.value == 3221225984
+True
+
+>>> cidr2.prefixlen
+24
+
+>>> cidr2.version
+4
+
+>>> del cidr, buf, cidr2
+
+}}}
+
+IPNetwork object pickling - IPv6.
+
+{{{
+
+>>> cidr = IPNetwork('::ffff:192.0.2.0/120')
+
+>>> cidr
+IPNetwork('::ffff:192.0.2.0/120')
+
+>>> cidr.value == 281473902969344
+True
+
+>>> cidr.prefixlen
+120
+
+>>> buf = pickle.dumps(cidr)
+
+>>> cidr2 = pickle.loads(buf)
+
+>>> cidr2 == cidr
+True
+
+>>> cidr2.value == 281473902969344
+True
+
+>>> cidr2.prefixlen
+120
+
+>>> cidr2.version
+6
+
+>>> del cidr, buf, cidr2
+
+}}}
+
+}}}
+
+IPRange object pickling - IPv4.
+
+{{{
+
+>>> iprange = IPRange('192.0.2.1', '192.0.2.254')
+>>> iprange
+IPRange('192.0.2.1', '192.0.2.254')
+
+>>> iprange.first == 3221225985
+True
+
+>>> iprange.last == 3221226238
+True
+
+>>> iprange.version
+4
+
+>>> buf = pickle.dumps(iprange)
+
+>>> iprange2 = pickle.loads(buf)
+
+>>> iprange2 == iprange
+True
+
+>>> id(iprange2) != id(iprange)
+True
+
+>>> iprange2.first == 3221225985
+True
+
+>>> iprange2.last == 3221226238
+True
+
+>>> iprange2.version
+4
+
+>>> del iprange, buf, iprange2
+
+}}}
+
+IPRange object pickling - IPv6.
+
+{{{
+
+>>> iprange = IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+
+>>> iprange
+IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
+
+>>> iprange.first == 281473902969345
+True
+
+>>> iprange.last == 281473902969598
+True
+
+>>> iprange.version
+6
+
+>>> buf = pickle.dumps(iprange)
+
+>>> iprange2 = pickle.loads(buf)
+
+>>> iprange2 == iprange
+True
+
+>>> iprange2.first == 281473902969345
+True
+
+>>> iprange2.last == 281473902969598
+True
+
+>>> iprange2.version
+6
+
+>>> del iprange, buf, iprange2
+
+}}}
+

netaddr/tests/3.x/ip/platform_darwin.txt

@@ -0,0 +1,90 @@
+=Mac OSX Specific Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Worst case IPv4 compatible IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::1', '::255.255.255.254'):
+...     ip
+...
+IPNetwork('::1/128')
+IPNetwork('::0.0.0.2/127')
+IPNetwork('::0.0.0.4/126')
+IPNetwork('::0.0.0.8/125')
+IPNetwork('::0.0.0.16/124')
+IPNetwork('::0.0.0.32/123')
+IPNetwork('::0.0.0.64/122')
+IPNetwork('::0.0.0.128/121')
+IPNetwork('::0.0.1.0/120')
+IPNetwork('::0.0.2.0/119')
+IPNetwork('::0.0.4.0/118')
+IPNetwork('::0.0.8.0/117')
+IPNetwork('::0.0.16.0/116')
+IPNetwork('::0.0.32.0/115')
+IPNetwork('::0.0.64.0/114')
+IPNetwork('::0.0.128.0/113')
+IPNetwork('::0.1.0.0/112')
+IPNetwork('::0.2.0.0/111')
+IPNetwork('::0.4.0.0/110')
+IPNetwork('::0.8.0.0/109')
+IPNetwork('::0.16.0.0/108')
+IPNetwork('::0.32.0.0/107')
+IPNetwork('::0.64.0.0/106')
+IPNetwork('::0.128.0.0/105')
+IPNetwork('::1.0.0.0/104')
+IPNetwork('::2.0.0.0/103')
+IPNetwork('::4.0.0.0/102')
+IPNetwork('::8.0.0.0/101')
+IPNetwork('::16.0.0.0/100')
+IPNetwork('::32.0.0.0/99')
+IPNetwork('::64.0.0.0/98')
+IPNetwork('::128.0.0.0/98')
+IPNetwork('::192.0.0.0/99')
+IPNetwork('::224.0.0.0/100')
+IPNetwork('::240.0.0.0/101')
+IPNetwork('::248.0.0.0/102')
+IPNetwork('::252.0.0.0/103')
+IPNetwork('::254.0.0.0/104')
+IPNetwork('::255.0.0.0/105')
+IPNetwork('::255.128.0.0/106')
+IPNetwork('::255.192.0.0/107')
+IPNetwork('::255.224.0.0/108')
+IPNetwork('::255.240.0.0/109')
+IPNetwork('::255.248.0.0/110')
+IPNetwork('::255.252.0.0/111')
+IPNetwork('::255.254.0.0/112')
+IPNetwork('::255.255.0.0/113')
+IPNetwork('::255.255.128.0/114')
+IPNetwork('::255.255.192.0/115')
+IPNetwork('::255.255.224.0/116')
+IPNetwork('::255.255.240.0/117')
+IPNetwork('::255.255.248.0/118')
+IPNetwork('::255.255.252.0/119')
+IPNetwork('::255.255.254.0/120')
+IPNetwork('::255.255.255.0/121')
+IPNetwork('::255.255.255.128/122')
+IPNetwork('::255.255.255.192/123')
+IPNetwork('::255.255.255.224/124')
+IPNetwork('::255.255.255.240/125')
+IPNetwork('::255.255.255.248/126')
+IPNetwork('::255.255.255.252/127')
+IPNetwork('::255.255.255.254/128')
+
+#   inet_pton has to be different on Mac OSX *sigh*
+>>> IPAddress('010.000.000.001', flags=INET_PTON)
+IPAddress('10.0.0.1')
+
+>>> from netaddr.strategy.ipv6 import int_to_str
+>>> int_to_str(0xffff)
+'::0.0.255.255'
+
+}}}
+

netaddr/tests/3.x/ip/platform_linux2.txt

@@ -0,0 +1,94 @@
+=Linux Specific Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Worst case IPv4 compatible IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::1', '::255.255.255.254'):
+...     ip
+...
+IPNetwork('::1/128')
+IPNetwork('::2/127')
+IPNetwork('::4/126')
+IPNetwork('::8/125')
+IPNetwork('::10/124')
+IPNetwork('::20/123')
+IPNetwork('::40/122')
+IPNetwork('::80/121')
+IPNetwork('::100/120')
+IPNetwork('::200/119')
+IPNetwork('::400/118')
+IPNetwork('::800/117')
+IPNetwork('::1000/116')
+IPNetwork('::2000/115')
+IPNetwork('::4000/114')
+IPNetwork('::8000/113')
+IPNetwork('::0.1.0.0/112')
+IPNetwork('::0.2.0.0/111')
+IPNetwork('::0.4.0.0/110')
+IPNetwork('::0.8.0.0/109')
+IPNetwork('::0.16.0.0/108')
+IPNetwork('::0.32.0.0/107')
+IPNetwork('::0.64.0.0/106')
+IPNetwork('::0.128.0.0/105')
+IPNetwork('::1.0.0.0/104')
+IPNetwork('::2.0.0.0/103')
+IPNetwork('::4.0.0.0/102')
+IPNetwork('::8.0.0.0/101')
+IPNetwork('::16.0.0.0/100')
+IPNetwork('::32.0.0.0/99')
+IPNetwork('::64.0.0.0/98')
+IPNetwork('::128.0.0.0/98')
+IPNetwork('::192.0.0.0/99')
+IPNetwork('::224.0.0.0/100')
+IPNetwork('::240.0.0.0/101')
+IPNetwork('::248.0.0.0/102')
+IPNetwork('::252.0.0.0/103')
+IPNetwork('::254.0.0.0/104')
+IPNetwork('::255.0.0.0/105')
+IPNetwork('::255.128.0.0/106')
+IPNetwork('::255.192.0.0/107')
+IPNetwork('::255.224.0.0/108')
+IPNetwork('::255.240.0.0/109')
+IPNetwork('::255.248.0.0/110')
+IPNetwork('::255.252.0.0/111')
+IPNetwork('::255.254.0.0/112')
+IPNetwork('::255.255.0.0/113')
+IPNetwork('::255.255.128.0/114')
+IPNetwork('::255.255.192.0/115')
+IPNetwork('::255.255.224.0/116')
+IPNetwork('::255.255.240.0/117')
+IPNetwork('::255.255.248.0/118')
+IPNetwork('::255.255.252.0/119')
+IPNetwork('::255.255.254.0/120')
+IPNetwork('::255.255.255.0/121')
+IPNetwork('::255.255.255.128/122')
+IPNetwork('::255.255.255.192/123')
+IPNetwork('::255.255.255.224/124')
+IPNetwork('::255.255.255.240/125')
+IPNetwork('::255.255.255.248/126')
+IPNetwork('::255.255.255.252/127')
+IPNetwork('::255.255.255.254/128')
+
+#   Sadly, inet_pton cannot help us here ...
+>>> IPAddress('010.000.000.001', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '010.000.000.001'
+
+>>> from netaddr.strategy.ipv6 import int_to_str
+>>> int_to_str(0xffff)
+'::ffff'
+
+}}}
+
+
+

netaddr/tests/3.x/ip/platform_win32.txt

@@ -0,0 +1,92 @@
+=Windows Specific Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Worst case IPv4 compatible IPv6 range to CIDR. 
+
+{{{
+
+>>> for ip in iprange_to_cidrs('::1', '::255.255.255.254'):
+...     ip
+...
+IPNetwork('::1/128')
+IPNetwork('::2/127')
+IPNetwork('::4/126')
+IPNetwork('::8/125')
+IPNetwork('::10/124')
+IPNetwork('::20/123')
+IPNetwork('::40/122')
+IPNetwork('::80/121')
+IPNetwork('::100/120')
+IPNetwork('::200/119')
+IPNetwork('::400/118')
+IPNetwork('::800/117')
+IPNetwork('::1000/116')
+IPNetwork('::2000/115')
+IPNetwork('::4000/114')
+IPNetwork('::8000/113')
+IPNetwork('::0.1.0.0/112')
+IPNetwork('::0.2.0.0/111')
+IPNetwork('::0.4.0.0/110')
+IPNetwork('::0.8.0.0/109')
+IPNetwork('::0.16.0.0/108')
+IPNetwork('::0.32.0.0/107')
+IPNetwork('::0.64.0.0/106')
+IPNetwork('::0.128.0.0/105')
+IPNetwork('::1.0.0.0/104')
+IPNetwork('::2.0.0.0/103')
+IPNetwork('::4.0.0.0/102')
+IPNetwork('::8.0.0.0/101')
+IPNetwork('::16.0.0.0/100')
+IPNetwork('::32.0.0.0/99')
+IPNetwork('::64.0.0.0/98')
+IPNetwork('::128.0.0.0/98')
+IPNetwork('::192.0.0.0/99')
+IPNetwork('::224.0.0.0/100')
+IPNetwork('::240.0.0.0/101')
+IPNetwork('::248.0.0.0/102')
+IPNetwork('::252.0.0.0/103')
+IPNetwork('::254.0.0.0/104')
+IPNetwork('::255.0.0.0/105')
+IPNetwork('::255.128.0.0/106')
+IPNetwork('::255.192.0.0/107')
+IPNetwork('::255.224.0.0/108')
+IPNetwork('::255.240.0.0/109')
+IPNetwork('::255.248.0.0/110')
+IPNetwork('::255.252.0.0/111')
+IPNetwork('::255.254.0.0/112')
+IPNetwork('::255.255.0.0/113')
+IPNetwork('::255.255.128.0/114')
+IPNetwork('::255.255.192.0/115')
+IPNetwork('::255.255.224.0/116')
+IPNetwork('::255.255.240.0/117')
+IPNetwork('::255.255.248.0/118')
+IPNetwork('::255.255.252.0/119')
+IPNetwork('::255.255.254.0/120')
+IPNetwork('::255.255.255.0/121')
+IPNetwork('::255.255.255.128/122')
+IPNetwork('::255.255.255.192/123')
+IPNetwork('::255.255.255.224/124')
+IPNetwork('::255.255.255.240/125')
+IPNetwork('::255.255.255.248/126')
+IPNetwork('::255.255.255.252/127')
+IPNetwork('::255.255.255.254/128')
+
+#   Sadly, inet_pton cannot help us here ...
+>>> IPAddress('010.000.000.001', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: failed to detect a valid IP address from '010.000.000.001'
+
+>>> from netaddr.strategy.ipv6 import int_to_str
+>>> int_to_str(0xffff)
+'::ffff'
+
+}}}
+

netaddr/tests/3.x/ip/rfc1924.txt

@@ -0,0 +1,33 @@
+=RFC 1924 Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+The example from the RFC.
+
+{{{
+
+>>> from netaddr.ip.rfc1924 import ipv6_to_base85, base85_to_ipv6
+
+>>> ip_addr = '1080::8:800:200c:417a'
+
+>>> ip_addr
+'1080::8:800:200c:417a'
+    
+>>> base85 = ipv6_to_base85(ip_addr)
+
+>>> base85
+'4)+k&C#VzJ4br>0wv%Yp'
+
+RFC specifies that "leading zeroes are never omitted"
+>>> ipv6_to_base85("::1")
+'00000000000000000001'
+
+>>> base85_to_ipv6(base85)
+'1080::8:800:200c:417a'
+
+Invalid length for a base85 encoded IPv6 address
+>>> base85_to_ipv6('not 20 chars')
+Traceback (most recent call last):
+netaddr.core.AddrFormatError: Invalid base 85 IPv6 address: 'not 20 chars'
+
+}}}

netaddr/tests/3.x/ip/sets.txt

@@ -0,0 +1,695 @@
+=IPSet Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Basic operations.
+
+{{{
+
+>>> IPSet()
+IPSet([])
+
+>>> IPSet([])
+IPSet([])
+
+>>> len(IPSet([]))
+0
+
+len() fails when the IPSet is longer than sys.maxint, which is most likely with IPv6.
+>>> from netaddr.compat import _sys_maxint
+>>> s = IPSet(IPRange(IPAddress("::0"), IPAddress(_sys_maxint, 6)))
+>>> len(s)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  ...
+IndexError: range contains more than ...
+
+>>> s = IPSet(IPRange(IPAddress("::0"), IPAddress(_sys_maxint - 1, 6)))
+>>> len(s) == _sys_maxint
+True
+
+IPSets must be usable in boolean context, even when they are very large.
+>>> s6 = IPSet(['2405:8100::/32'])
+>>> bool(s6)
+True
+>>> bool(IPSet())
+False
+
+>>> IPSet(['192.0.2.0'])
+IPSet(['192.0.2.0/32'])
+
+>>> IPSet([IPAddress('192.0.2.0')])
+IPSet(['192.0.2.0/32'])
+
+>>> IPSet([IPNetwork('192.0.2.0')])
+IPSet(['192.0.2.0/32'])
+
+>>> IPSet(IPNetwork('1234::/32'))
+IPSet(['1234::/32'])
+
+>>> IPSet([IPNetwork('192.0.2.0/24')])
+IPSet(['192.0.2.0/24'])
+
+>>> IPSet(IPSet(['192.0.2.0/32']))
+IPSet(['192.0.2.0/32'])
+
+>>> IPSet(IPRange("10.0.0.0", "10.0.1.31"))
+IPSet(['10.0.0.0/24', '10.0.1.0/27'])
+
+>>> IPSet(IPRange('0.0.0.0', '255.255.255.255'))
+IPSet(['0.0.0.0/0'])
+
+>>> for ip in IPSet(['192.0.2.0/28', '::192.0.2.0/124']):
+...     print(ip)
+192.0.2.0
+192.0.2.1
+192.0.2.2
+192.0.2.3
+192.0.2.4
+192.0.2.5
+192.0.2.6
+192.0.2.7
+192.0.2.8
+192.0.2.9
+192.0.2.10
+192.0.2.11
+192.0.2.12
+192.0.2.13
+192.0.2.14
+192.0.2.15
+::192.0.2.0
+::192.0.2.1
+::192.0.2.2
+::192.0.2.3
+::192.0.2.4
+::192.0.2.5
+::192.0.2.6
+::192.0.2.7
+::192.0.2.8
+::192.0.2.9
+::192.0.2.10
+::192.0.2.11
+::192.0.2.12
+::192.0.2.13
+::192.0.2.14
+::192.0.2.15
+
+}}}
+
+Adding and removing elements.
+
+{{{
+
+>>> s1 = IPSet()
+
+>>> s1.add('192.0.2.0')
+
+>>> s1
+IPSet(['192.0.2.0/32'])
+
+>>> s1.remove('192.0.2.0')
+
+>>> s1
+IPSet([])
+
+>>> s1.remove('192.0.2.0')
+>>> s1
+IPSet([])
+
+>>> s1.add(IPRange("10.0.0.0", "10.0.0.255"))
+>>> s1
+IPSet(['10.0.0.0/24'])
+
+>>> s1.remove(IPRange("10.0.0.128", "10.10.10.10"))
+>>> s1
+IPSet(['10.0.0.0/25'])
+
+This hits a special case in IPSet._compact_single_network()
+>>> s1.add('10.0.0.0/24')
+>>> s1
+IPSet(['10.0.0.0/24'])
+
+Various places must also accept integers.
+>>> integer1 = int(IPAddress('10.0.0.1'))
+>>> integer2 = int(IPAddress('fe80::'))
+>>> integer3 = int(IPAddress('10.0.0.2'))
+>>> s2 = IPSet([integer1, integer2])
+>>> s2
+IPSet(['10.0.0.1/32', 'fe80::/128'])
+>>> s2.add(integer3)
+>>> s2
+IPSet(['10.0.0.1/32', '10.0.0.2/32', 'fe80::/128'])
+>>> s2.remove(integer2)
+>>> s2
+IPSet(['10.0.0.1/32', '10.0.0.2/32'])
+>>> s2.update([integer2])
+>>> s2
+IPSet(['10.0.0.1/32', '10.0.0.2/32', 'fe80::/128'])
+
+}}}
+
+Set membership.
+
+{{{
+
+>>> iprange = IPRange('192.0.1.255', '192.0.2.16')
+
+>>> iprange.cidrs()
+[IPNetwork('192.0.1.255/32'), IPNetwork('192.0.2.0/28'), IPNetwork('192.0.2.16/32')]
+
+>>> ipset = IPSet(['192.0.2.0/28'])
+
+>>> for ip in iprange:
+...     print(ip, ip in ipset)
+192.0.1.255 False
+192.0.2.0 True
+192.0.2.1 True
+192.0.2.2 True
+192.0.2.3 True
+192.0.2.4 True
+192.0.2.5 True
+192.0.2.6 True
+192.0.2.7 True
+192.0.2.8 True
+192.0.2.9 True
+192.0.2.10 True
+192.0.2.11 True
+192.0.2.12 True
+192.0.2.13 True
+192.0.2.14 True
+192.0.2.15 True
+192.0.2.16 False
+
+>>> bigone = IPSet(['0.0.0.0/0'])
+>>> IPAddress("10.0.0.1") in bigone
+True
+>>> IPAddress("0.0.0.0") in bigone
+True
+>>> IPAddress("255.255.255") in bigone
+True
+>>> IPNetwork("10.0.0.0/24") in bigone
+True
+>>> IPAddress("::1") in bigone
+False
+
+>>> smallone = IPSet(["10.0.0.42/32"])
+>>> IPAddress("10.0.0.42") in smallone
+True
+>>> IPAddress("10.0.0.41") in smallone
+False
+>>> IPAddress("10.0.0.43") in smallone
+False
+>>> IPNetwork("10.0.0.42/32") in smallone
+True
+>>> IPNetwork("10.0.0.42/31") in smallone
+False
+
+}}}
+
+Set union.
+
+{{{
+
+>>> IPSet(['192.0.2.0'])
+IPSet(['192.0.2.0/32'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1'])
+IPSet(['192.0.2.0/31'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3'])
+IPSet(['192.0.2.0/31', '192.0.2.3/32'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3/30'])
+IPSet(['192.0.2.0/30'])
+
+>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3/31'])
+IPSet(['192.0.2.0/30'])
+
+>>> IPSet(['192.0.2.0/24']) | IPSet(['192.0.3.0/24']) | IPSet(['192.0.4.0/24'])
+IPSet(['192.0.2.0/23', '192.0.4.0/24'])
+
+}}}
+
+A joined up example of the union, intersection and symmetric difference operations.
+
+{{{
+
+>>> adj_cidrs = list(IPNetwork('192.0.2.0/24').subnet(28))
+>>> even_cidrs = adj_cidrs[::2]
+
+>>> evens = IPSet(even_cidrs)
+>>> evens
+IPSet(['192.0.2.0/28', '192.0.2.32/28', '192.0.2.64/28', '192.0.2.96/28', '192.0.2.128/28', '192.0.2.160/28', '192.0.2.192/28', '192.0.2.224/28'])
+
+>>> IPSet(['192.0.2.0/24']) & evens
+IPSet(['192.0.2.0/28', '192.0.2.32/28', '192.0.2.64/28', '192.0.2.96/28', '192.0.2.128/28', '192.0.2.160/28', '192.0.2.192/28', '192.0.2.224/28'])
+
+>>> odds = IPSet(['192.0.2.0/24']) ^ evens
+>>> odds
+IPSet(['192.0.2.16/28', '192.0.2.48/28', '192.0.2.80/28', '192.0.2.112/28', '192.0.2.144/28', '192.0.2.176/28', '192.0.2.208/28', '192.0.2.240/28'])
+
+>>> evens | odds
+IPSet(['192.0.2.0/24'])
+
+>>> evens & odds
+IPSet([])
+
+>>> evens ^ odds
+IPSet(['192.0.2.0/24'])
+
+}}}
+
+Superset and subset tests.
+
+{{{
+
+>>> s1 = IPSet(['192.0.2.0/24', '192.0.4.0/24'])
+>>> s2 = IPSet(['192.0.2.0', '192.0.4.0'])
+
+>>> s1
+IPSet(['192.0.2.0/24', '192.0.4.0/24'])
+
+>>> s2
+IPSet(['192.0.2.0/32', '192.0.4.0/32'])
+
+>>> s1.issuperset(s2)
+True
+
+>>> s2.issubset(s1)
+True
+
+>>> s2.issuperset(s1)
+False
+
+>>> s1.issubset(s2)
+False
+
+}}}
+
+
+
+{{{
+
+>>> ipv4_addr_space = IPSet(['0.0.0.0/0'])
+
+>>> private = IPSet(['10.0.0.0/8', '172.16.0.0/12', '192.0.2.0/24', '192.168.0.0/16', '239.192.0.0/14'])
+
+>>> reserved = IPSet(['225.0.0.0/8', '226.0.0.0/7', '228.0.0.0/6', '234.0.0.0/7', '236.0.0.0/7', '238.0.0.0/8', '240.0.0.0/4'])
+
+>>> unavailable = reserved | private
+
+>>> available = ipv4_addr_space ^ unavailable
+
+>>> for cidr in available.iter_cidrs():
+...     print(cidr, cidr[0], cidr[-1])
+0.0.0.0/5 0.0.0.0 7.255.255.255
+8.0.0.0/7 8.0.0.0 9.255.255.255
+11.0.0.0/8 11.0.0.0 11.255.255.255
+12.0.0.0/6 12.0.0.0 15.255.255.255
+16.0.0.0/4 16.0.0.0 31.255.255.255
+32.0.0.0/3 32.0.0.0 63.255.255.255
+64.0.0.0/2 64.0.0.0 127.255.255.255
+128.0.0.0/3 128.0.0.0 159.255.255.255
+160.0.0.0/5 160.0.0.0 167.255.255.255
+168.0.0.0/6 168.0.0.0 171.255.255.255
+172.0.0.0/12 172.0.0.0 172.15.255.255
+172.32.0.0/11 172.32.0.0 172.63.255.255
+172.64.0.0/10 172.64.0.0 172.127.255.255
+172.128.0.0/9 172.128.0.0 172.255.255.255
+173.0.0.0/8 173.0.0.0 173.255.255.255
+174.0.0.0/7 174.0.0.0 175.255.255.255
+176.0.0.0/4 176.0.0.0 191.255.255.255
+192.0.0.0/23 192.0.0.0 192.0.1.255
+192.0.3.0/24 192.0.3.0 192.0.3.255
+192.0.4.0/22 192.0.4.0 192.0.7.255
+192.0.8.0/21 192.0.8.0 192.0.15.255
+192.0.16.0/20 192.0.16.0 192.0.31.255
+192.0.32.0/19 192.0.32.0 192.0.63.255
+192.0.64.0/18 192.0.64.0 192.0.127.255
+192.0.128.0/17 192.0.128.0 192.0.255.255
+192.1.0.0/16 192.1.0.0 192.1.255.255
+192.2.0.0/15 192.2.0.0 192.3.255.255
+192.4.0.0/14 192.4.0.0 192.7.255.255
+192.8.0.0/13 192.8.0.0 192.15.255.255
+192.16.0.0/12 192.16.0.0 192.31.255.255
+192.32.0.0/11 192.32.0.0 192.63.255.255
+192.64.0.0/10 192.64.0.0 192.127.255.255
+192.128.0.0/11 192.128.0.0 192.159.255.255
+192.160.0.0/13 192.160.0.0 192.167.255.255
+192.169.0.0/16 192.169.0.0 192.169.255.255
+192.170.0.0/15 192.170.0.0 192.171.255.255
+192.172.0.0/14 192.172.0.0 192.175.255.255
+192.176.0.0/12 192.176.0.0 192.191.255.255
+192.192.0.0/10 192.192.0.0 192.255.255.255
+193.0.0.0/8 193.0.0.0 193.255.255.255
+194.0.0.0/7 194.0.0.0 195.255.255.255
+196.0.0.0/6 196.0.0.0 199.255.255.255
+200.0.0.0/5 200.0.0.0 207.255.255.255
+208.0.0.0/4 208.0.0.0 223.255.255.255
+224.0.0.0/8 224.0.0.0 224.255.255.255
+232.0.0.0/7 232.0.0.0 233.255.255.255
+239.0.0.0/9 239.0.0.0 239.127.255.255
+239.128.0.0/10 239.128.0.0 239.191.255.255
+239.196.0.0/14 239.196.0.0 239.199.255.255
+239.200.0.0/13 239.200.0.0 239.207.255.255
+239.208.0.0/12 239.208.0.0 239.223.255.255
+239.224.0.0/11 239.224.0.0 239.255.255.255
+
+>>> ipv4_addr_space ^ available
+IPSet(['10.0.0.0/8', '172.16.0.0/12', '192.0.2.0/24', '192.168.0.0/16', '225.0.0.0/8', '226.0.0.0/7', '228.0.0.0/6', '234.0.0.0/7', '236.0.0.0/7', '238.0.0.0/8', '239.192.0.0/14', '240.0.0.0/4'])
+
+}}}
+
+==Tests on combined IPv4 and IPv6 sets==
+
+{{{
+
+>>> s1 = IPSet(['192.0.2.0', '::192.0.2.0', '192.0.2.2', '::192.0.2.2'])
+>>> s2 = IPSet(['192.0.2.2', '::192.0.2.2', '192.0.2.4', '::192.0.2.4'])
+
+IPSets with IPNetworks that need to be merged or split (sometimes multiple times) during various set operations.
+IPNetwork('10.0.0.64/30') is the same as IPRange('10.0.0.64', '10.0.0.67')
+>>> s3 = IPSet(['0.0.0.1', '10.0.0.64/30', '255.255.255.1'])
+>>> s4 = IPSet(['10.0.0.64', '10.0.0.66'])
+>>> s4b = IPSet(['10.0.0.64', '10.0.0.66', '111.111.111.111'])
+>>> s5 = IPSet(['10.0.0.65', '10.0.0.67'])
+
+>>> s1
+IPSet(['192.0.2.0/32', '192.0.2.2/32', '::192.0.2.0/128', '::192.0.2.2/128'])
+
+>>> s2
+IPSet(['192.0.2.2/32', '192.0.2.4/32', '::192.0.2.2/128', '::192.0.2.4/128'])
+
+}}}
+
+Set union.
+
+{{{
+
+>>> s1 | s2
+IPSet(['192.0.2.0/32', '192.0.2.2/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.2/128', '::192.0.2.4/128'])
+>>> s2 | s1
+IPSet(['192.0.2.0/32', '192.0.2.2/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.2/128', '::192.0.2.4/128'])
+
+}}}
+
+Set intersection.
+
+{{{
+
+>>> s1 & s2
+IPSet(['192.0.2.2/32', '::192.0.2.2/128'])
+>>> s2 & s1
+IPSet(['192.0.2.2/32', '::192.0.2.2/128'])
+
+>>> s3 & s4
+IPSet(['10.0.0.64/32', '10.0.0.66/32'])
+>>> s4 & s3
+IPSet(['10.0.0.64/32', '10.0.0.66/32'])
+
+>>> s3 & s5
+IPSet(['10.0.0.65/32', '10.0.0.67/32'])
+>>> s5 & s3
+IPSet(['10.0.0.65/32', '10.0.0.67/32'])
+
+}}}
+
+Set difference.
+
+{{{
+
+>>> s1 - s2
+IPSet(['192.0.2.0/32', '::192.0.2.0/128'])
+
+>>> s2 - s1
+IPSet(['192.0.2.4/32', '::192.0.2.4/128'])
+
+>>> s3 - s4
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+>>> s4 - s3
+IPSet([])
+>>> s3 - s4b
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+
+>>> s3 - s5
+IPSet(['0.0.0.1/32', '10.0.0.64/32', '10.0.0.66/32', '255.255.255.1/32'])
+>>> s5 - s3
+IPSet([])
+
+}}}
+
+Symmetric set difference.
+
+{{{
+
+>>> s1 ^ s2
+IPSet(['192.0.2.0/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.4/128'])
+>>> s2 ^ s1
+IPSet(['192.0.2.0/32', '192.0.2.4/32', '::192.0.2.0/128', '::192.0.2.4/128'])
+
+>>> IPSet([]) ^ IPSet([])
+IPSet([])
+>>> IPSet(['0.0.0.1/32']) ^ IPSet([])
+IPSet(['0.0.0.1/32'])
+>>> IPSet(['0.0.0.1/32']) ^ IPSet(['0.0.0.1/32'])
+IPSet([])
+
+>>> s3 ^ s4
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+>>> s4 ^ s3
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '255.255.255.1/32'])
+>>> s3 ^ s4b
+IPSet(['0.0.0.1/32', '10.0.0.65/32', '10.0.0.67/32', '111.111.111.111/32', '255.255.255.1/32'])
+
+>>> s3 ^ s5
+IPSet(['0.0.0.1/32', '10.0.0.64/32', '10.0.0.66/32', '255.255.255.1/32'])
+>>> s5 ^ s3
+IPSet(['0.0.0.1/32', '10.0.0.64/32', '10.0.0.66/32', '255.255.255.1/32'])
+
+}}}
+
+Disjointed sets.
+
+{{{
+
+>>> s1 = IPSet(['192.0.2.0', '192.0.2.1', '192.0.2.2'])
+
+>>> s2 = IPSet(['192.0.2.2', '192.0.2.3', '192.0.2.4'])
+
+>>> s1 & s2
+IPSet(['192.0.2.2/32'])
+
+>>> s1.isdisjoint(s2)
+False
+
+>>> s1 = IPSet(['192.0.2.0', '192.0.2.1'])
+
+>>> s2 = IPSet(['192.0.2.3', '192.0.2.4'])
+
+>>> s1 & s2
+IPSet([])
+
+>>> s1.isdisjoint(s2)
+True
+
+}}}
+
+Updating a set.
+
+{{{
+
+>>> s1 = IPSet(['192.0.2.0/25'])
+>>> s1
+IPSet(['192.0.2.0/25'])
+
+>>> s2 = IPSet(['192.0.2.128/25'])
+>>> s2
+IPSet(['192.0.2.128/25'])
+
+>>> s1.update(s2)
+
+>>> s1
+IPSet(['192.0.2.0/24'])
+
+>>> s1.update(['192.0.0.0/24', '192.0.1.0/24', '192.0.3.0/24'])
+>>> s1
+IPSet(['192.0.0.0/22'])
+
+>>> s2 = IPSet(['10.0.0.0/16'])
+>>> s2.update(IPRange('10.1.0.0', '10.1.255.255'))
+>>> s2
+IPSet(['10.0.0.0/15'])
+
+>>> s2.clear()
+>>> s2
+IPSet([])
+
+}}}
+
+Removing IP addresses from an IPSet.
+
+{{{
+
+>>> s1 = IPSet(['0.0.0.0/0'])
+
+>>> s1
+IPSet(['0.0.0.0/0'])
+
+>>> s1.remove('255.255.255.255')
+
+>>> s1
+IPSet(['0.0.0.0/1', '128.0.0.0/2', ..., '255.255.255.252/31', '255.255.255.254/32'])
+
+>>> list(s1.iter_cidrs())
+[IPNetwork('0.0.0.0/1'), IPNetwork('128.0.0.0/2'), ..., IPNetwork('255.255.255.252/31'), IPNetwork('255.255.255.254/32')]
+
+>>> len(list(s1.iter_cidrs()))
+32
+
+>>> list(s1.iter_cidrs()) == cidr_exclude('0.0.0.0/0', '255.255.255.255')
+True
+
+>>> s1.remove('0.0.0.0')
+
+>>> s1
+IPSet(['0.0.0.1/32', '0.0.0.2/31', ..., '255.255.255.252/31', '255.255.255.254/32'])
+
+>>> len(list(s1.iter_cidrs()))
+62
+
+}}}
+
+Adding IP address to an IPSet.
+
+{{{
+
+>>> s1.add('255.255.255.255')
+
+>>> s1
+IPSet(['0.0.0.1/32', '0.0.0.2/31', ..., '64.0.0.0/2', '128.0.0.0/1'])
+
+>>> list(s1.iter_cidrs())
+[IPNetwork('0.0.0.1/32'), IPNetwork('0.0.0.2/31'), ..., IPNetwork('64.0.0.0/2'), IPNetwork('128.0.0.0/1')]
+
+>>> len(list(s1.iter_cidrs()))
+32
+
+>>> s1.add('0.0.0.0')
+
+>>> s1
+IPSet(['0.0.0.0/0'])
+
+}}}
+
+Converting an IP set to an IP range
+
+{{{
+
+>>> s1 = IPSet(['10.0.0.0/25', '10.0.0.128/25'])                                 
+>>> s1.iprange()
+IPRange('10.0.0.0', '10.0.0.255')
+>>> s1.iscontiguous()                                                            
+True
+>>> s1.remove('10.0.0.16')                                                       
+>>> s1                                                                           
+IPSet(['10.0.0.0/28', '10.0.0.17/32', '10.0.0.18/31', '10.0.0.20/30', '10.0.0.24/29', '10.0.0.32/27', '10.0.0.64/26', '10.0.0.128/25'])
+>>> s1.iscontiguous()
+False
+>>> s1.iprange()
+Traceback (most recent call last):
+    ...
+ValueError: IPSet is not contiguous
+
+>>> list(s1.iter_ipranges())
+[IPRange('10.0.0.0', '10.0.0.15'), IPRange('10.0.0.17', '10.0.0.255')]
+
+>>> list(IPSet().iter_ipranges())
+[]
+
+>>> list(IPSet([IPAddress('10.0.0.1')]).iter_ipranges())
+[IPRange('10.0.0.1', '10.0.0.1')]
+
+Adjacent, non-mergable CIDRs must be merged by iter_ipranges().
+>>> list(IPSet([IPAddress('10.0.0.1'), IPAddress('10.0.0.2')]).iter_ipranges())
+[IPRange('10.0.0.1', '10.0.0.2')]
+
+IPv4 and IPv6 addresses must not be merged.
+>>> list(IPSet([IPAddress(1, 4), IPAddress(1, 6)]).iter_ipranges())
+[IPRange('0.0.0.1', '0.0.0.1'), IPRange('::1', '::1')]
+
+>>> s2 = IPSet(['0.0.0.0/0'])
+>>> s2.iscontiguous()
+True
+>>> s2.iprange()
+IPRange('0.0.0.0', '255.255.255.255')
+
+>>> s3 = IPSet()
+>>> s3.iscontiguous()
+True
+>>> s3.iprange()
+
+>>> s4 = IPSet(IPRange('10.0.0.0', '10.0.0.8'))
+>>> s4.iscontiguous()
+True
+
+}}}
+
+Pickling of IPSet objects
+
+{{{
+
+>>> import pickle
+>>> ip_data = IPSet(['10.0.0.0/16', 'fe80::/64'])
+>>> buf = pickle.dumps(ip_data)
+>>> ip_data_unpickled = pickle.loads(buf)
+>>> ip_data == ip_data_unpickled
+True
+
+}}}
+
+
+Compare IPSet objects
+
+{{{
+
+>>> x = IPSet(['fc00::/2'])
+>>> y = IPSet(['fc00::/3'])
+
+>>> x > y
+True
+
+>>> x < y
+False
+
+>>> x != y
+True
+
+}}}
+
+Various exceptions
+
+{{{
+
+>>> s1 = IPSet(['10.0.0.1'])
+
+>>> hash(s1)
+Traceback (most recent call last):
+TypeError: IP sets are unhashable!
+
+>>> s1.update(42)
+Traceback (most recent call last):
+TypeError: an iterable was expected!
+
+In the following cases, the exceptions are caught and translated to booleans.
+>>> s1 == 42
+False
+>>> s1 != 42
+True
+
+}}}

netaddr/tests/3.x/ip/socket_fallback.txt

@@ -0,0 +1,88 @@
+=Socket Fallback Module Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.fbsocket import *
+
+}}}
+
+IPv6 '::' compression algorithm tests.
+
+{{{
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:0:0:0:0:0'))
+'::'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:0:0:0:0:A'))
+'::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:0:0:0:0:0'))
+'a::'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:A:0:0:0:0:0'))
+'a:0:a::'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:0:0:0:0:A'))
+'a::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:A:0:0:0:0:0:A'))
+'0:a::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:A:0:0:0:0:A'))
+'a:0:a::a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:A:0:0:0:A'))
+'::a:0:0:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:0:0:0:A:0:0:A'))
+'::a:0:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:0:0:A:0:A'))
+'a::a:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:0:A:0:0:A:0'))
+'a::a:0:0:a:0'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'A:0:A:0:A:0:A:0'))
+'a:0:a:0:a:0:a:0'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '0:A:0:A:0:A:0:A'))
+'0:a:0:a:0:a:0:a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, '1080:0:0:0:8:800:200C:417A'))
+'1080::8:800:200c:417a'
+
+>>> inet_ntop(AF_INET6, inet_pton(AF_INET6, 'FEDC:BA98:7654:3210:FEDC:BA98:7654:3210'))
+'fedc:ba98:7654:3210:fedc:ba98:7654:3210'
+
+}}}
+
+IPv4 failure tests
+
+{{{
+
+>>> inet_ntoa(1)
+Traceback (most recent call last):
+...
+TypeError: string type expected, not <class 'int'>
+
+
+>>> inet_ntoa('\x00')
+Traceback (most recent call last):
+...
+ValueError: invalid length of packed IP address string
+
+}}}
+
+IPv6 failure tests.
+
+{{{
+
+>>> inet_pton(AF_INET6, '::0x07f')
+Traceback (most recent call last):
+...
+ValueError: illegal IP address string '::0x07f'
+
+}}}

netaddr/tests/3.x/ip/subnet.txt

@@ -0,0 +1,108 @@
+=IP Subnet Tests=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr import *
+
+}}}
+
+Incrementing IP objects.
+
+{{{
+
+>>> ip = IPNetwork('192.0.2.0/28')
+>>> for i in range(16):
+...     str(ip)
+...     ip += 1
+'192.0.2.0/28'
+'192.0.2.16/28'
+'192.0.2.32/28'
+'192.0.2.48/28'
+'192.0.2.64/28'
+'192.0.2.80/28'
+'192.0.2.96/28'
+'192.0.2.112/28'
+'192.0.2.128/28'
+'192.0.2.144/28'
+'192.0.2.160/28'
+'192.0.2.176/28'
+'192.0.2.192/28'
+'192.0.2.208/28'
+'192.0.2.224/28'
+'192.0.2.240/28'
+
+>>> ip = IPNetwork('2001:470:1f04::/48')
+>>> for i in ip.subnet(128):
+...     print (i)
+...     break
+2001:470:1f04::/128
+
+}}}
+
+IP address and subnet sortability.
+
+{{{
+
+>>> ip_list = []
+
+>>> for subnet in IPNetwork('192.0.2.0/24').subnet(28, 3):
+...     ip_list.append(subnet)
+...     ip_list.extend([ip for ip in subnet])
+
+>>> for addr in sorted(ip_list):
+...     print('%r' % addr)
+IPNetwork('192.0.2.0/28')
+IPAddress('192.0.2.0')
+IPAddress('192.0.2.1')
+IPAddress('192.0.2.2')
+IPAddress('192.0.2.3')
+IPAddress('192.0.2.4')
+IPAddress('192.0.2.5')
+IPAddress('192.0.2.6')
+IPAddress('192.0.2.7')
+IPAddress('192.0.2.8')
+IPAddress('192.0.2.9')
+IPAddress('192.0.2.10')
+IPAddress('192.0.2.11')
+IPAddress('192.0.2.12')
+IPAddress('192.0.2.13')
+IPAddress('192.0.2.14')
+IPAddress('192.0.2.15')
+IPNetwork('192.0.2.16/28')
+IPAddress('192.0.2.16')
+IPAddress('192.0.2.17')
+IPAddress('192.0.2.18')
+IPAddress('192.0.2.19')
+IPAddress('192.0.2.20')
+IPAddress('192.0.2.21')
+IPAddress('192.0.2.22')
+IPAddress('192.0.2.23')
+IPAddress('192.0.2.24')
+IPAddress('192.0.2.25')
+IPAddress('192.0.2.26')
+IPAddress('192.0.2.27')
+IPAddress('192.0.2.28')
+IPAddress('192.0.2.29')
+IPAddress('192.0.2.30')
+IPAddress('192.0.2.31')
+IPNetwork('192.0.2.32/28')
+IPAddress('192.0.2.32')
+IPAddress('192.0.2.33')
+IPAddress('192.0.2.34')
+IPAddress('192.0.2.35')
+IPAddress('192.0.2.36')
+IPAddress('192.0.2.37')
+IPAddress('192.0.2.38')
+IPAddress('192.0.2.39')
+IPAddress('192.0.2.40')
+IPAddress('192.0.2.41')
+IPAddress('192.0.2.42')
+IPAddress('192.0.2.43')
+IPAddress('192.0.2.44')
+IPAddress('192.0.2.45')
+IPAddress('192.0.2.46')
+IPAddress('192.0.2.47')
+
+}}}

netaddr/tests/3.x/strategy/eui48.txt

@@ -0,0 +1,96 @@
+=IEEE EUI-48 Strategy Module=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.strategy.eui48 import *
+
+}}}
+
+==Basic Smoke Tests==
+
+{{{
+
+>>> b = '00000000-00001111-00011111-00010010-11100111-00110011'
+>>> i = 64945841971
+>>> t = (0x0, 0x0f, 0x1f, 0x12, 0xe7, 0x33)
+>>> s = '00-0F-1F-12-E7-33'
+>>> p = b'\x00\x0f\x1f\x12\xe73'
+
+>>> bits_to_int(b) == 64945841971
+True
+
+>>> int_to_bits(i) == b
+True
+
+>>> int_to_str(i)
+'00-0F-1F-12-E7-33'
+
+>>> int_to_words(i)
+(0, 15, 31, 18, 231, 51)
+
+>>> int_to_packed(i)
+b'\x00\x0f\x1f\x12\xe73'
+
+>>> str_to_int(s) == 64945841971
+True
+
+>>> words_to_int(t) == 64945841971
+True
+
+>>> words_to_int(list(t)) == 64945841971
+True
+
+>>> packed_to_int(p) == 64945841971
+True
+
+}}}
+
+==Smoke Tests With Alternate Dialects==
+
+{{{
+
+>>> b = '00000000:00001111:00011111:00010010:11100111:00110011'
+>>> i = 64945841971
+>>> t = (0x0, 0x0f, 0x1f, 0x12, 0xe7, 0x33)
+>>> s = '0:f:1f:12:e7:33'
+>>> p = b'\x00\x0f\x1f\x12\xe73'
+
+>>> bits_to_int(b, mac_unix) == 64945841971
+True
+
+>>> int_to_bits(i, mac_unix) == b
+True
+
+>>> int_to_str(i, mac_unix)
+'0:f:1f:12:e7:33'
+
+>>> int_to_str(i, mac_unix_expanded)
+'00:0f:1f:12:e7:33'
+
+>>> int_to_str(i, mac_cisco)
+'000f.1f12.e733'
+
+>>> int_to_str(i, mac_unix)
+'0:f:1f:12:e7:33'
+
+>>> int_to_words(i, mac_unix)
+(0, 15, 31, 18, 231, 51)
+
+>>> int_to_packed(i)
+b'\x00\x0f\x1f\x12\xe73'
+
+>>> str_to_int(s) == 64945841971
+True
+
+>>> words_to_int(t, mac_unix) == 64945841971
+True
+
+>>> words_to_int(list(t), mac_unix) == 64945841971
+True
+
+>>> packed_to_int(p) == 64945841971
+True
+
+}}}

netaddr/tests/3.x/strategy/ipv4.txt

@@ -0,0 +1,130 @@
+=IP version 4 Strategy Module=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+Uses TEST-NET references throughout, as described in RFC 3330.
+
+{{{
+
+>>> from netaddr.strategy.ipv4 import *
+
+}}}
+
+==Basic Smoke Tests==
+
+{{{
+
+>>> b = '11000000.00000000.00000010.00000001'
+>>> i = 3221225985
+>>> t = (192, 0, 2, 1)
+>>> s = '192.0.2.1'
+>>> p = b'\xc0\x00\x02\x01'
+>>> bin_val = '0b11000000000000000000001000000001'
+
+>>> bits_to_int(b) == 3221225985
+True
+
+>>> int_to_bits(i)
+'11000000.00000000.00000010.00000001'
+
+>>> int_to_str(i)
+'192.0.2.1'
+
+>>> int_to_words(i) == (192, 0, 2, 1)
+True
+
+>>> int_to_packed(i)
+b'\xc0\x00\x02\x01'
+
+>>> int_to_bin(i)
+'0b11000000000000000000001000000001'
+
+>>> int_to_bin(i)
+'0b11000000000000000000001000000001'
+
+>>> bin_to_int(bin_val) == 3221225985
+True
+
+>>> words_to_int(t) == 3221225985
+True
+
+>>> words_to_int(list(t)) == 3221225985
+True
+
+>>> packed_to_int(p) == 3221225985
+True
+
+>>> valid_bin(bin_val)
+True
+
+}}}
+
+== inet_aton() Behavioural Tests ==
+
+inet_aton() is a very old system call and is very permissive with regard to what is assume is a valid IPv4 address. Unfortunately, it is also the most widely used by system software used in software today, so netaddr supports this behaviour by default.
+
+{{{
+
+>>> str_to_int('127') == 127
+True
+
+>>> str_to_int('0x7f') == 127
+True
+
+>>> str_to_int('0177') == 127
+True
+
+>>> str_to_int('127.1') == 2130706433
+True
+
+>>> str_to_int('0x7f.1') == 2130706433
+True
+
+>>> str_to_int('0177.1') == 2130706433
+True
+
+>>> str_to_int('127.0.0.1') == 2130706433
+True
+
+}}}
+
+== inet_pton() Behavioural Tests ==
+
+inet_pton() is a newer system call that supports both IPv4 and IPv6. It is a lot more strict about what it deems to be a valid IPv4 address and doesn't support many of the features found in inet_aton() such as support for non- decimal octets, partial numbers of octets, etc.
+
+{{{
+
+>>> str_to_int('127', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '127' is not a valid IPv4 address string!
+
+>>> str_to_int('0x7f', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '0x7f' is not a valid IPv4 address string!
+
+>>> str_to_int('0177', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '0177' is not a valid IPv4 address string!
+
+>>> str_to_int('127.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '127.1' is not a valid IPv4 address string!
+
+>>> str_to_int('0x7f.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '0x7f.1' is not a valid IPv4 address string!
+
+>>> str_to_int('0177.1', flags=INET_PTON)
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '0177.1' is not a valid IPv4 address string!
+
+>>> str_to_int('127.0.0.1', flags=INET_PTON) == 2130706433
+True
+
+}}}

netaddr/tests/3.x/strategy/ipv6.txt

@@ -0,0 +1,290 @@
+=IP version 6 Strategy Module=
+
+Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+
+{{{
+
+>>> from netaddr.strategy.ipv6 import *
+
+}}}
+
+==Basic Smoke Tests==
+
+{{{
+
+>>> b = '0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:1111111111111111:1111111111111110'
+>>> i = 4294967294
+>>> t = (0, 0, 0, 0, 0, 0, 0xffff, 0xfffe)
+>>> s = '::255.255.255.254'
+>>> p = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xfe'
+
+>>> bits_to_int(b) == 4294967294
+True
+
+>>> int_to_bits(i) == b
+True
+
+>>> int_to_str(i)
+'::255.255.255.254'
+
+>>> int_to_words(i)
+(0, 0, 0, 0, 0, 0, 65535, 65534)
+
+>>> int_to_packed(i)
+b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xfe'
+
+>>> str_to_int(s) == 4294967294
+True
+
+>>> words_to_int(t) == 4294967294
+True
+
+>>> words_to_int(list(t)) == 4294967294
+True
+
+>>> packed_to_int(p) == 4294967294
+True
+
+}}}
+
+==More Specific IPv6 Tests==
+
+IPv6 string address variants that are all equivalent.
+
+{{{
+
+>>> i = 42540766411282592856903984951992014763
+>>> str_to_int('2001:0db8:0000:0000:0000:0000:1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8:0000:0000:0000::1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8:0:0:0:0:1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8:0:0::1428:57ab') == i
+True
+
+>>> str_to_int('2001:0db8::1428:57ab') == i
+True
+
+>>> str_to_int('2001:0DB8:0000:0000:0000:0000:1428:57AB') == i
+True
+
+>>> str_to_int('2001:DB8::1428:57AB') == i
+True
+
+}}}
+
+Intensive IPv6 string address validation testing.
+
+Positive tests.
+
+{{{
+
+>>> valid_addrs = (
+... #   RFC 4291
+... #   Long forms.
+... 'FEDC:BA98:7654:3210:FEDC:BA98:7654:3210',
+... '1080:0:0:0:8:800:200C:417A',   #   a unicast address
+... 'FF01:0:0:0:0:0:0:43',      	#   a multicast address
+... '0:0:0:0:0:0:0:1',          	#   the loopback address
+... '0:0:0:0:0:0:0:0',          	#   the unspecified addresses
+...
+... #   Short forms.
+... '1080::8:800:200C:417A',    	#   a unicast address
+... 'FF01::43',                 	#   a multicast address
+... '::1',                      	#   the loopback address
+... '::',                       	#   the unspecified addresses
+...
+... #   IPv4 compatible forms.
+... '::192.0.2.1',
+... '::ffff:192.0.2.1',
+... '0:0:0:0:0:0:192.0.2.1',
+... '0:0:0:0:0:FFFF:192.0.2.1',
+... '0:0:0:0:0:0:13.1.68.3',
+... '0:0:0:0:0:FFFF:129.144.52.38',
+... '::13.1.68.3',
+... '::FFFF:129.144.52.38',
+...
+... #   Other tests.
+... '1::',
+... '::ffff',
+... 'ffff::',
+... 'ffff::ffff',
+... '0:1:2:3:4:5:6:7',
+... '8:9:a:b:c:d:e:f',
+... '0:0:0:0:0:0:0:0',
+... 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
+... )
+
+>>> for addr in valid_addrs:
+...    addr, valid_str(addr) 
+('FEDC:BA98:7654:3210:FEDC:BA98:7654:3210', True)
+('1080:0:0:0:8:800:200C:417A', True)
+('FF01:0:0:0:0:0:0:43', True)
+('0:0:0:0:0:0:0:1', True)
+('0:0:0:0:0:0:0:0', True)
+('1080::8:800:200C:417A', True)
+('FF01::43', True)
+('::1', True)
+('::', True)
+('::192.0.2.1', True)
+('::ffff:192.0.2.1', True)
+('0:0:0:0:0:0:192.0.2.1', True)
+('0:0:0:0:0:FFFF:192.0.2.1', True)
+('0:0:0:0:0:0:13.1.68.3', True)
+('0:0:0:0:0:FFFF:129.144.52.38', True)
+('::13.1.68.3', True)
+('::FFFF:129.144.52.38', True)
+('1::', True)
+('::ffff', True)
+('ffff::', True)
+('ffff::ffff', True)
+('0:1:2:3:4:5:6:7', True)
+('8:9:a:b:c:d:e:f', True)
+('0:0:0:0:0:0:0:0', True)
+('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', True)
+
+}}}
+
+Negative tests.
+
+{{{
+
+>>> invalid_addrs = (
+... 'g:h:i:j:k:l:m:n',      #   bad chars.
+... '0:0:0:0:0:0:0:0:0'     #   too long,
+... '',                     #   empty string
+... #   Unexpected types.
+... [],
+... (),
+... {},
+... True,
+... False,
+... )
+
+>>> for addr in invalid_addrs:
+...    addr, valid_str(addr)
+('g:h:i:j:k:l:m:n', False)
+('0:0:0:0:0:0:0:0:0', False)
+([], False)
+((), False)
+({}, False)
+(True, False)
+(False, False)
+
+}}}
+
+String compaction tests.
+
+{{{
+
+>>> valid_addrs = {
+... #   RFC 4291
+... 'FEDC:BA98:7654:3210:FEDC:BA98:7654:3210' : 'fedc:ba98:7654:3210:fedc:ba98:7654:3210',
+... '1080:0:0:0:8:800:200C:417A' : '1080::8:800:200c:417a', #   a unicast address
+... 'FF01:0:0:0:0:0:0:43' : 'ff01::43', #   a multicast address
+... '0:0:0:0:0:0:0:1' : '::1',          #   the loopback address
+... '0:0:0:0:0:0:0:0' : '::',           #   the unspecified addresses
+... }
+
+>>> for long_form, short_form in valid_addrs.items():
+...	    int_val = str_to_int(long_form)
+...	    calc_short_form = int_to_str(int_val)
+...	    calc_short_form == short_form
+True
+True
+True
+True
+True
+
+}}}
+
+IPv6 mapped and compatible IPv4 string formatting.
+
+{{{
+
+>>> int_to_str(0xffffff)
+'::0.255.255.255'
+>>> int_to_str(0xffffffff)
+'::255.255.255.255'
+
+>>> int_to_str(0x1ffffffff)
+'::1:ffff:ffff'
+
+>>> int_to_str(0xffffffffffff)
+'::ffff:255.255.255.255'
+
+>>> int_to_str(0xfffeffffffff)
+'::fffe:ffff:ffff'
+
+>>> int_to_str(0xffffffffffff)
+'::ffff:255.255.255.255'
+
+>>> int_to_str(0xfffffffffff1)
+'::ffff:255.255.255.241'
+
+>>> int_to_str(0xfffffffffffe)
+'::ffff:255.255.255.254'
+
+>>> int_to_str(0xffffffffff00)
+'::ffff:255.255.255.0'
+
+>>> int_to_str(0xffffffff0000)
+'::ffff:255.255.0.0'
+
+>>> int_to_str(0xffffff000000)
+'::ffff:255.0.0.0'
+
+>>> int_to_str(0xffff000000)
+'::ff:ff00:0'
+
+>>> int_to_str(0xffff00000000)
+'::ffff:0.0.0.0'
+
+>>> int_to_str(0x1ffff00000000)
+'::1:ffff:0:0'
+
+>>> int_to_str(0xffff00000000)
+'::ffff:0.0.0.0'
+
+}}}
+
+== str_to_int() Behavioural Tests (legacy_mode switch) ==
+
+The legacy_mode switch on str_to_int() is for interface compatibility only and should not effect the behaviour of this method whether set to True or False.
+
+{{{
+
+>>> str_to_int('::127') == 295
+True
+
+>>> str_to_int('::0x7f')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '::0x7f' is not a valid IPv6 address string!
+
+>>> str_to_int('::0177') == 375
+True
+
+>>> str_to_int('::127.1')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '::127.1' is not a valid IPv6 address string!
+
+>>> str_to_int('::0x7f.1')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '::0x7f.1' is not a valid IPv6 address string!
+
+>>> str_to_int('::0177.1')
+Traceback (most recent call last):
+...
+netaddr.core.AddrFormatError: '::0177.1' is not a valid IPv6 address string!
+
+>>> str_to_int('::127.0.0.1') == 2130706433
+True
+
+}}}

netaddr/tests/__init__.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""Runs all netaddr unit tests."""
+
+from os.path import abspath, basename, dirname, join as pathjoin
+import sys
+import glob
+import doctest
+import unittest
+
+sys.path.insert(0, abspath(pathjoin(dirname(__file__), '..', '..')))
+
+
+def test_suite_all():
+
+    test_dirs = [
+        'ip',
+        'eui',
+        'strategy',
+        'core'
+    ]
+
+    base_path = abspath(pathjoin(dirname(__file__), '..'))
+
+    #   Select tests based on the version of the Python interpreter.
+    py_ver_dir = '2.x'
+    if sys.version_info[0] == 3:
+        py_ver_dir = '3.x'
+
+    #   Gather list of files containing tests.
+    test_files = []
+    for entry in test_dirs:
+        test_path = pathjoin(base_path, "tests", py_ver_dir, entry, "*.txt")
+        files = glob.glob(test_path)
+        test_files.extend(files)
+
+    sys.stdout.write('testdir: %s\n' % '\n'.join(test_files))
+
+    #   Add anything to the skiplist that we want to leave out.
+    skiplist = []
+
+    #   Drop platform specific tests for other platforms.
+    platform_tests = ['platform_darwin.txt', 'platform_linux2.txt', 'platform_win32.txt']
+    for platform_test in platform_tests:
+        if not sys.platform in platform_test:
+            skiplist.append(platform_test)
+
+    #   Exclude any entries from the skip list.
+    test_files = [t for t in test_files if basename(t) not in skiplist]
+
+    #   Build and return a complete unittest test suite.
+    suite = unittest.TestSuite()
+
+    for test_file in test_files:
+        doctest_suite = doctest.DocFileSuite(test_file,
+            optionflags=doctest.ELLIPSIS, module_relative=False)
+        suite.addTest(doctest_suite)
+
+    return suite
+
+
+def run():
+    runner = unittest.TextTestRunner()
+    return runner.run(test_suite_all())
+
+
+if __name__ == "__main__":
+    result = run()
+    sys.exit(not result.wasSuccessful())

netaddr/tools/netaddr

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+#-----------------------------------------------------------------------------
+#   Copyright (c) 2008-2015, David P. D. Moss. All rights reserved.
+#
+#   Released under the BSD license. See the LICENSE file for details.
+#-----------------------------------------------------------------------------
+"""an interactive shell for the netaddr library"""
+
+import os
+import sys
+import netaddr
+from netaddr import *
+
+#   aliases to save some typing ...
+from netaddr import IPAddress as IP, IPNetwork as CIDR
+from netaddr import EUI as MAC
+
+argv = sys.argv[1:]
+
+banner = "\nnetaddr shell %s - %s\n" % (netaddr.__version__, __doc__)
+exit_msg = "\nShare and enjoy!"
+rc_override = None
+
+try:
+    try:
+        # ipython >= 0.11
+        from IPython.frontend.terminal.embed import InteractiveShellEmbed
+        ipshell = InteractiveShellEmbed(banner1=banner, exit_msg=exit_msg)
+    except ImportError:
+        # ipython < 0.11
+        from IPython.Shell import IPShellEmbed
+        ipshell = IPShellEmbed(argv, banner, exit_msg, rc_override)
+except ImportError:
+    sys.stderr.write('IPython (http://ipython.scipy.org/) not found!\n')
+    sys.exit(1)
+
+ipshell()