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

udata/core/spatial/api.py

@@ -1,64 +1,60 @@
 import re
-from mongoengine.queryset.visitor import Q
 
 from flask_restx import inputs
+from mongoengine.queryset.visitor import Q
 
-from udata.api import api, API
+from udata.api import API, api
+from udata.core.dataset.api_fields import dataset_ref_fields
 from udata.i18n import _
 from udata.models import Dataset
-from udata.core.dataset.api_fields import dataset_ref_fields
 
 from .api_fields import (
-    level_fields,
-    granularity_fields,
     feature_collection_fields,
-    zone_suggestion_fields
+    granularity_fields,
+    level_fields,
+    zone_suggestion_fields,
 )
-from .models import GeoZone, GeoLevel, spatial_granularities
+from .models import GeoLevel, GeoZone, spatial_granularities
 
-
-GEOM_TYPES = (
-    'Point', 'LineString', 'Polygon', 'MultiPoint', 'MultiLineString',
-    'MultiPolygon'
-)
+GEOM_TYPES = ("Point", "LineString", "Polygon", "MultiPoint", "MultiLineString", "MultiPolygon")
 LEGACY_GEOID_PATTERN = r"^([a-z]+:[a-z]+:\d+)@(\d{4}-\d{2}-\d{2})$"
 
 
-ns = api.namespace('spatial', 'Spatial references')
+ns = api.namespace("spatial", "Spatial references")
 
 
 suggest_parser = api.parser()
 suggest_parser.add_argument(
-    'q', type=str, help='The string to autocomplete/suggest',
-    location='args', required=True)
+    "q", type=str, help="The string to autocomplete/suggest", location="args", required=True
+)
 suggest_parser.add_argument(
-    'size', type=int, help='The amount of suggestion to fetch',
-    location='args', default=10)
+    "size", type=int, help="The amount of suggestion to fetch", location="args", default=10
+)
 
 
 def payload_name(name):
-    '''localize name'''
+    """localize name"""
     return _(name)  # Avoid dict quotes in gettext
 
 
 def legacy_geoid(legacy_id):
-    ''' Returns an geoid without validity date
-    as we do not support it anymore'''
+    """Returns an geoid without validity date
+    as we do not support it anymore"""
     match = re.match(LEGACY_GEOID_PATTERN, legacy_id)
     if match:
-        return legacy_id.split('@')[0]
+        return legacy_id.split("@")[0]
     return legacy_id
 
 
-@ns.route('/zones/suggest/', endpoint='suggest_zones')
+@ns.route("/zones/suggest/", endpoint="suggest_zones")
 class SuggestZonesAPI(API):
     @api.marshal_list_with(zone_suggestion_fields)
     @api.expect(suggest_parser)
-    @api.doc('suggest_zones')
+    @api.doc("suggest_zones")
     def get(self):
-        '''Geospatial zones suggest endpoint using mongoDB contains'''
+        """Geospatial zones suggest endpoint using mongoDB contains"""
         args = suggest_parser.parse_args()
-        geozones = GeoZone.objects(Q(name__icontains=args['q']) | Q(code__icontains=args['q']))
+        geozones = GeoZone.objects(Q(name__icontains=args["q"]) | Q(code__icontains=args["q"]))
 
         # We're manually sorting based on zone level int (cause we don't have the int value directly in mongo document)
         level_id_to_int_level = {level.id: level.admin_level for level in GeoLevel.objects()}
@@ -66,114 +62,110 @@ class SuggestZonesAPI(API):
 
         return [
             {
-                'id': geozone.id,
-                'name': payload_name(geozone.name),
-                'code': geozone.code,
-                'level': geozone.level,
-                'uri': geozone.uri
+                "id": geozone.id,
+                "name": payload_name(geozone.name),
+                "code": geozone.code,
+                "level": geozone.level,
+                "uri": geozone.uri,
             }
-            for geozone in geozones[:args['size']]
+            for geozone in geozones[: args["size"]]
         ]
 
 
 dataset_parser = api.parser()
 dataset_parser.add_argument(
-    'dynamic', type=inputs.boolean, help='Append dynamic datasets',
-    location='args', required=False)
+    "dynamic", type=inputs.boolean, help="Append dynamic datasets", location="args", required=False
+)
 dataset_parser.add_argument(
-    'size', type=int, help='The amount of datasets to fetch',
-    location='args', default=25)
+    "size", type=int, help="The amount of datasets to fetch", location="args", default=25
+)
 
 
-@ns.route('/zones/<list:ids>/', endpoint='zones')
+@ns.route("/zones/<list:ids>/", endpoint="zones")
 class ZonesAPI(API):
-    @api.doc('spatial_zones',
-             params={'ids': 'A zone identifiers list (comma separated)'})
+    @api.doc("spatial_zones", params={"ids": "A zone identifiers list (comma separated)"})
     @api.marshal_with(feature_collection_fields)
     def get(self, ids):
-        '''Fetch a zone list as GeoJSON'''
+        """Fetch a zone list as GeoJSON"""
         ids_list = list(map(legacy_geoid, ids))
         zones = GeoZone.objects.in_bulk(ids_list)
         zones = [zones[id] for id in ids_list]
         return {
-            'type': 'FeatureCollection',
-            'features': [z.toGeoJSON() for z in zones],
+            "type": "FeatureCollection",
+            "features": [z.toGeoJSON() for z in zones],
         }
 
 
-@ns.route('/zone/<id>/datasets/', endpoint='zone_datasets')
+@ns.route("/zone/<id>/datasets/", endpoint="zone_datasets")
 class ZoneDatasetsAPI(API):
-    @api.doc('spatial_zone_datasets', params={'id': 'A zone identifier'})
+    @api.doc("spatial_zone_datasets", params={"id": "A zone identifier"})
     @api.expect(dataset_parser)
     @api.marshal_with(dataset_ref_fields)
     def get(self, id):
-        '''Fetch datasets for a given zone'''
+        """Fetch datasets for a given zone"""
         id = legacy_geoid(id)
         args = dataset_parser.parse_args()
         zone = GeoZone.objects.get_or_404(id=id)
         datasets = []
-        datasets += list(Dataset.objects.visible()
-                         .filter(spatial__zones=zone)
-                         .limit(args['size']))
+        datasets += list(Dataset.objects.visible().filter(spatial__zones=zone).limit(args["size"]))
         return datasets
 
 
-@ns.route('/zone/<id>/', endpoint='zone')
+@ns.route("/zone/<id>/", endpoint="zone")
 class ZoneAPI(API):
-    @api.doc('spatial_zone', params={'id': 'A zone identifier'})
+    @api.doc("spatial_zone", params={"id": "A zone identifier"})
     def get(self, id):
-        '''Fetch a zone'''
+        """Fetch a zone"""
         id = legacy_geoid(id)
         zone = GeoZone.objects.get_or_404(id=id)
         return zone.toGeoJSON()
 
 
-@ns.route('/levels/', endpoint='spatial_levels')
+@ns.route("/levels/", endpoint="spatial_levels")
 class SpatialLevelsAPI(API):
-    @api.doc('spatial_levels')
+    @api.doc("spatial_levels")
     @api.marshal_list_with(level_fields)
     def get(self):
-        '''List all known levels'''
-        return [{
-            'id': level.id,
-            'name': _(level.name)
-        } for level in GeoLevel.objects]
+        """List all known levels"""
+        return [{"id": level.id, "name": _(level.name)} for level in GeoLevel.objects]
 
 
-@ns.route('/granularities/', endpoint='spatial_granularities')
+@ns.route("/granularities/", endpoint="spatial_granularities")
 class SpatialGranularitiesAPI(API):
-    @api.doc('spatial_granularities')
+    @api.doc("spatial_granularities")
     @api.marshal_list_with(granularity_fields)
     def get(self):
-        '''List all known spatial granularities'''
-        return [{
-            'id': id,
-            'name': name,
-        } for id, name in spatial_granularities]
+        """List all known spatial granularities"""
+        return [
+            {
+                "id": id,
+                "name": name,
+            }
+            for id, name in spatial_granularities
+        ]
 
 
-@ns.route('/coverage/<level>/', endpoint='spatial_coverage')
+@ns.route("/coverage/<level>/", endpoint="spatial_coverage")
 class SpatialCoverageAPI(API):
-    @api.doc('spatial_coverage')
+    @api.doc("spatial_coverage")
     @api.marshal_list_with(feature_collection_fields)
     def get(self, level):
-        '''List each zone for a given level with their datasets count'''
+        """List each zone for a given level with their datasets count"""
         level = GeoLevel.objects.get_or_404(id=level)
         features = []
 
         for zone in GeoZone.objects(level=level.id):
-            features.append({
-                'id': zone.id,
-                'type': 'Feature',
-                'properties': {
-                    'name': _(zone.name),
-                    'code': zone.code,
-                    'uri': zone.uri,
-                    'datasets': zone.metrics.get('datasets', 0)
+            features.append(
+                {
+                    "id": zone.id,
+                    "type": "Feature",
+                    "properties": {
+                        "name": _(zone.name),
+                        "code": zone.code,
+                        "uri": zone.uri,
+                        "datasets": zone.metrics.get("datasets", 0),
+                    },
                 }
-            })
+            )
 
-        return {
-            'type': 'FeatureCollection',
-            'features': features
-        }
+        return {"type": "FeatureCollection", "features": features}

udata/core/spatial/api_fields.py

@@ -1,71 +1,86 @@
 from udata.api import api, fields
 
-
-GEOM_TYPES = (
-    'Point', 'LineString', 'Polygon', 'MultiPoint', 'MultiLineString',
-    'MultiPolygon'
-)
+GEOM_TYPES = ("Point", "LineString", "Polygon", "MultiPoint", "MultiLineString", "MultiPolygon")
 
 
-geojson = api.model('GeoJSON', {
-    'type': fields.String(
-        description='The GeoJSON Type', required=True, enum=GEOM_TYPES),
-    'coordinates': fields.List(
-        fields.Raw(), description='The geometry as coordinates lists',
-        required=True),
-})
+geojson = api.model(
+    "GeoJSON",
+    {
+        "type": fields.String(description="The GeoJSON Type", required=True, enum=GEOM_TYPES),
+        "coordinates": fields.List(
+            fields.Raw(), description="The geometry as coordinates lists", required=True
+        ),
+    },
+)
 
-feature_fields = api.model('GeoJSONFeature', {
-    'id': fields.String,
-    'type': fields.String(required=True, enum=['Feature']),
-    'geometry': fields.Nested(geojson, required=True),
-    'properties': fields.Raw,
-})
+feature_fields = api.model(
+    "GeoJSONFeature",
+    {
+        "id": fields.String,
+        "type": fields.String(required=True, enum=["Feature"]),
+        "geometry": fields.Nested(geojson, required=True),
+        "properties": fields.Raw,
+    },
+)
 
-feature_collection_fields = api.model('GeoJSONFeatureCollection', {
-    'type': fields.String(required=True, enum=['FeatureCollection']),
-    'features': fields.List(fields.Nested(feature_fields), required=True)
-})
+feature_collection_fields = api.model(
+    "GeoJSONFeatureCollection",
+    {
+        "type": fields.String(required=True, enum=["FeatureCollection"]),
+        "features": fields.List(fields.Nested(feature_fields), required=True),
+    },
+)
 
-level_fields = api.model('GeoLevel', {
-    'id': fields.String(description='The level identifier', required=True),
-    'name': fields.String(description='The level name', required=True)
-})
+level_fields = api.model(
+    "GeoLevel",
+    {
+        "id": fields.String(description="The level identifier", required=True),
+        "name": fields.String(description="The level name", required=True),
+    },
+)
 
-zone_fields = api.model('GeoZone', {
-    'id': fields.String(description='The zone identifier', required=True),
-    'name': fields.String(description='The zone name', required=True),
-    'slug': fields.String(description='The zone slug', required=True),
-    'code': fields.String(
-        description='The zone unique code in the level', required=True),
-    'level': fields.String(description='The zone level', required=True),
-    'uri': fields.String(description='The zone uri', required=True)
-})
+zone_fields = api.model(
+    "GeoZone",
+    {
+        "id": fields.String(description="The zone identifier", required=True),
+        "name": fields.String(description="The zone name", required=True),
+        "slug": fields.String(description="The zone slug", required=True),
+        "code": fields.String(description="The zone unique code in the level", required=True),
+        "level": fields.String(description="The zone level", required=True),
+        "uri": fields.String(description="The zone uri", required=True),
+    },
+)
 
-granularity_fields = api.model('GeoGranularity', {
-    'id': fields.String(
-        description='The granularity identifier', required=True),
-    'name': fields.String(description='The granularity name', required=True),
-})
+granularity_fields = api.model(
+    "GeoGranularity",
+    {
+        "id": fields.String(description="The granularity identifier", required=True),
+        "name": fields.String(description="The granularity name", required=True),
+    },
+)
 
 
-spatial_coverage_fields = api.model('SpatialCoverage', {
-    'geom': fields.Nested(
-        geojson, allow_null=True,
-        description='A multipolygon for the whole coverage'),
-    'zones': fields.List(
-        fields.String, description='The covered zones identifiers'),
-    'granularity': fields.String(default='other',
-        description='The spatial/territorial granularity'),
-})
+spatial_coverage_fields = api.model(
+    "SpatialCoverage",
+    {
+        "geom": fields.Nested(
+            geojson, allow_null=True, description="A multipolygon for the whole coverage"
+        ),
+        "zones": fields.List(fields.String, description="The covered zones identifiers"),
+        "granularity": fields.String(
+            default="other", description="The spatial/territorial granularity"
+        ),
+    },
+)
 
 
-zone_suggestion_fields = api.model('TerritorySuggestion', {
-    'id': fields.String(description='The territory identifier', required=True),
-    'name': fields.String(description='The territory name', required=True),
-    'code': fields.String(
-        description='The territory main code', required=True),
-    'level': fields.String(
-        description='The territory administrative level', required=True),
-    'uri': fields.String(description='The zone uri', required=True)
-})
+zone_suggestion_fields = api.model(
+    "TerritorySuggestion",
+    {
+        "id": fields.String(description="The territory identifier", required=True),
+        "name": fields.String(description="The territory name", required=True),
+        "code": fields.String(description="The territory main code", required=True),
+        "level": fields.String(description="The territory administrative level", required=True),
+        "uri": fields.String(description="The zone uri", required=True),
+    },
+)