Cleanup (#96)

* Style: Run black formatter

* Peripheral: remove travis-ci from readme. Using github actions now.

Author: madisona

README.rst

@@ -99,6 +99,3 @@ When you're displaying the address back to the user, just request the map
 using the geocoordinates that were saved in your model. Maybe sometime when
 I get around to it I'll see if I can create a method that will build that
 into the model.
-
-.. |Build Status| image:: https://travis-ci.org/madisona/django-google-maps.png
-   :target: https://travis-ci.org/madisona/django-google-maps

django_google_maps/fields.py

@@ -20,14 +20,14 @@
 from django.db import models
 from django.utils.encoding import force_str
 
-__all__ = ('AddressField', 'GeoLocationField')
+__all__ = ("AddressField", "GeoLocationField")
 
 
 def typename(obj):
     """Returns the type of obj as a string. More descriptive and specific than
     type(obj), and safe for any object, unlike __class__."""
-    if hasattr(obj, '__class__'):
-        return getattr(obj, '__class__').__name__
+    if hasattr(obj, "__class__"):
+        return getattr(obj, "__class__").__name__
     else:
         return type(obj).__name__
 
@@ -57,7 +57,7 @@ def __init__(self, lat, lon=None):
     def __str__(self):
         if self.lat is not None and self.lon is not None:
             return "%s,%s" % (self.lat, self.lon)
-        return ''
+        return ""
 
     def __eq__(self, other):
         if isinstance(other, GeoPt):
@@ -69,24 +69,22 @@ def __len__(self):
     def _split_geo_point(self, geo_point):
         """splits the geo point into lat and lon"""
         try:
-            lat, lon = geo_point.split(',')
+            lat, lon = geo_point.split(",")
             return lat, lon
         except (AttributeError, ValueError):
             m = 'Expected a "lat,long" formatted string; received %s (a %s).'
-            raise exceptions.ValidationError(m % (geo_point,
-                                                  typename(geo_point)))
+            raise exceptions.ValidationError(m % (geo_point, typename(geo_point)))
 
     def _validate_geo_range(self, geo_part, range_val):
         try:
             geo_part = float(geo_part)
             if abs(geo_part) > range_val:
-                m = 'Must be between -%s and %s; received %s'
-                raise exceptions.ValidationError(m % (range_val, range_val,
-                                                      geo_part))
+                m = "Must be between -%s and %s; received %s"
+                raise exceptions.ValidationError(m % (range_val, range_val, geo_part))
         except (TypeError, ValueError):
             raise exceptions.ValidationError(
-                'Expected float, received %s (a %s).' % (geo_part,
-                                                         typename(geo_part)))
+                "Expected float, received %s (a %s)." % (geo_part, typename(geo_part))
+            )
         return geo_part
 
 
@@ -107,10 +105,11 @@ class GeoLocationField(models.CharField):
     serialized string, or if lat and lon are not valid floating points in the
     ranges [-90, 90] and [-180, 180], respectively.
     """
+
     description = "A geographical point, specified by floating-point latitude and longitude coordinates."
 
     def __init__(self, *args, **kwargs):
-        kwargs['max_length'] = 100
+        kwargs["max_length"] = 100
         super(GeoLocationField, self).__init__(*args, **kwargs)
 
     def from_db_value(self, value, *args, **kwargs):

django_google_maps/tests/test_geolocation_field.py

@@ -5,42 +5,42 @@
 
 class GeoLocationFieldTests(test.TestCase):
     def test_getting_lat_lon_from_model_given_string(self):
-        sut_create = models.Person.objects.create(geolocation='45,90')
+        sut_create = models.Person.objects.create(geolocation="45,90")
         sut = models.Person.objects.get(pk=sut_create.pk)
         self.assertEqual(45, sut.geolocation.lat)
         self.assertEqual(90, sut.geolocation.lon)
 
     def test_getting_lat_lon_from_model_given_pt(self):
-        sut_create = models.Person.objects.create(geolocation=GeoPt('45,90'))
+        sut_create = models.Person.objects.create(geolocation=GeoPt("45,90"))
         sut = models.Person.objects.get(pk=sut_create.pk)
         self.assertEqual(45, sut.geolocation.lat)
         self.assertEqual(90, sut.geolocation.lon)
 
     def test_getting_lat_lon_from_model_in_db_given_string(self):
-        sut_create = models.Person.objects.create(geolocation='45,90')
+        sut_create = models.Person.objects.create(geolocation="45,90")
         sut = models.Person.objects.get(pk=sut_create.pk)
         self.assertEqual(45, sut.geolocation.lat)
         self.assertEqual(90, sut.geolocation.lon)
 
     def test_exact_match_query(self):
-        sut = models.Person.objects.create(geolocation='45,90')
-        result = models.Person.objects.get(geolocation__exact=GeoPt('45,90'))
+        sut = models.Person.objects.create(geolocation="45,90")
+        result = models.Person.objects.get(geolocation__exact=GeoPt("45,90"))
         self.assertEqual(result, sut)
 
     def test_in_match_query(self):
-        sut = models.Person.objects.create(geolocation='45,90')
-        result = models.Person.objects.get(geolocation__in=[GeoPt('45,90')])
+        sut = models.Person.objects.create(geolocation="45,90")
+        result = models.Person.objects.get(geolocation__in=[GeoPt("45,90")])
         self.assertEqual(result, sut)
 
     def test_value_to_string_with_point(self):
-        sut = models.Person.objects.create(geolocation=GeoPt('45,90'))
+        sut = models.Person.objects.create(geolocation=GeoPt("45,90"))
         field = models.Person._meta.fields[-1]
-        self.assertEqual('45.0,90.0', field.value_to_string(sut))
+        self.assertEqual("45.0,90.0", field.value_to_string(sut))
 
     def test_value_to_string_with_string(self):
-        sut = models.Person.objects.create(geolocation='45,90')
+        sut = models.Person.objects.create(geolocation="45,90")
         field = models.Person._meta.fields[-1]
-        self.assertEqual('45.0,90.0', field.value_to_string(sut))
+        self.assertEqual("45.0,90.0", field.value_to_string(sut))
 
     def test_get_prep_value_returns_none_when_none(self):
         field = models.Person._meta.fields[-1]

django_google_maps/tests/test_geopt_field.py

@@ -37,18 +37,18 @@ def test_is_not_equal_when_comparison_is_not_GeoPt_object(self):
         self.assertNotEqual(geo_pt_1, geo_pt_2)
 
     def test_allows_GeoPt_instantiated_with_empty_string(self):
-        geo_pt = fields.GeoPt('')
+        geo_pt = fields.GeoPt("")
         self.assertEqual(None, geo_pt.lat)
         self.assertEqual(None, geo_pt.lon)
 
     def test_uses_empty_string_as_unicode_representation_for_empty_GeoPt(self):
-        geo_pt = fields.GeoPt('')
-        self.assertEqual('', force_str(geo_pt))
+        geo_pt = fields.GeoPt("")
+        self.assertEqual("", force_str(geo_pt))
 
     def test_splits_geo_point_on_comma(self):
         pt = fields.GeoPt("15.001,32.001")
-        self.assertEqual('15.001', str(pt.lat))
-        self.assertEqual('32.001', str(pt.lon))
+        self.assertEqual("15.001", str(pt.lat))
+        self.assertEqual("32.001", str(pt.lon))
 
     def test_raises_error_when_attribute_error_on_split(self):
         class Fake(object):
@@ -62,25 +62,25 @@ def test_raises_error_when_type_error_on_split(self):
             x, y = fields.GeoPt("x,x")
 
     def test_returns_float_value_when_valid_value(self):
-        geo_pt = fields.GeoPt('45.005,180')
+        geo_pt = fields.GeoPt("45.005,180")
         self.assertEqual(45.005, geo_pt.lat)
 
     def test_raises_exception_when_value_is_out_of_upper_range(self):
         with self.assertRaises(exceptions.ValidationError):
-            fields.GeoPt('180,180')
+            fields.GeoPt("180,180")
 
     def test_raises_exception_when_value_is_out_of_lower_range(self):
         with self.assertRaises(exceptions.ValidationError):
-            fields.GeoPt('-180,180')
+            fields.GeoPt("-180,180")
 
     def test_len_returns_len_of_unicode_value(self):
         geo_pt = fields.GeoPt("84,12")
         self.assertEqual(9, len(geo_pt))
 
     def test_raises_exception_not_enough_values_to_unpack(self):
         with self.assertRaises(exceptions.ValidationError):
-            fields.GeoPt('22')
+            fields.GeoPt("22")
 
     def test_raises_exception_too_many_values_to_unpack(self):
         with self.assertRaises(exceptions.ValidationError):
-            fields.GeoPt('22,50,90')
+            fields.GeoPt("22,50,90")

django_google_maps/tests/test_typename.py

@@ -4,10 +4,10 @@
 
 class TypeNameTests(test.TestCase):
     def test_simple_type_returns_type_name_as_string(self):
-        self.assertEqual('str', typename("x"))
+        self.assertEqual("str", typename("x"))
 
     def test_class_object(self):
         class X:
             pass
 
-        self.assertEqual('type', typename(X))
+        self.assertEqual("type", typename(X))

django_google_maps/tests/test_widget.py

@@ -6,22 +6,25 @@
 class WidgetTests(test.TestCase):
     def test_render_returns_xxxxxxx(self):
         widget = GoogleMapsAddressWidget()
-        results = widget.render('name', 'value', attrs={'a1': 1, 'a2': 2})
+        results = widget.render("name", "value", attrs={"a1": 1, "a2": 2})
         expected = '<input a1="1" a2="2" name="name" type="text" value="value" />'
         expected += '<div class="map_canvas_wrapper">'
         expected += '<div id="map_canvas"></div></div>'
         self.assertHTMLEqual(expected, results)
 
     def test_render_returns_blank_for_value_when_none(self):
         widget = GoogleMapsAddressWidget()
-        results = widget.render('name', None, attrs={'a1': 1, 'a2': 2})
+        results = widget.render("name", None, attrs={"a1": 1, "a2": 2})
         expected = '<input a1="1" a2="2" name="name" type="text" />'
         expected += '<div class="map_canvas_wrapper">'
         expected += '<div id="map_canvas"></div></div>'
         self.assertHTMLEqual(expected, results)
 
     def test_maps_js_uses_api_key(self):
         widget = GoogleMapsAddressWidget()
-        google_maps_js = "https://maps.google.com/maps/api/js?key={}&libraries=places".format(
-            settings.GOOGLE_MAPS_API_KEY)
+        google_maps_js = (
+            "https://maps.google.com/maps/api/js?key={}&libraries=places".format(
+                settings.GOOGLE_MAPS_API_KEY
+            )
+        )
         self.assertEqual(google_maps_js, widget.Media().js[1])

django_google_maps/widgets.py

@@ -4,15 +4,15 @@
 
 class GoogleMapsAddressWidget(widgets.TextInput):
     """a widget that will place a google map right after the #id_address field"""
+
     template_name = "django_google_maps/widgets/map_widget.html"
 
     class Media:
-        css = {
-            'all': ('django_google_maps/css/google-maps-admin.css', )
-        }
+        css = {"all": ("django_google_maps/css/google-maps-admin.css",)}
         js = (
-            'https://ajax.googleapis.com/ajax/libs/jquery/3.1.0/jquery.min.js',
-            'https://maps.google.com/maps/api/js?key={}&libraries=places'.format(
-                settings.GOOGLE_MAPS_API_KEY),
-            'django_google_maps/js/google-maps-admin.js',
+            "https://ajax.googleapis.com/ajax/libs/jquery/3.1.0/jquery.min.js",
+            "https://maps.google.com/maps/api/js?key={}&libraries=places".format(
+                settings.GOOGLE_MAPS_API_KEY
+            ),
+            "django_google_maps/js/google-maps-admin.js",
         )