collapse_address_list is too slow

ipaddr.py

 #!/usr/bin/python
 #
 # Copyright 2007 Google Inc.
 #  Licensed to PSF under a Contributor Agreement.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
@@ skipping 231 matching lines @@
         IPTypeError:
             If the first and last objects are not IP addresses.
             If the first and last objects are not the same version.
         ValueError:
             If the last object is not greater than the first.
             If the version is not 4 or 6.
 
     """
 
     if not (isinstance(first, BaseIP) and isinstance(last, BaseIP)):
-        raise IPTypeError("first and last must be IP addresses not networks.")
+        raise IPTypeError("first and last must be IP addresses, not networks")
     if first.version != last.version:
         raise IPTypeError("IP addresses must be same version")
     if first > last:
         raise ValueError("last IP address must be greater than first")
 
     networks = []
 
     if first.version == 4:
-        ipnet = IPv4Network
-        ip = IPv4Address
+        ip = IPv4Network
     elif first.version == 6:
-        ipnet = IPv6Network
-        ip = IPv6Address
+        ip = IPv6Network
     else:
         raise ValueError("unknown IP version")
 
     ip_bits = first._max_prefixlen
+    first = first._ip
+    last = last._ip
     while first <= last:
-        nbits = _count_righthand_zero_bits(first._ip, ip_bits)
+        nbits = _count_righthand_zero_bits(first, ip_bits)
         current = None
         while nbits >= 0:
             addend = 2**nbits - 1
-            current = first._ip + addend
+            current = first + addend
             nbits -= 1
-            if ip(current) <= last:
+            if current <= last:
                 break
-        prefix = _get_prefix_length(first._ip, current, ip_bits)
-        networks.append(ipnet('%s/%s' % (first, prefix)))
-        if current == first._ALL_ONES:
+        prefix = _get_prefix_length(first, current, ip_bits)
+        net = ip(first)
+        net.prefixlen = prefix
+        networks.append(net)
+        if current == ip._ALL_ONES:
             break
-        first = ip(current + 1)
+        first = current + 1
     return networks
 
 def _collapse_address_list_recursive(addresses):
     """Loops through the addresses, collapsing concurrent netblocks.
 
     Example:
 
         ip1 = IPv4('1.1.0.0/24')
         ip2 = IPv4('1.1.1.0/24')
         ip3 = IPv4('1.1.2.0/24')
@@ skipping 42 matching lines @@
         collapse_address_list([IPv4('1.1.0.0/24'), IPv4('1.1.1.0/24')]) ->
           [IPv4('1.1.0.0/23')]
 
     Args:
         addresses: A list of IPv4 or IPv6 objects.
 
     Returns:
         A list of IPv4 or IPv6 objects depending on what we were passed.
 
     """
-    _addresses = []
     i = 0
-    ip_bits = addresses[0]._max_prefixlen
-    # filter out IP addresses, dedup, and sort
-    addrs = sorted(set([ip for ip in addresses if isinstance(ip, BaseIP)]))
-    nets = sorted(set([ip for ip in addresses if isinstance(ip, BaseNet)]))
-
-    while i < len(addrs):
-        (first, last) = _find_address_range(addrs[i:])
-        i = addrs.index(last) + 1
-        _addresses.extend(
-            [IP(ip) for ip in summarize_address_range(first, last)])
+    addrs = []
+    ips = []
+    nets = []
+    # split IP addresses and networks
+    for ip in addresses:
+        if isinstance(ip, BaseIP):
+            ips.append(ip)
+        elif ip._prefixlen == ip._max_prefixlen:
+            ips.append(ip.ip)
+        else:
+            nets.append(ip)
+    # sort and dedup
+    ips = sorted(set(ips))
+    nets = sorted(set(nets))
+        
+    while i < len(ips):
+        (first, last) = _find_address_range(ips[i:])
+        i = ips.index(last) + 1
+        addrs.extend(summarize_address_range(first, last))
 
     return _collapse_address_list_recursive(
-        sorted(_addresses + nets, key=BaseNet._get_networks_key))
+        sorted(addrs + nets, key=BaseNet._get_networks_key))
 
 # backwards compatibility
 CollapseAddrList = collapse_address_list
 
 # Test whether this Python implementation supports byte objects that
 # are not identical to str ones.
 # We need to exclude platforms where bytes == str so that we can
 # distinguish between packed representations and strings, for example
 # b'12::' (the IPv4 address 49.50.58.58) and '12::' (an IPv6 address).
 try:
@@ skipping 1411 matching lines @@
         """
         try:
             prefixlen = int(prefixlen)
         except ValueError:
             return False
         return 0 <= prefixlen <= 128
 
     # backwards compatibility
     Subnet = subnet
     Supernet = supernet