def _parse_octet(self, octet_str):

        """Convert a decimal octet into an integer.

        Args:

            octet_str: A string, the number to parse.

        Returns:

            The octet as an integer.

        Raises:

            ValueError: if the octet isn't strictly a decimal from [0..255].

        """

        # Whitelist the characters, since int() allows a lot of bizarre stuff.

        if not self._DECIMAL_DIGITS.issuperset(octet_str):

            raise ValueError

        octet_int = int(octet_str, 10)

        # Disallow leading zeroes, because no clear standard exists on

        # whether these should be interpreted as decimal or octal.

        if octet_int > 255 or (octet_str[0] == '0' and len(octet_str) > 1):

            raise ValueError

        return octet_int

    def _string_from_ip_int(self, ip_int):

        """Turns a 32-bit integer into dotted decimal notation.

        Args:

            ip_int: An integer, the IP address.

        Returns:

            The IP address as a string in dotted decimal notation.

        """

        octets = []

        for _ in xrange(4):

            octets.insert(0, str(ip_int & 0xFF))

            ip_int >>= 8

        return '.'.join(octets)

    @property

    def max_prefixlen(self):

        return self._max_prefixlen

    @property

    def packed(self):

        """The binary representation of this address."""

        return v4_int_to_packed(self._ip)

    @property

    def version(self):

        return self._version

    @property

    def is_reserved(self):

        """Test if the address is otherwise IETF reserved.

         Returns:

             A boolean, True if the address is within the

             reserved IPv4 Network range.

        """

        return self in IPv4Network('240.0.0.0/4')

    @property

    def is_private(self):

        """Test if this address is allocated for private networks.

        Returns:

            A boolean, True if the address is reserved per RFC 1918.

        """

        return (self in IPv4Network('10.0.0.0/8') or

                self in IPv4Network('172.16.0.0/12') or

                self in IPv4Network('192.168.0.0/16'))

    @property

    def is_multicast(self):

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

        Returns:

            A boolean, True if the address is multicast.

            See RFC 3171 for details.

        """

        return self in IPv4Network('224.0.0.0/4')

    @property

    def is_unspecified(self):

        """Test if the address is unspecified.

        Returns:

            A boolean, True if this is the unspecified address as defined in

            RFC 5735 3.

        """

        return self in IPv4Network('0.0.0.0')

    @property

    def is_loopback(self):

        """Test if the address is a loopback address.

        Returns:

            A boolean, True if the address is a loopback per RFC 3330.

        """

        return self in IPv4Network('127.0.0.0/8')

    @property

    def is_link_local(self):

        """Test if the address is reserved for link-local.

        Returns:

            A boolean, True if the address is link-local per RFC 3927.

        """

        return self in IPv4Network('169.254.0.0/16')

class IPv4Address(_BaseV4, _BaseIP):

    """Represent and manipulate single IPv4 Addresses."""

    def __init__(self, address):

        """

        Args:

            address: A string or integer representing the IP

              '192.168.1.1'

              Additionally, an integer can be passed, so

              IPv4Address('192.168.1.1') == IPv4Address(3232235777).

              or, more generally

              IPv4Address(int(IPv4Address('192.168.1.1'))) ==

                IPv4Address('192.168.1.1')

        Raises:

            AddressValueError: If ipaddr isn't a valid IPv4 address.

        """

        _BaseV4.__init__(self, address)

        # Efficient constructor from integer.

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

            self._ip = address

            if address < 0 or address > self._ALL_ONES:

                raise AddressValueError(address)

            return

        # Constructing from a packed address

        if isinstance(address, Bytes):

            try:

                self._ip, = struct.unpack('!I', address)

            except struct.error:

                raise AddressValueError(address)  # Wrong length.

            return

        # Assume input argument to be string or any object representation

        # which converts into a formatted IP string.

        addr_str = str(address)

        self._ip = self._ip_int_from_string(addr_str)

class IPv4Network(_BaseV4, _BaseNet):

    """This class represents and manipulates 32-bit IPv4 networks.

    Attributes: [examples for IPv4Network('1.2.3.4/27')]

        ._ip: 16909060

        .ip: IPv4Address('1.2.3.4')

        .network: IPv4Address('1.2.3.0')

        .hostmask: IPv4Address('0.0.0.31')

        .broadcast: IPv4Address('1.2.3.31')

        .netmask: IPv4Address('255.255.255.224')

        .prefixlen: 27

    """

    # the valid octets for host and netmasks. only useful for IPv4.

    _valid_mask_octets = set((255, 254, 252, 248, 240, 224, 192, 128, 0))

    def __init__(self, address, strict=False):

        """Instantiate a new IPv4 network object.

        Args:

            address: A string or integer representing the IP [& network].

              '192.168.1.1/24'

              '192.168.1.1/255.255.255.0'

              '192.168.1.1/0.0.0.255'

              are all functionally the same in IPv4. Similarly,

              '192.168.1.1'

              '192.168.1.1/255.255.255.255'

              '192.168.1.1/32'

              provide a subnetmask will create an object with a mask of /32.

              If the mask (portion after the / in the argument) is given in

              dotted quad form, it is treated as a netmask if it starts with a

              non-zero field (e.g. /255.0.0.0 == /8) and as a hostmask if it

              starts with a zero field (e.g. 0.255.255.255 == /8), with the

              single exception of an all-zero mask which is treated as a

              netmask == /0. If no mask is given, a default of /32 is used.

              Additionally, an integer can be passed, so

              IPv4Network('192.168.1.1') == IPv4Network(3232235777).

              or, more generally

              IPv4Network(int(IPv4Network('192.168.1.1'))) ==

                IPv4Network('192.168.1.1')

            strict: A boolean. If true, ensure that we have been passed

              A true network address, eg, 192.168.1.0/24 and not an

              IP address on a network, eg, 192.168.1.1/24.

        Raises:

            AddressValueError: If ipaddr isn't a valid IPv4 address.

            NetmaskValueError: If the netmask isn't valid for

              an IPv4 address.

            ValueError: If strict was True and a network address was not

              supplied.

        """

        _BaseNet.__init__(self, address)

        _BaseV4.__init__(self, address)

        # Constructing from an integer or packed bytes.

        if isinstance(address, (int, long, Bytes)):

            self.ip = IPv4Address(address)

            self._ip = self.ip._ip

            self._prefixlen = self._max_prefixlen

            self.netmask = IPv4Address(self._ALL_ONES)

            return

        # Assume input argument to be string or any object representation

        # which converts into a formatted IP prefix string.

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

        if len(addr) > 2:

            raise AddressValueError(address)

        self._ip = self._ip_int_from_string(addr[0])

        self.ip = IPv4Address(self._ip)

        if len(addr) == 2:

            mask = addr[1].split('.')

            if len(mask) == 4:

                # We have dotted decimal netmask.

                if self._is_valid_netmask(addr[1]):

                    self.netmask = IPv4Address(self._ip_int_from_string(

                            addr[1]))

                elif self._is_hostmask(addr[1]):

                    self.netmask = IPv4Address(

                        self._ip_int_from_string(addr[1]) ^ self._ALL_ONES)

                else:

                    raise NetmaskValueError('%s is not a valid netmask'

                                                     % addr[1])

                self._prefixlen = self._prefix_from_ip_int(int(self.netmask))

            else:

                # We have a netmask in prefix length form.

                if not self._is_valid_netmask(addr[1]):

                    raise NetmaskValueError(addr[1])

                self._prefixlen = int(addr[1])

                self.netmask = IPv4Address(self._ip_int_from_prefix(

                    self._prefixlen))

        else:

            self._prefixlen = self._max_prefixlen

            self.netmask = IPv4Address(self._ip_int_from_prefix(

                self._prefixlen))

        if strict:

            if self.ip != self.network:

                raise ValueError('%s has host bits set' %

                                 self.ip)

        if self._prefixlen == (self._max_prefixlen - 1):

            self.iterhosts = self.__iter__

    def _is_hostmask(self, ip_str):

        """Test if the IP string is a hostmask (rather than a netmask).

        Args:

            ip_str: A string, the potential hostmask.

        Returns:

            A boolean, True if the IP string is a hostmask.

        """

        bits = ip_str.split('.')

        try:

            parts = [int(x) for x in bits if int(x) in self._valid_mask_octets]

        except ValueError:

            return False

        if len(parts) != len(bits):

            return False

        if parts[0] < parts[-1]:

            return True

        return False

    def _is_valid_netmask(self, netmask):

        """Verify that the netmask is valid.

        Args:

            netmask: A string, either a prefix or dotted decimal

              netmask.

        Returns:

            A boolean, True if the prefix represents a valid IPv4

            netmask.

        """

        mask = netmask.split('.')

        if len(mask) == 4:

            if [x for x in mask if int(x) not in self._valid_mask_octets]:

                return False

            if [y for idx, y in enumerate(mask) if idx > 0 and

                y > mask[idx - 1]]:

                return False

            return True

        try:

            netmask = int(netmask)

        except ValueError:

            return False

        return 0 <= netmask <= self._max_prefixlen

    # backwards compatibility

    IsRFC1918 = lambda self: self.is_private

    IsMulticast = lambda self: self.is_multicast

    IsLoopback = lambda self: self.is_loopback

    IsLinkLocal = lambda self: self.is_link_local

class _BaseV6(object):

    """Base IPv6 object.

    The following methods are used by IPv6 objects in both single IP

    addresses and networks.

    """

    _ALL_ONES = (2 ** IPV6LENGTH) - 1

    _HEXTET_COUNT = 8

    _HEX_DIGITS = frozenset('0123456789ABCDEFabcdef')

    def __init__(self, address):

        self._version = 6

        self._max_prefixlen = IPV6LENGTH

    def _ip_int_from_string(self, ip_str):

        """Turn an IPv6 ip_str into an integer.

        Args:

            ip_str: A string, the IPv6 ip_str.

        Returns:

            A long, the IPv6 ip_str.

        Raises:

            AddressValueError: if ip_str isn't a valid IPv6 Address.

        """

        parts = ip_str.split(':')

        # An IPv6 address needs at least 2 colons (3 parts).

        if len(parts) < 3:

            raise AddressValueError(ip_str)

        # If the address has an IPv4-style suffix, convert it to hexadecimal.

        if '.' in parts[-1]:

            ipv4_int = IPv4Address(parts.pop())._ip

            parts.append('%x' % ((ipv4_int >> 16) & 0xFFFF))

            parts.append('%x' % (ipv4_int & 0xFFFF))

        # An IPv6 address can't have more than 8 colons (9 parts).

        if len(parts) > self._HEXTET_COUNT + 1:

            raise AddressValueError(ip_str)

        # Disregarding the endpoints, find '::' with nothing in between.

        # This indicates that a run of zeroes has been skipped.

        try:

            skip_index, = (

                [i for i in xrange(1, len(parts) - 1) if not parts[i]] or

                [None])

        except ValueError:

            # Can't have more than one '::'

            raise AddressValueError(ip_str)

        # parts_hi is the number of parts to copy from above/before the '::'