import ipaddress
import timeit


class IPv6Network2(ipaddress.IPv6Network):
    def __contains__(self, other):
        # always false if one is v4 and the other is v6.
        if self._version != other._version:
            return False
        # dealing with another network.
        if isinstance(other, ipaddress._BaseNetwork):
            return False
        else:
            # address
            return other._ip & self.netmask._ip == self.network_address._ip

class IPv4Network2(ipaddress.IPv4Network):
    def __contains__(self, other):
        # always false if one is v4 and the other is v6.
        if self._version != other._version:
            return False
        # dealing with another network.
        if isinstance(other, ipaddress._BaseNetwork):
            return False
        # dealing with another address
        else:
            # address
            return other._ip & self.netmask._ip == self.network_address._ip

ipv6_test_net = ipaddress.IPv6Network("::/0")
ipv6_test_net2 = IPv6Network2("::/0")
ipv4_test_net = ipaddress.IPv4Network("0.0.0.0/0")
ipv4_test_net2 = IPv4Network2("0.0.0.0/0")

dataipv6 = list()
dataipv4 = list()
for x in range(2000000):
    dataipv6.append(ipaddress.IPv6Address(x))
    dataipv4.append(ipaddress.IPv4Address(x))

def test():
    for d in dataipv6:
        d in ipv6_test_net

def test2():
    for d in dataipv6:
        d in ipv6_test_net2

def test3():
    for d in dataipv4:
        d in ipv4_test_net

def test4():
    for d in dataipv4:
        d in ipv4_test_net2

t = timeit.Timer("test()", "from __main__ import test")
print("ipv6 test origin __contains__", t.timeit(number=1))

t = timeit.Timer("test2()", "from __main__ import test2")
print("ipv6 test new __contains__", t.timeit(number=1))

t = timeit.Timer("test3()", "from __main__ import test3")
print("ipv4 test origin __contains__", t.timeit(number=1))

t = timeit.Timer("test4()", "from __main__ import test4")
print("ipv4 test new __contains__", t.timeit(number=1))

import ipaddress
import timeit

class IPv6Network2(ipaddress.IPv6Network):

    @property
    def num_addresses(self):
        return self.broadcast_address._ip - self.network_address._ip + 1

    def __hash__(self):
        return hash(self.network_address._ip ^ self.netmask._ip)

    def __eq__(self, other):
        try:
            return (self._version == other._version and
                    self.network_address == other.network_address and
                    self.netmask._ip == other.netmask._ip)
        except AttributeError:
            return NotImplemented

    def __getitem__(self, n):
        network = self.network_address._ip
        broadcast = self.broadcast_address._ip
        if n >= 0:
            if network + n > broadcast:
                raise IndexError('address out of range')
            return self._address_class(network + n)
        else:
            n += 1
            if broadcast + n < network:
                raise IndexError('address out of range')
            return self._address_class(broadcast + n)


ipv6_test_net = ipaddress.IPv6Network("::/0")
ipv6_test_net2 = IPv6Network2("::/0")

def test1_num_address():
    return ipv6_test_net.num_addresses

def test2_num_address():
    return ipv6_test_net2.num_addresses

def test1_hash_address():
    return hash(ipv6_test_net)

def test2_hash_address():
    return hash(ipv6_test_net2)

if __name__ == "__main__":
    t = timeit.Timer("test1_num_address()", "from __main__ import test1_num_address")
    print("ipv6 test num_addresses with int", t.timeit(number=1000000))

    t = timeit.Timer("test2_num_address()", "from __main__ import test2_num_address")
    print("ipv6 test num_addresses without int", t.timeit(number=1000000))

    t = timeit.Timer("test1_hash_address()", "from __main__ import test1_hash_address")
    print("ipv6 test hash with int", t.timeit(number=1000000))

    t = timeit.Timer("test2_hash_address()", "from __main__ import test2_hash_address")
    print("ipv6 test hash without int", t.timeit(number=1000000))

    t = timeit.Timer("ipv6_test_net == ipv6_test_net", "from __main__ import ipv6_test_net")
    print("ipv6 test equality with int", t.timeit(number=1000000))

    t = timeit.Timer("ipv6_test_net2 == ipv6_test_net2", "from __main__ import ipv6_test_net2")
    print("ipv6 test equality without int", t.timeit(number=1000000))

    t = timeit.Timer("ipv6_test_net[10000]", "from __main__ import ipv6_test_net")
    print("ipv6 test get item with int", t.timeit(number=1000000))

    t = timeit.Timer("ipv6_test_net2[10000]", "from __main__ import ipv6_test_net2")
    print("ipv6 test get item without int", t.timeit(number=1000000))