Python ipaddress 模块，AddressValueError() 实例源码

def isipv4(value):
    """
    Return whether or not given value is an IP version 4.
    If the value is an IP version 4, this function returns ``True``, otherwise ``False``.

    Examples::

        >>> isipv4('127.0.0.1')
        True

        >>> isipv4('::1')
        False

    :param value: string to validate IP version 4
    """
    try:
        ip_addr = ipaddress.IPv4Address(value)
    except ipaddress.AddressValueError:
        return False
    return ip_addr.version == 4

def isipv6(value):
    """
    Return whether or not given value is an IP version 6.
    If the value is an IP version 6, this function returns ``True``, otherwise ``False``.

    Examples::

        >>> isipv6('2001:41d0:2:a141::1')
        True

        >>> isipv6('127.0.0.1')
        False

    :param value: string to validate IP version 6
    """
    try:
        ip_addr = ipaddress.IPv6Address(value)
    except ipaddress.AddressValueError:
        return False
    return ip_addr.version == 6

def _validate_cidr_format(cidr):
    """Validate CIDR IP range
    :param str cidr:
    :return:
    :rtype: bool
    """
    try:
        ipaddress.ip_network(cidr, strict=False)
    except (ValueError, ipaddress.AddressValueError,
            ipaddress.NetmaskValueError):
        return False
    if '/' not in cidr:
        return False
    if re.search('\s', cidr):
        return False
    return True

def convert(self, value, param, ctx):
        if value.startswith('ext:'):
            ip, _, port = value[4:].partition(':')
            try:
                IPv4Address(ip.decode('UTF-8', 'ignore'))
            except AddressValueError:
                self.fail('invalid IP address: {}'.format(ip), param, ctx)
            if port:
                try:
                    port = int(port, 0)
                except ValueError:
                    self.fail('invalid port number: {}'.format(port), param, ctx)
            else:
                port = None
            return ip, port
        return super(NATChoiceType, self).convert(value, param, ctx)

def parse_autoblock(data):
        # type: (str) -> set
        def _parse(item):
            # Try to parse item as a single IP
            try:
                ipaddress.IPv4Address(item)
                return {item}
            except ipaddress.AddressValueError:
                pass

            # Try parse item as ip range: ip1-ip2
            try:
                first_ip, last_ip = [utils.ip2int(i) for i in item.split('-')]
                return {utils.int2ip(n) for n in range(first_ip, last_ip + 1)}
            except ValueError:
                raise APIError(
                    'Exclude IP\'s are expected to be in the form of '
                    '10.0.0.1,10.0.0.4 or 10.1.0.10-10.1.1.54 or both '
                    'comma-separated')

        ip_sets = (_parse(unicode(d)) for d in data.split(','))
        return reduce(operator.or_, ip_sets)

def __init__(self, cmd, addr, port, name, domainname=""):
        if cmd not in [0x1, 0x2]:
            raise ValueError("cmd should be either command or bind")

        try:
            addr = ipaddress.IPv4Address(addr)
        except ipaddress.AddressValueError:
            raise ValueError("Invalid ipaddress format for IPv4")

        if int(addr) == 1 and len(domainname) == 0:
            raise ValueError("Domain name should be specified when addr is 1")

        if not isinstance(name, string_func) or not isinstance(domainname, string_func):
            raise ValueError("name or domainname must be a unicode string")

        self.cmd = cmd
        self.port = port
        self.name = name

        if domainname:
            self.addr = ipaddress.IPv4Address(1)
        else:
            self.addr = addr

        self.domainname = domainname

def __init__(self, cmd, atyp, addr, port):
        if cmd not in REQ_COMMAND.values():
            raise ValueError("Unsupported request command {}".format(cmd))

        if atyp not in ADDR_TYPE.values():
            raise ValueError("Unsupported address type {}".format(atyp))

        if atyp == ADDR_TYPE["IPV4"]:
            try:
                addr = ipaddress.IPv4Address(addr)
            except ipaddress.AddressValueError:
                raise ValueError("Invalid ipaddress format for IPv4")
        elif atyp == ADDR_TYPE["IPV6"]:
            try:
                addr = ipaddress.IPv6Address(addr)
            except ipaddress.AddressValueError:
                raise ValueError("Invalid ipaddress format for IPv6")
        elif atyp == ADDR_TYPE["DOMAINNAME"] and not isinstance(addr, string_func):
            raise ValueError("Domain name expect to be unicode string")

        self.cmd = cmd
        self.atyp = atyp
        self.addr = addr
        self.port = port

def __init__(self, status, atyp, addr, port):
        if status not in RESP_STATUS.values():
            raise ValueError("Unsupported status code {}".format(status))

        if atyp not in ADDR_TYPE.values():
            raise ValueError("Unsupported address type {}".format(atyp))

        if atyp == ADDR_TYPE["IPV4"]:
            try:
                addr = ipaddress.IPv4Address(addr)
            except ipaddress.AddressValueError:
                raise ValueError("Invalid ipaddress format for IPv4")
        elif atyp == ADDR_TYPE["IPV6"]:
            try:
                addr = ipaddress.IPv6Address(addr)
            except ipaddress.AddressValueError:
                raise ValueError("Invalid ipaddress format for IPv6")
        elif atyp == ADDR_TYPE["DOMAINNAME"] and not isinstance(addr, string_func):
            raise ValueError("Domain name expect to be unicode string")

        self.status = status
        self.atyp = atyp
        self.addr = addr
        self.port = port

def validate_ip_address(self, address, af=6):
        if af == 4:
            try:
                ipaddress.IPv4Address(address)
                return True
            except ipaddress.AddressValueError as ex:
                logging.error(ex)
        elif af == 6:
            try:
                ipaddress.IPv6Address(address)
                return True
            except ipaddress.AddressValueError as ex:
                logging.error(ex)
        else:
            raise Exception("Invalid AF: {}".format(af))
        return False

def is_ipv4(string):
        """
        Checks if a string is a valid ip-address (v4)

        :param string: String to check
        :type string: str

        :return: True if an ip, false otherwise.
        :rtype: bool
        """

        try:
            ipaddress.IPv4Address(string)
            return True
        except ipaddress.AddressValueError:
            return False

def is_ipv6(string):
        """
        Checks if a string is a valid ip-address (v6)

        :param string: String to check
        :type string: str

        :return: True if an ipv6, false otherwise.
        :rtype: bool
        """

        try:
            ipaddress.IPv6Address(string)
            return True
        except ipaddress.AddressValueError:
            return False

def validate_ip(addr):
    """Pass-through function for validating an IPv4 address.

    Args:
        ip: (str) IP address

    Returns:
        unicode string with same address

    Raises:
        Error: if IPv4 address is not valid
    """
    try:
        return ipaddress.IPv4Address(unicode(addr)).compressed
    except ipaddress.AddressValueError as exc:
        raise Error('Invalid IPv4 address "%s"; %s' % (addr, exc))

def check_if_ipv4address(potential_address):
    """ check if ipv4address
    this is used in conjunction with the flexible parse function
    and determines if the word is an ipaddress in a smart way """

    try:
        ipaddress.IPv4Interface(potential_address)
        return True
    except ipaddress.AddressValueError:
        return False

def is_ipv6(ip_addr):
    try:
        ipaddress.IPv6Address(ip_addr)
        return True
    except ipaddress.AddressValueError:
        return False

def ip_isvalid(address):
    try: 
        ipaddress.IPv4Address(address)
        return True
    except ipaddress.AddressValueError:
        return False

def __init__(self, address):
        if not isinstance(address, basestring):
            message = "Invalid type used in IP initilization: '{}'. Must use a string"
            raise TypeError(message.format(type(address).__name__))
        if isinstance(address, str):
            address = unicode(address)
        try:
            super(IPv4Address, self).__init__(address)
        except ipaddress.AddressValueError as e:
            raise ValueError(e)

def address_builder(value):
        if isinstance(value, (basestring)):
            try:
                value = IPv4Interface(unicode(value)).network
            except AddressValueError:
                message = 'Unsupported string initialization format \'{}\''
                message = message.format(value)
                raise ValueError(message)
        elif not isinstance(value, IPv4Network):
            raise_type_exception(value, (IPv4Network, ), 'build with')
        return value

def unpack_ip_address_bytes(data_bytes, addr_type):
    '''
    Return a tuple containing the unpacked addr_type IP address string, and the
    remainder of data_bytes.
    addr_type must be either IPV4_ADDRESS_TYPE or IPV6_ADDRESS_TYPE.
    data_bytes must be at least IPV4_ADDRESS_LEN or IPV6_ADDRESS_LEN long.
    '''
    addr_len = get_addr_type_len(addr_type)
    assert len(data_bytes) >= addr_len
    if addr_type == IPV4_ADDRESS_TYPE:
        assert addr_len == IPV4_ADDRESS_LEN
        (addr_bytes, remaining_bytes) = split_field(addr_len, data_bytes)
        # Some ipaddress variants demand bytearray, others demand bytes
        try:
            addr_value = ipaddress.IPv4Address(bytearray(addr_bytes))
            return (str(addr_value), remaining_bytes)
        except ipaddress.AddressValueError:
            pass
        except UnicodeDecodeError:
            pass
        addr_value = ipaddress.IPv4Address(bytes(addr_bytes))
    elif addr_type == IPV6_ADDRESS_TYPE:
        assert addr_len == IPV6_ADDRESS_LEN
        (addr_bytes, remaining_bytes) = split_field(addr_len, data_bytes)
        try:
            addr_value = ipaddress.IPv6Address(bytearray(addr_bytes))
            return (str(addr_value), remaining_bytes)
        except ipaddress.AddressValueError:
            pass
        except UnicodeDecodeError:
            pass
        addr_value = ipaddress.IPv6Address(bytes(addr_bytes))
    else:
        raise ValueError('Unexpected address type: {}'.format(addr_type))
    return (str(addr_value), remaining_bytes)

def __next__(self):
        """Get next generated IPv6 address.

        """
        current = self.value
        if self.iterator >= self.count and self.count != 0:
            self.value = self.start_value
            self.iterator = 1
        else:
            ip = ipaddr.IPv6Address(self.value)
            try:
                hex_ip = hex(int(ip))
                part_hex_lo = hex_ip[-8:]
                part_hex_hi = hex_ip[0:-8]
                int_hex_lo = int(part_hex_lo, 16)
                int_lo = int_hex_lo + self.increment
                if int_lo > int("FFFFFFFF", 16):
                    diff = int_lo - int("FFFFFFFF", 16)
                    int_lo = int("00000000", 16) + diff
                if int_lo < int("00000000", 16):
                    diff = int_lo - int("00000000", 16)
                    int_lo = int("FFFFFFFF", 16) + diff
                part_hex_lo = hex(int_lo)[2:]
                new_ip_hex = part_hex_hi + part_hex_lo.zfill(8)
                ip = ipaddr.IPv6Address(int(new_ip_hex, 16))
                self.value = str(ip)
            except ipaddr.AddressValueError:
                self.value = self.start_value
            self.iterator += 1
        return current

def __init__(self, status, addr, port):
        if status not in {0x5a, 0x5b, 0x5c, 0x5d}:
            raise ValueError("Incorrect status code")

        self.status = status
        try:
            self.addr = ipaddress.IPv4Address(addr)
        except ipaddress.AddressValueError:
            raise ValueError("Invalid ipaddress format for IPv4")

        self.port = port

def __call__(self):
        # Remove duplicated values
        self.config['whitelist'] = list(set(self.config.get('whitelist', [])))
        self.config['blacklist'] = list(set(self.config.get('blacklist', [])))

        try:
            [
                ipaddress.ip_network(ip)
                for ip in self.config['whitelist']+self.config['blacklist']
            ]
        except (ipaddress.AddressValueError, ValueError) as err:
            raise serializers.ValidationError({
                'config': err
            })

def get_network_object(prefix):
        u = prefix.decode('utf8')
        try:
            return ipaddress.IPv4Network(u, strict=False)
        except (ValueError, ipaddress.AddressValueError, ipaddress.NetmaskValueError):
            pass
        try:
            return ipaddress.IPv6Network(u, strict=False)
        except (ValueError, ipaddress.AddressValueError, ipaddress.NetmaskValueError):
            return None

def assertAddressError(self, details, *args):
        """Ensure a clean AddressValueError"""
        return self.assertCleanError(ipaddress.AddressValueError,
                                       details, *args)

def testEmbeddedIpv4(self):
        ipv4_string = '192.168.0.1'
        ipv4 = ipaddress.IPv4Interface(ipv4_string)
        v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
        self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
        v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
        self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                          '2001:1.1.1.1:1.1.1.1')

    # Issue 67: IPv6 with embedded IPv4 address not recognized.

def parse_cidr(value):
    """Process cidr ranges."""
    klass = IPv4Network
    if '/' not in value:
        klass = ipaddress.ip_address
    try:
        v = klass(six.text_type(value))
    except (ipaddress.AddressValueError, ValueError):
        v = None
    return v

def validate(self, data):
        try: 
            if len(data.split('/')) != 2:
                raise ValueError('Invalid CIDR syntax')
            # need to be unicode for py27
            if sys.version_info > (3,):
                ipaddress.IPv4Network(data)
            else:
                ipaddress.IPv4Network(u'{}'.format(data))
        except (ValueError, ipaddress.AddressValueError) as e:
            raise ValidationError(e)
        return {self.field_name: data}

def normalize_tc_value(tc_obj):
    import ipaddress

    try:
        tc_obj.sanitize()
    except ipaddress.AddressValueError as e:
        logger.error(IPV6_OPTION_ERROR_MSG_FORMAT.format(e))
        sys.exit(errno.EINVAL)
    except ValueError as e:
        logger.error("{:s}: {}".format(e.__class__.__name__, e))
        sys.exit(errno.EINVAL)

def sanitize_network(network, ip_version):
    """
    :return: Network string
    :rtype: str
    :raises ValueError: if the network string is invalid.
    """

    import ipaddress

    if typepy.is_null_string(network) or network.lower() == "anywhere":
        return get_anywhere_network(ip_version)

    try:
        if ip_version == 4:
            ipaddress.IPv4Address(network)
            return network + "/32"

        if ip_version == 6:
            return ipaddress.IPv6Address(network).compressed
    except ipaddress.AddressValueError:
        pass

    # validate network str ---

    if ip_version == 4:
        return ipaddress.IPv4Network(six.text_type(network)).compressed

    if ip_version == 6:
        return ipaddress.IPv6Network(six.text_type(network)).compressed

    raise ValueError("unexpected ip version: {}".format(ip_version))

def assertAddressError(self, details, *args):
        """Ensure a clean AddressValueError"""
        return self.assertCleanError(ipaddress.AddressValueError,
                                     details, *args)

def testEmbeddedIpv4(self):
        ipv4_string = '192.168.0.1'
        ipv4 = ipaddress.IPv4Interface(ipv4_string)
        v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
        self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
        v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
        self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                          '2001:1.1.1.1:1.1.1.1')

    # Issue 67: IPv6 with embedded IPv4 address not recognized.

def chose_blacklist(self, ip):
        """
        Given an IP address, figure out the ipset we have to use.

        If the address is an IPv4, we have to use *rig_blacklist4*.
        If the address is an IPv6, we have to use *rig_blacklist6*.

        Raises ipaddress.AddressValueError if the address is neither
        an IPv4 nor an IPv6.
        """
        blacklist = 'rig_blacklist{0}'

        try:
            address = ipaddress.ip_address(ip)
        except ipaddress.AddressValueError:
            raise
        else:
            if address.version is 6:
                # We don't ban private IPv6:
                if address.is_private:
                    msg = "We don't ban private addresses ({0} given)." \
                          .format(address)
                    raise ipaddress.AddressValueError(msg)
                else:
                    # Do we have an embedded IPv4 ?
                    if address.ipv4_mapped is not None:
                        address = address.ipv4_mapped
                    elif address.sixtofour is not None:
                        address = address.sixtofour

        blacklist = blacklist.format(address.version)

        return (address, blacklist)

def get_client_ip(request):
    ip = get_real_ip(request)

    if ip:
        try:
            interface = ipaddress.IPv6Interface('%s/%i' % (ip, settings.IPV6_PRIVACY_MASK))
        except ipaddress.AddressValueError:
            interface = ipaddress.IPv4Interface('%s/%i' % (ip, settings.IPV4_PRIVACY_MASK))

        return str(interface.network.network_address)
    else:
        return None

def assertAddressError(self, details, *args):
        """Ensure a clean AddressValueError"""
        return self.assertCleanError(ipaddress.AddressValueError,
                                       details, *args)

def testEmbeddedIpv4(self):
        ipv4_string = '192.168.0.1'
        ipv4 = ipaddress.IPv4Interface(ipv4_string)
        v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
        self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
        v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
        self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
        self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
                          '2001:1.1.1.1:1.1.1.1')

    # Issue 67: IPv6 with embedded IPv4 address not recognized.

def __call__(self, value):
        try:
            import ipaddress
        except ImportError:
            from gluon.contrib import ipaddr as ipaddress

        try:
            ip = ipaddress.IPv6Address(value.decode('utf-8'))
            ok = True
        except ipaddress.AddressValueError:
            return (value, translate(self.error_message))

        if self.subnets:
            # iterate through self.subnets to see if value is a member
            ok = False
            if isinstance(self.subnets, str):
                self.subnets = [self.subnets]
            for network in self.subnets:
                try:
                    ipnet = ipaddress.IPv6Network(network.decode('utf-8'))
                except (ipaddress.NetmaskValueError, ipaddress.AddressValueError):
                    return (value, translate('invalid subnet provided'))
                if ip in ipnet:
                    ok = True

        if self.is_routeable:
            self.is_private = False
            self.is_link_local = False
            self.is_reserved = False
            self.is_multicast = False

        if not (self.is_private is None or self.is_private ==
                ip.is_private):
            ok = False
        if not (self.is_link_local is None or self.is_link_local ==
                ip.is_link_local):
            ok = False
        if not (self.is_reserved is None or self.is_reserved ==
                ip.is_reserved):
            ok = False
        if not (self.is_multicast is None or self.is_multicast ==
                ip.is_multicast):
            ok = False
        if not (self.is_6to4 is None or self.is_6to4 ==
                ip.is_6to4):
            ok = False
        if not (self.is_teredo is None or self.is_teredo ==
                ip.is_teredo):
            ok = False

        if ok:
            return (value, None)

        return (value, translate(self.error_message))

def __call__(self, value):
        try:
            import ipaddress
        except ImportError:
            from contrib import ipaddr as ipaddress

        try:
            ip = ipaddress.IPv6Address(value)
            ok = True
        except ipaddress.AddressValueError:
            return (value, translate(self.error_message))

        if self.subnets:
            # iterate through self.subnets to see if value is a member
            ok = False
            if isinstance(self.subnets, str):
                self.subnets = [self.subnets]
            for network in self.subnets:
                try:
                    ipnet = ipaddress.IPv6Network(network)
                except (ipaddress.NetmaskValueError, ipaddress.AddressValueError):
                    return (value, translate('invalid subnet provided'))
                if ip in ipnet:
                    ok = True

        if self.is_routeable:
            self.is_private = False
            self.is_link_local = False
            self.is_reserved = False
            self.is_multicast = False

        if not (self.is_private is None or self.is_private ==
                ip.is_private):
            ok = False
        if not (self.is_link_local is None or self.is_link_local ==
                ip.is_link_local):
            ok = False
        if not (self.is_reserved is None or self.is_reserved ==
                ip.is_reserved):
            ok = False
        if not (self.is_multicast is None or self.is_multicast ==
                ip.is_multicast):
            ok = False
        if not (self.is_6to4 is None or self.is_6to4 ==
                ip.is_6to4):
            ok = False
        if not (self.is_teredo is None or self.is_teredo ==
                ip.is_teredo):
            ok = False

        if ok:
            return (value, None)

        return (value, translate(self.error_message))

def __call__(self, value):
        try:
            import ipaddress
        except ImportError:
            from gluon.contrib import ipaddr as ipaddress

        try:
            ip = ipaddress.IPv6Address(value.decode('utf-8'))
            ok = True
        except ipaddress.AddressValueError:
            return (value, translate(self.error_message))

        if self.subnets:
            # iterate through self.subnets to see if value is a member
            ok = False
            if isinstance(self.subnets, str):
                self.subnets = [self.subnets]
            for network in self.subnets:
                try:
                    ipnet = ipaddress.IPv6Network(network.decode('utf-8'))
                except (ipaddress.NetmaskValueError, ipaddress.AddressValueError):
                    return (value, translate('invalid subnet provided'))
                if ip in ipnet:
                    ok = True

        if self.is_routeable:
            self.is_private = False
            self.is_link_local = False
            self.is_reserved = False
            self.is_multicast = False

        if not (self.is_private is None or self.is_private ==
                ip.is_private):
            ok = False
        if not (self.is_link_local is None or self.is_link_local ==
                ip.is_link_local):
            ok = False
        if not (self.is_reserved is None or self.is_reserved ==
                ip.is_reserved):
            ok = False
        if not (self.is_multicast is None or self.is_multicast ==
                ip.is_multicast):
            ok = False
        if not (self.is_6to4 is None or self.is_6to4 ==
                ip.is_6to4):
            ok = False
        if not (self.is_teredo is None or self.is_teredo ==
                ip.is_teredo):
            ok = False

        if ok:
            return (value, None)

        return (value, translate(self.error_message))

def post(self):
        """Method to create a gateway"""
        host = self.args['host']
        name = self.args['name']
        eui = self.args['eui']
        enabled = self.args['enabled']
        power = self.args['power']

        message = {}
        # Check for required args
        required = {'host', 'name', 'eui', 'enabled', 'power'}
        for r in required:
            if self.args[r] is None:
                message[r] = "Missing the {} parameter.".format(r)
        if message:
            abort(400, message=message)

        # Ensure we have a valid address
        try:
            ipaddress.ip_address(host)
        except (ipaddress.AddressValueError, ValueError):
            message = {'error': "Invalid IP address {} ".format(host)}
            abort(400, message=message)

        # Ensure we have a valid EUI
        if not isinstance(eui, (int, long)):
            message = {'error': "Invalid gateway EUI {} ".format(eui)}
            abort(400, message=message)

        # Check this gateway does not currently exist
        exists = yield Gateway.exists(where=['host = ?', host])
        if exists:
            message = {'error': "Gateway address {} ".format(host) + \
                                 "currently exists."}
            abort(400, message=message)

        # Check the EUI does not currently exist
        exists = yield Gateway.exists(where=['eui = ?', eui])
        if exists:
            message = {'error': "Gateway EUI {} ".format(eui) + \
                                 "currently exists."}
            abort(400, message=message)

        # Create and validate
        gateway = Gateway(host=host, eui=eui, name=name, enabled=enabled, power=power)
        (valid, message) = gateway.valid()
        if not valid:
            abort(400, message=message)

        try:
            g = yield gateway.save()
            if g is None:
                abort(500, message={'error': "Error saving the gateway."})
            # Add the new gateway to the server.
            self.server.lora.addGateway(g)
            location = self.restapi.api.prefix + '/gateway/' + str(host)
            returnValue(({}, 201, {'Location': location}))
        except TimeoutError:
            # Exception returns 500 to client
            log.error("REST API timeout for gateway POST request")

def __call__(self, value):
        try:
            import ipaddress
        except ImportError:
            from gluon.contrib import ipaddr as ipaddress

        try:
            ip = ipaddress.IPv6Address(value.decode('utf-8'))
            ok = True
        except ipaddress.AddressValueError:
            return (value, translate(self.error_message))

        if self.subnets:
            # iterate through self.subnets to see if value is a member
            ok = False
            if isinstance(self.subnets, str):
                self.subnets = [self.subnets]
            for network in self.subnets:
                try:
                    ipnet = ipaddress.IPv6Network(network.decode('utf-8'))
                except (ipaddress.NetmaskValueError, ipaddress.AddressValueError):
                    return (value, translate('invalid subnet provided'))
                if ip in ipnet:
                    ok = True

        if self.is_routeable:
            self.is_private = False
            self.is_link_local = False
            self.is_reserved = False
            self.is_multicast = False

        if not (self.is_private is None or self.is_private ==
                ip.is_private):
            ok = False
        if not (self.is_link_local is None or self.is_link_local ==
                ip.is_link_local):
            ok = False
        if not (self.is_reserved is None or self.is_reserved ==
                ip.is_reserved):
            ok = False
        if not (self.is_multicast is None or self.is_multicast ==
                ip.is_multicast):
            ok = False
        if not (self.is_6to4 is None or self.is_6to4 ==
                ip.is_6to4):
            ok = False
        if not (self.is_teredo is None or self.is_teredo ==
                ip.is_teredo):
            ok = False

        if ok:
            return (value, None)

        return (value, translate(self.error_message))

def __call__(self, value):
        try:
            import ipaddress
        except ImportError:
            from gluon.contrib import ipaddr as ipaddress

        try:
            ip = ipaddress.IPv6Address(value.decode('utf-8'))
            ok = True
        except ipaddress.AddressValueError:
            return (value, translate(self.error_message))

        if self.subnets:
            # iterate through self.subnets to see if value is a member
            ok = False
            if isinstance(self.subnets, str):
                self.subnets = [self.subnets]
            for network in self.subnets:
                try:
                    ipnet = ipaddress.IPv6Network(network.decode('utf-8'))
                except (ipaddress.NetmaskValueError, ipaddress.AddressValueError):
                    return (value, translate('invalid subnet provided'))
                if ip in ipnet:
                    ok = True

        if self.is_routeable:
            self.is_private = False
            self.is_link_local = False
            self.is_reserved = False
            self.is_multicast = False

        if not (self.is_private is None or self.is_private ==
                ip.is_private):
            ok = False
        if not (self.is_link_local is None or self.is_link_local ==
                ip.is_link_local):
            ok = False
        if not (self.is_reserved is None or self.is_reserved ==
                ip.is_reserved):
            ok = False
        if not (self.is_multicast is None or self.is_multicast ==
                ip.is_multicast):
            ok = False
        if not (self.is_6to4 is None or self.is_6to4 ==
                ip.is_6to4):
            ok = False
        if not (self.is_teredo is None or self.is_teredo ==
                ip.is_teredo):
            ok = False

        if ok:
            return (value, None)

        return (value, translate(self.error_message))

def __call__(self, value):
        try:
            import ipaddress
        except ImportError:
            from gluon.contrib import ipaddr as ipaddress

        try:
            ip = ipaddress.IPv6Address(value)
            ok = True
        except ipaddress.AddressValueError:
            return (value, translate(self.error_message))

        if self.subnets:
            # iterate through self.subnets to see if value is a member
            ok = False
            if isinstance(self.subnets, str):
                self.subnets = [self.subnets]
            for network in self.subnets:
                try:
                    ipnet = ipaddress.IPv6Network(network)
                except (ipaddress.NetmaskValueError, ipaddress.AddressValueError):
                    return (value, translate('invalid subnet provided'))
                if ip in ipnet:
                    ok = True

        if self.is_routeable:
            self.is_private = False
            self.is_link_local = False
            self.is_reserved = False
            self.is_multicast = False

        if not (self.is_private is None or self.is_private ==
                ip.is_private):
            ok = False
        if not (self.is_link_local is None or self.is_link_local ==
                ip.is_link_local):
            ok = False
        if not (self.is_reserved is None or self.is_reserved ==
                ip.is_reserved):
            ok = False
        if not (self.is_multicast is None or self.is_multicast ==
                ip.is_multicast):
            ok = False
        if not (self.is_6to4 is None or self.is_6to4 ==
                ip.is_6to4):
            ok = False
        if not (self.is_teredo is None or self.is_teredo ==
                ip.is_teredo):
            ok = False

        if ok:
            return (value, None)

        return (value, translate(self.error_message))