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

udata/core/spatial/models.py

@@ -4,44 +4,41 @@ from werkzeug.utils import cached_property
 
 from udata.app import cache
 from udata.core.metrics.models import WithMetrics
-from udata.uris import endpoint_for
 from udata.i18n import _, get_locale, language
 from udata.mongo import db
+from udata.uris import endpoint_for
 
 from . import geoids
-from .constants import ADMIN_LEVEL_MIN, ADMIN_LEVEL_MAX, BASE_GRANULARITIES
+from .constants import ADMIN_LEVEL_MAX, ADMIN_LEVEL_MIN, BASE_GRANULARITIES
 
-
-__all__ = ('GeoLevel', 'GeoZone', 'SpatialCoverage', 'spatial_granularities')
+__all__ = ("GeoLevel", "GeoZone", "SpatialCoverage", "spatial_granularities")
 
 
 class GeoLevel(db.Document):
     id = db.StringField(primary_key=True)
     name = db.StringField(required=True)
-    admin_level = db.IntField(min_value=ADMIN_LEVEL_MIN,
-                              max_value=ADMIN_LEVEL_MAX,
-                              default=100)
+    admin_level = db.IntField(min_value=ADMIN_LEVEL_MIN, max_value=ADMIN_LEVEL_MAX, default=100)
 
-class GeoZoneQuerySet(db.BaseQuerySet):
 
+class GeoZoneQuerySet(db.BaseQuerySet):
     def resolve(self, geoid, id_only=False):
-        '''
+        """
         Resolve a GeoZone given a GeoID.
 
         If `id_only` is True,
         the result will be the resolved GeoID
         instead of the resolved zone.
-        '''
+        """
         level, code = geoids.parse(geoid)
         qs = self(level=level, code=code)
         if id_only:
-            qs = qs.only('id')
+            qs = qs.only("id")
         result = qs.first()
         return result.id if id_only and result else result
 
 
 class GeoZone(WithMetrics, db.Document):
-    SEPARATOR = ':'
+    SEPARATOR = ":"
 
     id = db.StringField(primary_key=True)
     slug = db.StringField(required=True)
@@ -51,11 +48,11 @@ class GeoZone(WithMetrics, db.Document):
     uri = db.StringField()
 
     meta = {
-        'indexes': [
-            'name',
-            ('level', 'code'),
+        "indexes": [
+            "name",
+            ("level", "code"),
         ],
-        'queryset_class': GeoZoneQuerySet
+        "queryset_class": GeoZoneQuerySet,
     }
 
     def __str__(self):
@@ -63,20 +60,19 @@ class GeoZone(WithMetrics, db.Document):
 
     def __html__(self):
         """In use within the admin."""
-        return '{name} <i>({code})</i>'.format(
-            name=_(self.name), code=self.code)
+        return "{name} <i>({code})</i>".format(name=_(self.name), code=self.code)
 
     @cached_property
     def level_code(self):
         """Truncated level code for the sake of readability."""
         # Either 'region', 'departement' or 'commune',
         # useful to match TERRITORY_DATASETS keys.
-        return self.id.split(':')[1]
+        return self.id.split(":")[1]
 
     @cached_property
     def level_name(self):
         """Truncated level name for the sake of readability."""
-        if self.level.startswith('fr:'):
+        if self.level.startswith("fr:"):
             return self.level[3:]
         # Keep the whole level name as a fallback (e.g. `country:fr`)
         return self.level
@@ -91,48 +87,48 @@ class GeoZone(WithMetrics, db.Document):
 
     @property
     def handled_level(self):
-        return self.level in current_app.config.get('HANDLED_LEVELS')
+        return self.level in current_app.config.get("HANDLED_LEVELS")
 
     @property
     def url(self):
-        return endpoint_for('territories.territory', territory=self)
+        return endpoint_for("territories.territory", territory=self)
 
     @property
     def external_url(self):
-        return endpoint_for('territories.territory', territory=self, _external=True)
+        return endpoint_for("territories.territory", territory=self, _external=True)
 
     def count_datasets(self):
         from udata.models import Dataset
-        self.metrics['datasets'] = Dataset.objects(spatial__zones=self.id).visible().count()
+
+        self.metrics["datasets"] = Dataset.objects(spatial__zones=self.id).visible().count()
         self.save()
 
     def toGeoJSON(self):
         return {
-            'id': self.id,
-            'type': 'Feature',
-            'properties': {
-                'slug': self.slug,
-                'name': _(self.name),
-                'code': self.code,
-                'uri': self.uri,
-                'level': self.level,
-            }
+            "id": self.id,
+            "type": "Feature",
+            "properties": {
+                "slug": self.slug,
+                "name": _(self.name),
+                "code": self.code,
+                "uri": self.uri,
+                "level": self.level,
+            },
         }
 
 
 @cache.memoize()
 def get_spatial_granularities(lang):
     with language(lang):
-        return [
-            (l.id, _(l.name)) for l in GeoLevel.objects
-        ] + [(id, str(label)) for id, label in BASE_GRANULARITIES]
+        return [(l.id, _(l.name)) for l in GeoLevel.objects] + [
+            (id, str(label)) for id, label in BASE_GRANULARITIES
+        ]
 
 
-spatial_granularities = LocalProxy(
-    lambda: get_spatial_granularities(get_locale()))
+spatial_granularities = LocalProxy(lambda: get_spatial_granularities(get_locale()))
 
 
-@cache.cached(timeout=50, key_prefix='admin_levels')
+@cache.cached(timeout=50, key_prefix="admin_levels")
 def get_spatial_admin_levels():
     return dict((l.id, l.admin_level) for l in GeoLevel.objects)
 
@@ -141,15 +137,15 @@ admin_levels = LocalProxy(get_spatial_admin_levels)
 
 
 class SpatialCoverage(db.EmbeddedDocument):
-    """Represent a spatial coverage as a list of territories and/or a geometry.
-    """
+    """Represent a spatial coverage as a list of territories and/or a geometry."""
+
     geom = db.MultiPolygonField()
     zones = db.ListField(db.ReferenceField(GeoZone))
-    granularity = db.StringField(default='other')
+    granularity = db.StringField(default="other")
 
     @property
     def granularity_label(self):
-        return dict(spatial_granularities).get(self.granularity or 'other', 'other')
+        return dict(spatial_granularities).get(self.granularity or "other", "other")
 
     @property
     def top_label(self):
@@ -168,9 +164,9 @@ class SpatialCoverage(db.EmbeddedDocument):
         return [zone for zone in self.zones if zone.handled_level]
 
     def clean(self):
-        if 'geom' in self._get_changed_fields():
+        if "geom" in self._get_changed_fields():
             if self.zones:
-                raise db.ValidationError('The spatial coverage already has a Geozone')
-        if 'zones' in self._get_changed_fields():
+                raise db.ValidationError("The spatial coverage already has a Geozone")
+        if "zones" in self._get_changed_fields():
             if self.geom:
-                raise db.ValidationError('The spatial coverage already has a Geometry')
+                raise db.ValidationError("The spatial coverage already has a Geometry")

udata/core/spatial/tasks.py

@@ -1,7 +1,8 @@
 from udata.core.spatial.models import GeoZone
 from udata.tasks import job
 
-@job('compute-geozones-metrics')
+
+@job("compute-geozones-metrics")
 def compute_geozones_metrics(self):
     for geozone in GeoZone.objects.timeout(False):
         geozone.count_datasets()

udata/core/spatial/tests/test_api.py

@@ -1,16 +1,19 @@
 from flask import url_for
 
-from udata.utils import faker
-from udata.tests.api import APITestCase
-from udata.tests.features.territories import (
-    create_geozones_fixtures, TerritoriesSettings
-)
-from udata.core.organization.factories import OrganizationFactory
 from udata.core.dataset.factories import DatasetFactory
+from udata.core.organization.factories import OrganizationFactory
 from udata.core.spatial.factories import (
-    SpatialCoverageFactory, GeoZoneFactory, GeoLevelFactory
+    GeoLevelFactory,
+    GeoZoneFactory,
+    SpatialCoverageFactory,
 )
 from udata.core.spatial.tasks import compute_geozones_metrics
+from udata.tests.api import APITestCase
+from udata.tests.features.territories import (
+    TerritoriesSettings,
+    create_geozones_fixtures,
+)
+from udata.utils import faker
 
 
 class SpatialApiTest(APITestCase):
@@ -19,151 +22,141 @@ class SpatialApiTest(APITestCase):
     def test_zones_api_one(self):
         zone = GeoZoneFactory()
 
-        url = url_for('api.zones', ids=[zone.id])
+        url = url_for("api.zones", ids=[zone.id])
         response = self.get(url)
         self.assert200(response)
 
-        self.assertEqual(len(response.json['features']), 1)
+        self.assertEqual(len(response.json["features"]), 1)
 
-        feature = response.json['features'][0]
-        self.assertEqual(feature['type'], 'Feature')
-        self.assertEqual(feature['id'], zone.id)
+        feature = response.json["features"][0]
+        self.assertEqual(feature["type"], "Feature")
+        self.assertEqual(feature["id"], zone.id)
 
-        properties = feature['properties']
-        self.assertEqual(properties['name'], zone.name)
-        self.assertEqual(properties['code'], zone.code)
-        self.assertEqual(properties['level'], zone.level)
-        self.assertEqual(properties['uri'], zone.uri)
+        properties = feature["properties"]
+        self.assertEqual(properties["name"], zone.name)
+        self.assertEqual(properties["code"], zone.code)
+        self.assertEqual(properties["level"], zone.level)
+        self.assertEqual(properties["uri"], zone.uri)
 
     def test_zones_api_many(self):
         zones = [GeoZoneFactory() for _ in range(3)]
 
-        url = url_for('api.zones', ids=zones)
+        url = url_for("api.zones", ids=zones)
         response = self.get(url)
         self.assert200(response)
 
-        self.assertEqual(len(response.json['features']), len(zones))
+        self.assertEqual(len(response.json["features"]), len(zones))
 
-        for zone, feature in zip(zones, response.json['features']):
-            self.assertEqual(feature['type'], 'Feature')
-            self.assertEqual(feature['id'], zone.id)
+        for zone, feature in zip(zones, response.json["features"]):
+            self.assertEqual(feature["type"], "Feature")
+            self.assertEqual(feature["id"], zone.id)
 
-            properties = feature['properties']
-            self.assertEqual(properties['name'], zone.name)
-            self.assertEqual(properties['code'], zone.code)
-            self.assertEqual(properties['level'], zone.level)
-            self.assertEqual(properties['uri'], zone.uri)
+            properties = feature["properties"]
+            self.assertEqual(properties["name"], zone.name)
+            self.assertEqual(properties["code"], zone.code)
+            self.assertEqual(properties["level"], zone.level)
+            self.assertEqual(properties["uri"], zone.uri)
 
     def test_suggest_zones_on_name(self):
-        '''It should suggest zones based on its name'''
+        """It should suggest zones based on its name"""
         for i in range(4):
-            GeoZoneFactory(name='name-test-{0}'.format(i)
-                           if i % 2 else faker.word())
+            GeoZoneFactory(name="name-test-{0}".format(i) if i % 2 else faker.word())
 
-        response = self.get(
-            url_for('api.suggest_zones'), qs={'q': 'name-test', 'size': '5'})
+        response = self.get(url_for("api.suggest_zones"), qs={"q": "name-test", "size": "5"})
         self.assert200(response)
 
         self.assertEqual(len(response.json), 2)
 
         for suggestion in response.json:
-            self.assertIn('id', suggestion)
-            self.assertIn('name', suggestion)
-            self.assertIn('code', suggestion)
-            self.assertIn('uri', suggestion)
-            self.assertIn('level', suggestion)
-            self.assertIn('name-test', suggestion['name'])
+            self.assertIn("id", suggestion)
+            self.assertIn("name", suggestion)
+            self.assertIn("code", suggestion)
+            self.assertIn("uri", suggestion)
+            self.assertIn("level", suggestion)
+            self.assertIn("name-test", suggestion["name"])
 
     def test_suggest_zones_sorted(self):
-        '''It should suggest zones based on its name'''
-        country_level = GeoLevelFactory(id='country', name='country', admin_level=10)
-        region_level = GeoLevelFactory(id='region', name='region', admin_level=20)
-        country_zone = GeoZoneFactory(name='name-test-country', level=country_level.id)
-        region_zone = GeoZoneFactory(name='name-test-region', level=region_level.id)
-
-        response = self.get(
-            url_for('api.suggest_zones'), qs={'q': 'name-test', 'size': '5'})
+        """It should suggest zones based on its name"""
+        country_level = GeoLevelFactory(id="country", name="country", admin_level=10)
+        region_level = GeoLevelFactory(id="region", name="region", admin_level=20)
+        country_zone = GeoZoneFactory(name="name-test-country", level=country_level.id)
+        region_zone = GeoZoneFactory(name="name-test-region", level=region_level.id)
+
+        response = self.get(url_for("api.suggest_zones"), qs={"q": "name-test", "size": "5"})
         self.assert200(response)
 
         self.assertEqual(len(response.json), 2)
-        self.assertEqual((response.json[0]['id']), country_zone.id)
-        self.assertEqual((response.json[1]['id']), region_zone.id)
+        self.assertEqual((response.json[0]["id"]), country_zone.id)
+        self.assertEqual((response.json[1]["id"]), region_zone.id)
 
     def test_suggest_zones_on_code(self):
-        '''It should suggest zones based on its code'''
+        """It should suggest zones based on its code"""
         for i in range(4):
-            GeoZoneFactory(code='code-test-{0}'.format(i)
-                           if i % 2 else faker.word())
+            GeoZoneFactory(code="code-test-{0}".format(i) if i % 2 else faker.word())
 
-        response = self.get(
-            url_for('api.suggest_zones'), qs={'q': 'code-test', 'size': '5'})
+        response = self.get(url_for("api.suggest_zones"), qs={"q": "code-test", "size": "5"})
         self.assert200(response)
 
         self.assertEqual(len(response.json), 2)
 
         for suggestion in response.json:
-            self.assertIn('id', suggestion)
-            self.assertIn('name', suggestion)
-            self.assertIn('code', suggestion)
-            self.assertIn('level', suggestion)
-            self.assertIn('uri', suggestion)
-            self.assertIn('code-test', suggestion['code'])
+            self.assertIn("id", suggestion)
+            self.assertIn("name", suggestion)
+            self.assertIn("code", suggestion)
+            self.assertIn("level", suggestion)
+            self.assertIn("uri", suggestion)
+            self.assertIn("code-test", suggestion["code"])
 
     def test_suggest_zones_no_match(self):
-        '''It should not provide zones suggestions if no match'''
+        """It should not provide zones suggestions if no match"""
         for i in range(3):
-            GeoZoneFactory(name=5 * '{0}'.format(i),
-                           code=3 * '{0}'.format(i))
+            GeoZoneFactory(name=5 * "{0}".format(i), code=3 * "{0}".format(i))
 
-        response = self.get(
-            url_for('api.suggest_zones'), qs={'q': 'xxxxxx', 'size': '5'})
+        response = self.get(url_for("api.suggest_zones"), qs={"q": "xxxxxx", "size": "5"})
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
     def test_suggest_zones_unicode(self):
-        '''It should suggest zones based on its name'''
+        """It should suggest zones based on its name"""
         for i in range(4):
-            GeoZoneFactory(name='name-testé-{0}'.format(i)
-                           if i % 2 else faker.word())
+            GeoZoneFactory(name="name-testé-{0}".format(i) if i % 2 else faker.word())
 
-        response = self.get(
-            url_for('api.suggest_zones'), qs={'q': 'name-testé', 'size': '5'})
+        response = self.get(url_for("api.suggest_zones"), qs={"q": "name-testé", "size": "5"})
         self.assert200(response)
 
         self.assertEqual(len(response.json), 2)
 
         for suggestion in response.json:
-            self.assertIn('id', suggestion)
-            self.assertIn('name', suggestion)
-            self.assertIn('code', suggestion)
-            self.assertIn('level', suggestion)
-            self.assertIn('uri', suggestion)
-            self.assertIn('name-testé', suggestion['name'])
+            self.assertIn("id", suggestion)
+            self.assertIn("name", suggestion)
+            self.assertIn("code", suggestion)
+            self.assertIn("level", suggestion)
+            self.assertIn("uri", suggestion)
+            self.assertIn("name-testé", suggestion["name"])
 
     def test_suggest_zones_empty(self):
-        '''It should not provide zones suggestion if no data is present'''
-        response = self.get(
-            url_for('api.suggest_zones'), qs={'q': 'xxxxxx', 'size': '5'})
+        """It should not provide zones suggestion if no data is present"""
+        response = self.get(url_for("api.suggest_zones"), qs={"q": "xxxxxx", "size": "5"})
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
     def test_spatial_levels(self):
         levels = [GeoLevelFactory() for _ in range(3)]
 
-        response = self.get(url_for('api.spatial_levels'))
+        response = self.get(url_for("api.spatial_levels"))
         self.assert200(response)
         self.assertEqual(len(response.json), len(levels))
 
     def test_spatial_granularities(self):
         levels = [GeoLevelFactory() for _ in range(3)]
 
-        response = self.get(url_for('api.spatial_granularities'))
+        response = self.get(url_for("api.spatial_granularities"))
         self.assert200(response)
         self.assertEqual(len(response.json), len(levels) + 2)
 
     def test_zone_datasets_empty(self):
         paca, bdr, arles = create_geozones_fixtures()
-        response = self.get(url_for('api.zone_datasets', id=paca.id))
+        response = self.get(url_for("api.zone_datasets", id=paca.id))
         self.assert200(response)
         self.assertEqual(response.json, [])
 
@@ -172,10 +165,10 @@ class SpatialApiTest(APITestCase):
         organization = OrganizationFactory()
         for _ in range(3):
             DatasetFactory(
-                organization=organization,
-                spatial=SpatialCoverageFactory(zones=[paca.id]))
+                organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])
+            )
 
-        response = self.get(url_for('api.zone_datasets', id=paca.id))
+        response = self.get(url_for("api.zone_datasets", id=paca.id))
         self.assert200(response)
         self.assertEqual(len(response.json), 3)
 
@@ -184,11 +177,10 @@ class SpatialApiTest(APITestCase):
         organization = OrganizationFactory()
         for _ in range(3):
             DatasetFactory(
-                organization=organization,
-                spatial=SpatialCoverageFactory(zones=[paca.id]))
+                organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])
+            )
 
-        response = self.get(url_for('api.zone_datasets', id=paca.id),
-                            qs={'size': 2})
+        response = self.get(url_for("api.zone_datasets", id=paca.id), qs={"size": 2})
         self.assert200(response)
         self.assertEqual(len(response.json), 2)
 
@@ -197,11 +189,10 @@ class SpatialApiTest(APITestCase):
         organization = OrganizationFactory()
         for _ in range(3):
             DatasetFactory(
-                organization=organization,
-                spatial=SpatialCoverageFactory(zones=[paca.id]))
+                organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])
+            )
 
-        response = self.get(
-            url_for('api.zone_datasets', id=paca.id), qs={'dynamic': 1})
+        response = self.get(url_for("api.zone_datasets", id=paca.id), qs={"dynamic": 1})
         self.assert200(response)
         # No dynamic datasets given that the setting is deactivated by default.
         self.assertEqual(len(response.json), 3)
@@ -211,49 +202,48 @@ class SpatialApiTest(APITestCase):
         organization = OrganizationFactory()
         for _ in range(3):
             DatasetFactory(
-                organization=organization,
-                spatial=SpatialCoverageFactory(zones=[paca.id]))
+                organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])
+            )
 
-        response = self.get(
-            url_for('api.zone_datasets', id=paca.id),
-            qs={'dynamic': 1, 'size': 2})
+        response = self.get(url_for("api.zone_datasets", id=paca.id), qs={"dynamic": 1, "size": 2})
         self.assert200(response)
         # No dynamic datasets given that the setting is deactivated by default.
         self.assertEqual(len(response.json), 2)
 
     def test_coverage_empty(self):
-        GeoLevelFactory(id='top')
-        response = self.get(url_for('api.spatial_coverage', level='top'))
+        GeoLevelFactory(id="top")
+        response = self.get(url_for("api.spatial_coverage", level="top"))
         self.assert200(response)
-        self.assertEqual(response.json, {
-            'type': 'FeatureCollection',
-            'features': [],
-        })
+        self.assertEqual(
+            response.json,
+            {
+                "type": "FeatureCollection",
+                "features": [],
+            },
+        )
 
     def test_coverage_datasets_count(self):
-        GeoLevelFactory(id='fr:commune')
+        GeoLevelFactory(id="fr:commune")
         paris = GeoZoneFactory(
-            id='fr:commune:75056', level='fr:commune',
-            name='Paris', code='75056')
+            id="fr:commune:75056", level="fr:commune", name="Paris", code="75056"
+        )
         arles = GeoZoneFactory(
-            id='fr:commune:13004', level='fr:commune',
-            name='Arles', code='13004')
+            id="fr:commune:13004", level="fr:commune", name="Arles", code="13004"
+        )
 
         for _ in range(3):
-            DatasetFactory(
-                spatial=SpatialCoverageFactory(zones=[paris.id]))
+            DatasetFactory(spatial=SpatialCoverageFactory(zones=[paris.id]))
         for _ in range(2):
-            DatasetFactory(
-                spatial=SpatialCoverageFactory(zones=[arles.id]))
-                    
+            DatasetFactory(spatial=SpatialCoverageFactory(zones=[arles.id]))
+
         compute_geozones_metrics()
 
-        response = self.get(url_for('api.spatial_coverage', level='fr:commune'))
+        response = self.get(url_for("api.spatial_coverage", level="fr:commune"))
         self.assert200(response)
-        self.assertEqual(response.json['features'][0]['id'], 'fr:commune:13004')
-        self.assertEqual(response.json['features'][0]['properties']['datasets'], 2)
-        self.assertEqual(response.json['features'][1]['id'], 'fr:commune:75056')
-        self.assertEqual(response.json['features'][1]['properties']['datasets'], 3)
+        self.assertEqual(response.json["features"][0]["id"], "fr:commune:13004")
+        self.assertEqual(response.json["features"][0]["properties"]["datasets"], 2)
+        self.assertEqual(response.json["features"][1]["id"], "fr:commune:75056")
+        self.assertEqual(response.json["features"][1]["properties"]["datasets"], 3)
 
 
 class SpatialTerritoriesApiTest(APITestCase):
@@ -265,11 +255,10 @@ class SpatialTerritoriesApiTest(APITestCase):
         organization = OrganizationFactory()
         for _ in range(3):
             DatasetFactory(
-                organization=organization,
-                spatial=SpatialCoverageFactory(zones=[paca.id]))
+                organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])
+            )
 
-        response = self.get(
-            url_for('api.zone_datasets', id=paca.id), qs={'dynamic': 1})
+        response = self.get(url_for("api.zone_datasets", id=paca.id), qs={"dynamic": 1})
         self.assert200(response)
         # No dynamic datasets given that they are added by udata-front extension.
         self.assertEqual(len(response.json), 3)
@@ -279,14 +268,10 @@ class SpatialTerritoriesApiTest(APITestCase):
         organization = OrganizationFactory()
         for _ in range(3):
             DatasetFactory(
-                organization=organization,
-                spatial=SpatialCoverageFactory(zones=[paca.id]))
-
-        response = self.get(
-            url_for('api.zone_datasets', id=paca.id), qs={
-                'dynamic': 1,
-                'size': 2
-            })
+                organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])
+            )
+
+        response = self.get(url_for("api.zone_datasets", id=paca.id), qs={"dynamic": 1, "size": 2})
         self.assert200(response)
         # No dynamic datasets given that they are added by udata-front extension.
         self.assertEqual(len(response.json), 2)