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)