udata 9.1.2.dev30355__py2.py3-none-any.whl → 9.1.2.dev30454__py2.py3-none-any.whl

udata/core/spatial/tests/test_fields.py

@@ -1,5 +1,4 @@
 import json
-
 from datetime import timedelta
 
 from werkzeug.datastructures import MultiDict
@@ -14,7 +13,6 @@ from ..factories import GeoZoneFactory
 from ..forms import SpatialCoverageField
 from ..models import SpatialCoverage
 
-
 A_YEAR = timedelta(days=365)
 
 
@@ -32,9 +30,9 @@ class SpatialCoverageFieldTest(TestCase):
         Fake, FakeForm = self.factory()
 
         form = FakeForm()
-        self.assertEqual(form.spatial.zones._value(), '')
+        self.assertEqual(form.spatial.zones._value(), "")
         self.assertEqual(form.spatial.zones.data, [])
-        self.assertEqual(form.spatial.granularity.data, 'other')
+        self.assertEqual(form.spatial.granularity.data, "other")
         self.assertIsNone(form.spatial.geom.data)
 
         self.assertIsNone(form.spatial.data)
@@ -57,17 +55,15 @@ class SpatialCoverageFieldTest(TestCase):
 
         fake = Fake(spatial=SpatialCoverage(zones=zones))
         form = FakeForm(None, obj=fake)
-        self.assertEqual(
-            form.spatial.zones._value(), ','.join([z.id for z in zones]))
+        self.assertEqual(form.spatial.zones._value(), ",".join([z.id for z in zones]))
 
     def test_with_zone_empty_string(self):
         Fake, FakeForm = self.factory()
 
         fake = Fake()
-        form = FakeForm(MultiDict({
-            'spatial-zones': '',
-            'spatial-granularity': faker.spatial_granularity()
-        }))
+        form = FakeForm(
+            MultiDict({"spatial-zones": "", "spatial-granularity": faker.spatial_granularity()})
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -81,10 +77,11 @@ class SpatialCoverageFieldTest(TestCase):
         zone = GeoZoneFactory()
 
         fake = Fake()
-        form = FakeForm(MultiDict({
-            'spatial-zones': zone.id,
-            'spatial-granularity': faker.spatial_granularity()
-        }))
+        form = FakeForm(
+            MultiDict(
+                {"spatial-zones": zone.id, "spatial-granularity": faker.spatial_granularity()}
+            )
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -99,12 +96,9 @@ class SpatialCoverageFieldTest(TestCase):
         zone = GeoZoneFactory()
 
         fake = Fake()
-        form = FakeForm.from_json({
-            'spatial': {
-                'zones': zone.id,
-                'granularity': faker.spatial_granularity()
-            }
-        })
+        form = FakeForm.from_json(
+            {"spatial": {"zones": zone.id, "granularity": faker.spatial_granularity()}}
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -119,10 +113,14 @@ class SpatialCoverageFieldTest(TestCase):
         zones = [GeoZoneFactory() for _ in range(3)]
 
         fake = Fake()
-        form = FakeForm(MultiDict({
-            'spatial-zones': ','.join([z.id for z in zones]),
-            'spatial-granularity': faker.spatial_granularity()
-        }))
+        form = FakeForm(
+            MultiDict(
+                {
+                    "spatial-zones": ",".join([z.id for z in zones]),
+                    "spatial-granularity": faker.spatial_granularity(),
+                }
+            )
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -140,12 +138,14 @@ class SpatialCoverageFieldTest(TestCase):
         zones = [GeoZoneFactory() for _ in range(3)]
 
         fake = Fake()
-        form = FakeForm.from_json({
-            'spatial': {
-                'zones': ','.join([z.id for z in zones]),
-                'granularity': faker.spatial_granularity()
+        form = FakeForm.from_json(
+            {
+                "spatial": {
+                    "zones": ",".join([z.id for z in zones]),
+                    "granularity": faker.spatial_granularity(),
+                }
             }
-        })
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -163,7 +163,7 @@ class SpatialCoverageFieldTest(TestCase):
         geom = faker.multipolygon()
 
         fake = Fake()
-        form = FakeForm(MultiDict({'spatial-geom': json.dumps(geom)}))
+        form = FakeForm(MultiDict({"spatial-geom": json.dumps(geom)}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -177,7 +177,7 @@ class SpatialCoverageFieldTest(TestCase):
         geom = faker.multipolygon()
 
         fake = Fake()
-        form = FakeForm.from_json({'spatial': {'geom': geom}})
+        form = FakeForm.from_json({"spatial": {"geom": geom}})
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -188,35 +188,36 @@ class SpatialCoverageFieldTest(TestCase):
 
     def test_with_invalid_geom_from_json(self):
         Fake, FakeForm = self.factory()
-        geom = {'type': 'InvalidGeoJSON', 'coordinates': []}
+        geom = {"type": "InvalidGeoJSON", "coordinates": []}
 
-        form = FakeForm.from_json({
-            'spatial': {
-                'geom': geom,
+        form = FakeForm.from_json(
+            {
+                "spatial": {
+                    "geom": geom,
+                }
             }
-        })
+        )
 
         form.validate()
-        self.assertIn('spatial', form.errors)
-        self.assertEqual(len(form.errors['spatial']), 1)
+        self.assertIn("spatial", form.errors)
+        self.assertEqual(len(form.errors["spatial"]), 1)
 
-        self.assertIn('geom', form.errors['spatial'])
-        self.assertEqual(len(form.errors['spatial']['geom']), 1)
+        self.assertIn("geom", form.errors["spatial"])
+        self.assertEqual(len(form.errors["spatial"]["geom"]), 1)
 
     def test_with_invalid_data(self):
         Fake, FakeForm = self.factory()
 
-        form = FakeForm(MultiDict({
-            'spatial-zones': 'wrong-data', 'spatial-granularity': 'wrong'}))
+        form = FakeForm(MultiDict({"spatial-zones": "wrong-data", "spatial-granularity": "wrong"}))
 
         form.validate()
-        self.assertIn('spatial', form.errors)
-        self.assertEqual(len(form.errors['spatial']), 2)
+        self.assertIn("spatial", form.errors)
+        self.assertEqual(len(form.errors["spatial"]), 2)
 
-        self.assertIn('granularity', form.errors['spatial'])
-        self.assertEqual(len(form.errors['spatial']['granularity']), 1)
-        self.assertIn('zones', form.errors['spatial'])
-        self.assertEqual(len(form.errors['spatial']['zones']), 1)
+        self.assertIn("granularity", form.errors["spatial"])
+        self.assertEqual(len(form.errors["spatial"]["granularity"]), 1)
+        self.assertIn("zones", form.errors["spatial"])
+        self.assertEqual(len(form.errors["spatial"]["zones"]), 1)
 
     def test_with_initial_zones(self):
         Fake, FakeForm = self.factory()
@@ -225,7 +226,7 @@ class SpatialCoverageFieldTest(TestCase):
         fake = Fake(spatial=SpatialCoverage(zones=zones))
 
         zone = GeoZoneFactory()
-        data = MultiDict({'spatial-zones': zone.id})
+        data = MultiDict({"spatial-zones": zone.id})
 
         form = FakeForm(data, obj=fake)
 
@@ -240,13 +241,11 @@ class SpatialCoverageFieldTest(TestCase):
     def test_with_initial_granularity(self):
         Fake, FakeForm = self.factory()
 
-        fake = Fake(spatial=SpatialCoverage(
-            granularity=faker.spatial_granularity()
-        ))
+        fake = Fake(spatial=SpatialCoverage(granularity=faker.spatial_granularity()))
 
         granularity = faker.spatial_granularity()
 
-        data = MultiDict({'spatial-granularity': granularity})
+        data = MultiDict({"spatial-granularity": granularity})
 
         form = FakeForm(data, obj=fake)
 
@@ -263,7 +262,7 @@ class SpatialCoverageFieldTest(TestCase):
 
         fake = Fake(spatial=SpatialCoverage(geom=geom))
 
-        data = {'spatial': {'geom': geom}}
+        data = {"spatial": {"geom": geom}}
 
         form = FakeForm.from_json(data, fake)
 
@@ -279,10 +278,12 @@ class SpatialCoverageFieldTest(TestCase):
         zone = GeoZoneFactory()
 
         fake = Fake(spatial=None)
-        form = FakeForm(MultiDict({
-            'spatial-zones': str(zone.id),
-            'spatial-granularity': faker.spatial_granularity()
-        }), obj=fake)
+        form = FakeForm(
+            MultiDict(
+                {"spatial-zones": str(zone.id), "spatial-granularity": faker.spatial_granularity()}
+            ),
+            obj=fake,
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -300,15 +301,12 @@ class SpatialCoverageFieldTest(TestCase):
         for i in range(3):
             GeoZoneFactory(code=zone.code)
 
-        geoid = '{0.level}:{0.code}'.format(zone)
+        geoid = "{0.level}:{0.code}".format(zone)
 
         fake = Fake()
-        form = FakeForm.from_json({
-            'spatial': {
-                'zones': [geoid],
-                'granularity': faker.spatial_granularity()
-            }
-        })
+        form = FakeForm.from_json(
+            {"spatial": {"zones": [geoid], "granularity": faker.spatial_granularity()}}
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -321,20 +319,19 @@ class SpatialCoverageFieldTest(TestCase):
     def test_resolve_zones_from_json_failure(self):
         Fake, FakeForm = self.factory()
         GeoZoneFactory.create_batch(3)
-        form = FakeForm.from_json({
-            'spatial': {
-                'zones': [
-                    '{0}:{0}@{0}'.format(faker.unique_string())
-                    for _ in range(2)
-                ],
-                'granularity': faker.spatial_granularity()
+        form = FakeForm.from_json(
+            {
+                "spatial": {
+                    "zones": ["{0}:{0}@{0}".format(faker.unique_string()) for _ in range(2)],
+                    "granularity": faker.spatial_granularity(),
+                }
             }
-        })
+        )
 
         form.validate()
 
-        self.assertIn('spatial', form.errors)
-        self.assertEqual(len(form.errors['spatial']), 1)
+        self.assertIn("spatial", form.errors)
+        self.assertEqual(len(form.errors["spatial"]), 1)
 
-        self.assertIn('zones', form.errors['spatial'])
-        self.assertEqual(len(form.errors['spatial']['zones']), 1)
+        self.assertIn("zones", form.errors["spatial"])
+        self.assertEqual(len(form.errors["spatial"]["zones"]), 1)

udata/core/spatial/tests/test_geoid.py

@@ -6,64 +6,64 @@ from ..models import GeoZone
 
 class GeoIDTest:
     def test_parse_full_geoid(self):
-        geoid = 'level:code'
+        geoid = "level:code"
 
         level, code = geoids.parse(geoid)
 
-        assert level == 'level'
-        assert code == 'code'
+        assert level == "level"
+        assert code == "code"
 
     def test_parse_legacy_geoid(self):
-        geoid = 'level/code'
+        geoid = "level/code"
 
         level, code = geoids.parse(geoid)
 
-        assert level == 'level'
-        assert code == 'code'
+        assert level == "level"
+        assert code == "code"
 
     def test_parse_implicit_latest(self):
-        geoid = 'level:code'
+        geoid = "level:code"
 
         level, code = geoids.parse(geoid)
 
-        assert level == 'level'
-        assert code == 'code'
+        assert level == "level"
+        assert code == "code"
 
     def test_parse_nested_levels(self):
-        geoid = 'nested:level:code'
+        geoid = "nested:level:code"
 
         level, code = geoids.parse(geoid)
 
-        assert level == 'nested:level'
-        assert code == 'code'
+        assert level == "nested:level"
+        assert code == "code"
 
     def test_parse_country_subset_levels(self):
-        geoid = 'country-subset:country:code'
+        geoid = "country-subset:country:code"
 
         level, code = geoids.parse(geoid)
 
-        assert level == 'country-subset'
-        assert code == 'country:code'
+        assert level == "country-subset"
+        assert code == "country:code"
 
     def test_parse_invalid_geoid(self):
-        geoid = 'this-is-not-a-geoid'
+        geoid = "this-is-not-a-geoid"
 
         with pytest.raises(geoids.GeoIDError):
             geoids.parse(geoid)
 
     def test_build(self):
-        level = 'level'
-        code = 'code'
+        level = "level"
+        code = "code"
 
         geoid = geoids.build(level, code)
 
-        assert geoid == 'level:code'
+        assert geoid == "level:code"
 
     def test_from_zone(self):
-        level = 'level'
-        code = 'code'
+        level = "level"
+        code = "code"
         zone = GeoZone(level=level, code=code)
 
         geoid = geoids.from_zone(zone)
 
-        assert geoid == 'level:code'
+        assert geoid == "level:code"

udata/core/spatial/tests/test_models.py

@@ -1,11 +1,10 @@
 from datetime import timedelta
 
-from udata.tests import TestCase, DBTestMixin
+from udata.tests import DBTestMixin, TestCase
 
-from ..factories import GeoZoneFactory, GeoLevelFactory
+from ..factories import GeoLevelFactory, GeoZoneFactory
 from ..models import GeoZone, SpatialCoverage
 
-
 A_YEAR = timedelta(days=365)
 
 
@@ -15,19 +14,18 @@ class SpacialCoverageTest(DBTestMixin, TestCase):
         self.assertIsNone(coverage.top_label)
 
     def test_top_label_single(self):
-        zone = GeoZoneFactory(name='name', level='level', code='code')
+        zone = GeoZoneFactory(name="name", level="level", code="code")
         coverage = SpatialCoverage(zones=[zone])
-        self.assertEqual(coverage.top_label, 'name')
+        self.assertEqual(coverage.top_label, "name")
 
 
 class SpatialTemporalResolutionTest(DBTestMixin, TestCase):
-
     def test_resolve_id_only(self):
         zone = GeoZoneFactory()
         for i in range(3):
             GeoZoneFactory(code=zone.code)
 
-        geoid = '{0.level}:{0.code}'.format(zone)
+        geoid = "{0.level}:{0.code}".format(zone)
         result = GeoZone.objects.resolve(geoid, id_only=True)
 
         self.assertEqual(result, zone.id)

udata/core/spatial/translations.py

@@ -2,20 +2,20 @@
 _ = lambda s: s  # noqa: force translations
 
 TRANSLATIONS = (
-    _('French region'),
-    _('French intermunicipal (EPCI)'),
-    _('French county'),
-    _('French district'),
-    _('French town'),
-    _('French canton'),
-    _('Iris (Insee districts)'),
-    _('Country'),
-    _('World'),
-    _('Country group'),
-    _('Country subset'),
-    _('European Union'),
-    _('Metropolitan France'),
-    _('Overseas France'),
-    _('French overseas collectivities'),
-    _('French arrondissement'),
+    _("French region"),
+    _("French intermunicipal (EPCI)"),
+    _("French county"),
+    _("French district"),
+    _("French town"),
+    _("French canton"),
+    _("Iris (Insee districts)"),
+    _("Country"),
+    _("World"),
+    _("Country group"),
+    _("Country subset"),
+    _("European Union"),
+    _("Metropolitan France"),
+    _("Overseas France"),
+    _("French overseas collectivities"),
+    _("French arrondissement"),
 )

udata/core/storages/__init__.py

@@ -1,43 +1,41 @@
 from datetime import date
 from uuid import uuid4
 
-from flask import current_app
-
 import flask_storage as fs
+from flask import current_app
 
 AUTHORIZED_TYPES = fs.AllExcept(fs.SCRIPTS + fs.EXECUTABLES)
 
 
 class ConfigurableAuthorizedTypes(object):
     def __contains__(self, value):
-        return value in current_app.config['ALLOWED_RESOURCES_EXTENSIONS']
+        return value in current_app.config["ALLOWED_RESOURCES_EXTENSIONS"]
 
 
 CONFIGURABLE_AUTHORIZED_TYPES = ConfigurableAuthorizedTypes()
 
 
 def tmp_upload_to():
-    uuid = str(uuid4()).replace('-', '')
+    uuid = str(uuid4()).replace("-", "")
     isodate = date.today().isoformat()
-    return '/'.join((isodate, uuid))
+    return "/".join((isodate, uuid))
 
 
-resources = fs.Storage('resources', CONFIGURABLE_AUTHORIZED_TYPES)
-avatars = fs.Storage('avatars', fs.IMAGES)
-logos = fs.Storage('logos', fs.IMAGES)
-images = fs.Storage('images', fs.IMAGES)
-chunks = fs.Storage('chunks', AUTHORIZED_TYPES)
-tmp = fs.Storage('tmp', fs.ALL, upload_to=tmp_upload_to)
-references = fs.Storage('references', AUTHORIZED_TYPES)
+resources = fs.Storage("resources", CONFIGURABLE_AUTHORIZED_TYPES)
+avatars = fs.Storage("avatars", fs.IMAGES)
+logos = fs.Storage("logos", fs.IMAGES)
+images = fs.Storage("images", fs.IMAGES)
+chunks = fs.Storage("chunks", AUTHORIZED_TYPES)
+tmp = fs.Storage("tmp", fs.ALL, upload_to=tmp_upload_to)
+references = fs.Storage("references", AUTHORIZED_TYPES)
 
 
 def default_image_basename(*args, **kwargs):
-    uuid = str(uuid4()).replace('-', '')
-    return '/'.join((uuid[:2], uuid[2:]))
+    uuid = str(uuid4()).replace("-", "")
+    return "/".join((uuid[:2], uuid[2:]))
 
 
 def init_app(app):
-    if 'BUCKETS_PREFIX' not in app.config:
-        app.config['BUCKETS_PREFIX'] = '/s'
-    fs.init_app(
-        app, resources, avatars, logos, images, chunks, tmp, references)
+    if "BUCKETS_PREFIX" not in app.config:
+        app.config["BUCKETS_PREFIX"] = "/s"
+    fs.init_app(app, resources, avatars, logos, images, chunks, tmp, references)