Make language list weakly private and make most_specific on Subdivisions a property that always returns an object.

Author: oschwald

geoip2/records.py

@@ -28,12 +28,14 @@ class PlaceRecord(Record):
     def __init__(self, languages=None, **kwargs):
         if languages is None:
             languages = ['en']
-        object.__setattr__(self, 'languages', languages)
+        if kwargs.get('names') is None:
+            kwargs['names'] = {}
+        object.__setattr__(self, '_languages', languages)
         super(PlaceRecord, self).__init__(**kwargs)
 
     @property
     def name(self):
-        return next((self.names.get(x) for x in self.languages if x in
+        return next((self.names.get(x) for x in self._languages if x in
                      self.names), None)
 
 
@@ -208,20 +210,24 @@ class Subdivisions(tuple):
     """
     def __new__(cls, languages, *subdivisions):
         subdivisions = [Subdivision(languages, **x) for x in subdivisions]
-        return super(cls, Subdivisions).__new__(cls, subdivisions)
+        obj = super(cls, Subdivisions).__new__(cls, subdivisions)
+        obj._languages = languages
+        return obj
 
+    @property
     def most_specific(self):
         """The most specific subdivision available
 
-        :returns: The most specific (smallest) :py:class:`Subdivision`
-        :raises: :py:exc:`ValueError` if :py:class:`Subdivisions` does
-          not contain any :py:class:`Subdivision` objects
+        :returns: The most specific (smallest) :py:class:`Subdivision`. If there
+          are no :py:class:`Subdivision` objects for the response, this returns an
+          empty :py:class:`Subdivision`.
 
         """
         try:
             return self[-1]
         except IndexError:
-            raise ValueError('No subdivisions are available');
+            return Subdivision(self._languages)
+
 
 class Traits(Record):
     """ Contains data for the traits record associated with an IP address

tests/models_test.py

@@ -109,7 +109,7 @@ def test_omni_full(self):
                          {'en': 'Minnesota'}, 'div 1 names are correct')
         self.assertEqual(model.subdivisions[1].name, 'Hennepin',
                          'div 2 has correct name')
-        self.assertEqual(model.subdivisions.most_specific().iso_code, 'HP',
+        self.assertEqual(model.subdivisions.most_specific.iso_code, 'HP',
                           'subdivisions.most_specific returns HP')
 
     def test_omni_min(self):
@@ -129,9 +129,13 @@ def test_omni_min(self):
                          'geoip2.records.Location object')
         self.assertEqual(type(model.traits), geoip2.records.Traits,
                          'geoip2.records.Traits object')
-        with self.assertRaisesRegex(ValueError,
-                                    'No subdivisions are available'):
-            model.subdivisions.most_specific()
+        self.assertEqual(type(model.subdivisions.most_specific),
+                         geoip2.records.Subdivision,
+                         'geoip2.records.Subdivision object returned even'
+                         'when none are available.')
+        self.assertEqual(model.subdivisions.most_specific.names, {},
+                         'Empty names hash returned')
+
 
     def test_city_full(self):
         raw = {