Only compute network when needed

This provides a significant performance boost in the case where it is
never used.

Author: oschwald

geoip2/database.py

@@ -14,7 +14,6 @@
 import geoip2
 import geoip2.models
 import geoip2.errors
-from geoip2.compat import compat_ip_network
 
 
 class Reader(object):
@@ -189,22 +188,19 @@ def _get(self, database_type, ip_address):
         if record is None:
             raise geoip2.errors.AddressNotFoundError(
                 "The address %s is not in the database." % ip_address)
-
-        network = compat_ip_network('{}/{}'.format(ip_address, prefix_len),
-                                    False)
-        return (record, network)
+        return (record, prefix_len)
 
     def _model_for(self, model_class, types, ip_address):
-        (record, network) = self._get(types, ip_address)
+        (record, prefix_len) = self._get(types, ip_address)
         traits = record.setdefault('traits', {})
         traits['ip_address'] = ip_address
-        traits['network'] = network
+        traits['prefix_len'] = prefix_len
         return model_class(record, locales=self._locales)
 
     def _flat_model_for(self, model_class, types, ip_address):
-        (record, network) = self._get(types, ip_address)
+        (record, prefix_len) = self._get(types, ip_address)
         record['ip_address'] = ip_address
-        record['network'] = network
+        record['prefix_len'] = prefix_len
         return model_class(record)
 
     def metadata(self):

geoip2/models.py

@@ -11,9 +11,11 @@
 
 """
 # pylint: disable=too-many-instance-attributes,too-few-public-methods
+import ipaddress
 from abc import ABCMeta
 
 import geoip2.records
+from geoip2.compat import compat_ip_network
 from geoip2.mixins import SimpleEquality
 
 
@@ -306,9 +308,10 @@ class SimpleModel(SimpleEquality):
     __metaclass__ = ABCMeta
 
     def __init__(self, raw):
-        self.ip_address = raw.get('ip_address')
-        self.network = raw.get('network')
         self.raw = raw
+        self._network = None
+        self._prefix_len = raw.get('prefix_len')
+        self.ip_address = raw.get('ip_address')
 
     def __repr__(self):
         # pylint: disable=no-member
@@ -317,6 +320,24 @@ def __repr__(self):
             class_name=self.__class__.__name__,
             data=str(self.raw))
 
+    @property
+    def network(self):
+        """The network for the record"""
+        # This code is duplicated for performance reasons
+        # pylint: disable=duplicate-code
+        network = self._network
+        if isinstance(network, (ipaddress.IPv4Network, ipaddress.IPv6Network)):
+            return network
+
+        ip_address = self.ip_address
+        prefix_len = self._prefix_len
+        if ip_address is None or prefix_len is None:
+            return None
+        network = compat_ip_network("{}/{}".format(ip_address, prefix_len),
+                                    False)
+        self._network = network
+        return network
+
 
 class AnonymousIP(SimpleModel):
     """Model class for the GeoIP2 Anonymous IP.

geoip2/records.py

@@ -732,12 +732,9 @@ def __init__(self,
                  ip_address=None,
                  network=None,
                  organization=None,
+                 prefix_len=None,
                  user_type=None,
                  **_):
-
-        if network is not None and not isinstance(
-                network, (ipaddress.IPv4Network, ipaddress.IPv6Network)):
-            network = compat_ip_network(network)
         self.autonomous_system_number = autonomous_system_number
         self.autonomous_system_organization = autonomous_system_organization
         self.connection_type = connection_type
@@ -751,7 +748,27 @@ def __init__(self,
         self.is_satellite_provider = is_satellite_provider
         self.is_tor_exit_node = is_tor_exit_node
         self.isp = isp
-        self.ip_address = ip_address
-        self.network = network
         self.organization = organization
         self.user_type = user_type
+        self.ip_address = ip_address
+        self._network = network
+        self._prefix_len = prefix_len
+
+    # This code is duplicated for performance reasons
+    # pylint: disable=duplicate-code
+    @property
+    def network(self):
+        """The network for the record"""
+        network = self._network
+        if isinstance(network, (ipaddress.IPv4Network, ipaddress.IPv6Network)):
+            return network
+
+        if network is None:
+            ip_address = self.ip_address
+            prefix_len = self._prefix_len
+            if ip_address is None or prefix_len is None:
+                return None
+            network = "{}/{}".format(ip_address, prefix_len)
+        network = compat_ip_network(network, False)
+        self._network = network
+        return network

tests/database_test.py

@@ -86,6 +86,9 @@ def test_asn(self):
 
         ip_address = '1.128.0.0'
         record = reader.asn(ip_address)
+
+        self.assertEqual(record, eval(repr(record)), "ASN repr can be eval'd")
+
         self.assertEqual(record.autonomous_system_number, 1221)
         self.assertEqual(record.autonomous_system_organization,
                          'Telstra Pty Ltd')
@@ -95,8 +98,6 @@ def test_asn(self):
         self.assertRegex(str(record), r'geoip2.models.ASN\(.*1\.128\.0\.0.*\)',
                          'str representation is correct')
 
-        self.assertEqual(record, eval(repr(record)), "ASN repr can be eval'd")
-
         reader.close()
 
     def test_city(self):
@@ -119,16 +120,17 @@ def test_connection_type(self):
         ip_address = '1.0.1.0'
 
         record = reader.connection_type(ip_address)
+
+        self.assertEqual(record, eval(repr(record)),
+                         "ConnectionType repr can be eval'd")
+
         self.assertEqual(record.connection_type, 'Cable/DSL')
         self.assertEqual(record.ip_address, ip_address)
         self.assertEqual(record.network, ipaddress.ip_network('1.0.1.0/24'))
 
         self.assertRegex(str(record), r'ConnectionType\(\{.*Cable/DSL.*\}\)',
                          'ConnectionType str representation is reasonable')
 
-        self.assertEqual(record, eval(repr(record)),
-                         "ConnectionType repr can be eval'd")
-
         reader.close()
 
     def test_country(self):
@@ -149,16 +151,17 @@ def test_domain(self):
 
         ip_address = '1.2.0.0'
         record = reader.domain(ip_address)
+
+        self.assertEqual(record, eval(repr(record)),
+                         "Domain repr can be eval'd")
+
         self.assertEqual(record.domain, 'maxmind.com')
         self.assertEqual(record.ip_address, ip_address)
         self.assertEqual(record.network, ipaddress.ip_network('1.2.0.0/16'))
 
         self.assertRegex(str(record), r'Domain\(\{.*maxmind.com.*\}\)',
                          'Domain str representation is reasonable')
 
-        self.assertEqual(record, eval(repr(record)),
-                         "Domain repr can be eval'd")
-
         reader.close()
 
     def test_enterprise(self):
@@ -185,6 +188,8 @@ def test_isp(self):
 
         ip_address = '1.128.0.0'
         record = reader.isp(ip_address)
+        self.assertEqual(record, eval(repr(record)), "ISP repr can be eval'd")
+
         self.assertEqual(record.autonomous_system_number, 1221)
         self.assertEqual(record.autonomous_system_organization,
                          'Telstra Pty Ltd')
@@ -196,8 +201,6 @@ def test_isp(self):
         self.assertRegex(str(record), r'ISP\(\{.*Telstra.*\}\)',
                          'ISP str representation is reasonable')
 
-        self.assertEqual(record, eval(repr(record)), "ISP repr can be eval'd")
-
         reader.close()
 
     def test_context_manager(self):