geovisio 2.4.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

geovisio/web/map.py

@@ -3,9 +3,9 @@
 
 import psycopg
 import io
-from typing import Optional, Dict, Any, Tuple, List
+from typing import Optional, Dict, Any, Tuple, List, Union
 from uuid import UUID
-from flask import Blueprint, current_app, send_file, request
+from flask import Blueprint, current_app, send_file, request, jsonify, url_for
 from geovisio.utils import auth
 from geovisio.utils.auth import Account
 from geovisio.web import params
@@ -15,6 +15,91 @@ from psycopg import sql
 
 bp = Blueprint("map", __name__, url_prefix="/api")
 
+ZOOM_GRID_SEQUENCES = 6
+ZOOM_PICTURES = 15
+
+
+def get_style_json(forUser: Optional[Union[UUID, str]] = None):
+    # Get correct vector tiles URL
+    tilesUrl = url_for("map.getTile", x="111", y="222", z="333", format="mvt", _external=True)
+    sourceId = "geovisio"
+    if forUser == "me":
+        tilesUrl = url_for("map.getMyTile", x="111", y="222", z="333", format="mvt", _external=True)
+        sourceId = "geovisio_me"
+    elif forUser is not None:
+        tilesUrl = url_for("map.getUserTile", userId=forUser, x="111", y="222", z="333", format="mvt", _external=True)
+        sourceId = f"geovisio_{str(forUser)}"
+    tilesUrl = tilesUrl.replace("111", "{x}").replace("222", "{y}").replace("333", "{z}")
+
+    # Display sequence on all zooms if user tiles, after grid on general tiles
+    sequenceOpacity = ["interpolate", ["linear"], ["zoom"], ZOOM_GRID_SEQUENCES, 0, ZOOM_GRID_SEQUENCES + 1, 1] if forUser is None else 1
+
+    layers = [
+        {
+            "id": f"{sourceId}_sequences",
+            "type": "line",
+            "source": sourceId,
+            "source-layer": "sequences",
+            "paint": {
+                "line-color": "#FF6F00",
+                "line-width": ["interpolate", ["linear"], ["zoom"], 0, 0.5, 10, 2, 14, 4, 16, 5, 22, 3],
+                "line-opacity": sequenceOpacity,
+            },
+            "layout": {
+                "line-cap": "square",
+            },
+        },
+        {
+            "id": f"{sourceId}_pictures",
+            "type": "circle",
+            "source": sourceId,
+            "source-layer": "pictures",
+            "paint": {
+                "circle-color": "#FF6F00",
+                "circle-radius": ["interpolate", ["linear"], ["zoom"], ZOOM_PICTURES, 4.5, 17, 8, 22, 12],
+                "circle-opacity": ["interpolate", ["linear"], ["zoom"], ZOOM_PICTURES, 0, ZOOM_PICTURES + 1, 1],
+                "circle-stroke-color": "#ffffff",
+                "circle-stroke-width": ["interpolate", ["linear"], ["zoom"], 17, 0, 20, 2],
+            },
+        },
+    ]
+
+    # Grid layer of general tiles
+    if forUser is None:
+        layers.append(
+            {
+                "id": f"{sourceId}_grid",
+                "type": "fill",
+                "source": sourceId,
+                "source-layer": "grid",
+                "paint": {
+                    "fill-color": ["interpolate-hcl", ["linear"], ["get", "coef"], 0, "#FFCC80", 0.5, "#E65100", 1, "#BF360C"],
+                    "fill-opacity": [
+                        "interpolate",
+                        ["linear"],
+                        ["zoom"],
+                        0,
+                        1,
+                        ZOOM_GRID_SEQUENCES - 2,
+                        1,
+                        ZOOM_GRID_SEQUENCES,
+                        0.8,
+                        ZOOM_GRID_SEQUENCES + 0.5,
+                        0,
+                    ],
+                },
+            }
+        )
+
+    style = {
+        "version": 8,
+        "name": "GeoVisio Vector Tiles",
+        "sources": {sourceId: {"type": "vector", "tiles": [tilesUrl], "minzoom": 0, "maxzoom": ZOOM_PICTURES}},
+        "layers": layers,
+    }
+
+    return jsonify(style)
+
 
 def checkTileValidity(z, x, y, format):
     """Check if tile parameters are valid
@@ -44,8 +129,8 @@ def checkTileValidity(z, x, y, format):
         raise errors.InvalidAPIUsage("X or Y parameter is out of bounds", status_code=404)
     if x < 0 or y < 0:
         raise errors.InvalidAPIUsage("X or Y parameter is out of bounds", status_code=404)
-    if z < 0 or z > 14:
-        raise errors.InvalidAPIUsage("Z parameter is out of bounds (should be 0-14)", status_code=404)
+    if z < 0 or z > 15:
+        raise errors.InvalidAPIUsage("Z parameter is out of bounds (should be 0-15)", status_code=404)
 
 
 def _getTile(z: int, x: int, y: int, format: str, onlyForUser: Optional[UUID] = None, filter: Optional[sql.SQL] = None):
@@ -63,18 +148,38 @@ def _getTile(z: int, x: int, y: int, format: str, onlyForUser: Optional[UUID] =
             return send_file(io.BytesIO(res), mimetype="application/vnd.mapbox-vector-tile")
 
 
+@bp.route("/map/style.json")
+@user_dependant_response(False)
+def getStyle():
+    """Get vector tiles style.
+
+    This style file follows MapLibre Style Spec : https://maplibre.org/maplibre-style-spec/
+
+    ---
+    tags:
+        - Map
+    responses:
+        200:
+            description: Vector tiles style JSON
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/MapLibreStyleJSON'
+    """
+    return get_style_json()
+
+
 @bp.route("/map/<int:z>/<int:x>/<int:y>.<format>")
 @user_dependant_response(False)
 def getTile(z: int, x: int, y: int, format: str):
     """Get pictures and sequences as vector tiles
 
-    Vector tiles contains possibly two layers : sequences and pictures.
+    Vector tiles contains different layers based on zoom level : sequences, pictures or grid.
 
     Layer "sequences":
-      - Available on all zoom levels
-      - Available properties (all levels)
+      - Available on zoom levels >= 6
+      - Available properties:
         - id (sequence ID)
-      - Other properties (available on zoom levels >= 13)
         - account_id
         - model (camera make and model)
         - type (flat or equirectangular)
@@ -90,6 +195,14 @@ def getTile(z: int, x: int, y: int, format: str):
             - sequences (list of sequences ID this pictures belongs to)
         - type (flat or equirectangular)
         - model (camera make and model)
+
+    Layer "grid":
+      - Available on zoom levels 0 to 5 (included)
+      - Available properties:
+        - id
+        - nb_pictures
+        - coef (value from 0 to 1, relative quantity of available pictures)
+
     ---
     tags:
         - Map
@@ -135,27 +248,24 @@ def getTile(z: int, x: int, y: int, format: str):
 def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_filter: Optional[sql.SQL]) -> Tuple[sql.Composed, Dict]:
     """Returns appropriate SQL query according to given zoom"""
 
-    sequences_filter: List[sql.Composable] = [sql.SQL("s.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)")]
-    pictures_filter: List[sql.Composable] = [sql.SQL("p.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)")]
     params: Dict[str, Any] = {"x": x, "y": y, "z": z}
 
-    account = auth.get_current_account()
-    accountId = account.id if account is not None else None
-    # we never want to display deleted sequences on the map
-    sequences_filter.append(sql.SQL("s.status != 'deleted'"))
-    pictures_filter.append(sql.SQL("p.status != 'waiting-for-delete'"))
-
-    if onlyForUser:
-        sequences_filter.append(sql.SQL("s.account_id = %(account)s"))
-        pictures_filter.append(sql.SQL("p.account_id = %(account)s"))
-        params["account"] = onlyForUser
+    #############################################################
+    # SQL Filters
+    #
 
-    # we want to show only 'ready' collection to the general users
-    if not onlyForUser or accountId != str(onlyForUser):
-        sequences_filter.append(sql.SQL("s.status = 'ready'"))
-        pictures_filter.append(sql.SQL("p.status = 'ready'"))
-        pictures_filter.append(sql.SQL("s.status = 'ready'"))
+    # Basic filters
+    grid_filter: List[sql.Composable] = [sql.SQL("g.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)")]
+    sequences_filter: List[sql.Composable] = [
+        sql.SQL("s.status != 'deleted'"),  # we never want to display deleted sequences on the map
+        sql.SQL("s.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)"),
+    ]
+    pictures_filter: List[sql.Composable] = [
+        sql.SQL("p.status != 'waiting-for-delete'"),  # we never want to display deleted pictures on the map
+        sql.SQL("p.geom && ST_Transform(ST_TileEnvelope(%(z)s, %(x)s, %(y)s), 4326)"),
+    ]
 
+    # Supplementary filters
     if additional_filter:
         sequences_filter.append(additional_filter)
         filter_str = additional_filter.as_string(None)
@@ -166,16 +276,46 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
             pic_additional_filter = sql.SQL(pic_additional_filter_str)  # type: ignore
             pictures_filter.append(sql.SQL("(") + sql.SQL(" OR ").join([pic_additional_filter, additional_filter]) + sql.SQL(")"))
 
+    # Per-user filters
+    if onlyForUser:
+        sequences_filter.append(sql.SQL("s.account_id = %(account)s"))
+        pictures_filter.append(sql.SQL("p.account_id = %(account)s"))
+        params["account"] = onlyForUser
+
+    # Not logged-in requests -> only show "ready" pics/sequences
+    account = auth.get_current_account()
+    accountId = account.id if account is not None else None
+    if not onlyForUser or accountId != str(onlyForUser):
+        sequences_filter.append(sql.SQL("s.status = 'ready'"))
+        pictures_filter.append(sql.SQL("p.status = 'ready'"))
+        pictures_filter.append(sql.SQL("s.status = 'ready'"))
+
+    #############################################################
+    # SQL Result columns/fields
+    #
+
+    grid_fields = [
+        sql.SQL("ST_AsMVTGeom(ST_Transform(geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
+        sql.SQL("id"),
+        sql.SQL("nb_pictures"),
+        sql.SQL(
+            """
+            ((CASE WHEN nb_pictures <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) from pictures_grid)
+                THEN nb_pictures::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) from pictures_grid) * 0.5
+                ELSE 0.5 + nb_pictures::float / (SELECT MAX(nb_pictures) FROM pictures_grid) * 0.5
+            END) * 10)::int / 10::float AS coef
+            """
+        ),
+    ]
     sequences_fields = [
         sql.SQL("ST_AsMVTGeom(ST_Transform(geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
         sql.SQL("id"),
     ]
     simplified_sequence_fields = [
-        sql.SQL("ST_Simplify(geom, 0.01) AS geom"),
-        sql.SQL("id"),
-        sql.SQL("status"),
+        sql.SQL("ST_AsMVTGeom(ST_Transform(ST_Simplify(geom, 0.01), 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom"),
     ]
-    if z >= 7 or onlyForUser:
+
+    if z >= ZOOM_GRID_SEQUENCES or onlyForUser:
         sequences_fields.extend(
             [
                 sql.SQL("account_id"),
@@ -185,91 +325,146 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
                 sql.SQL("computed_capture_date AS date"),
             ]
         )
-        simplified_sequence_fields.extend(
-            [
-                sql.SQL("account_id"),
-                sql.SQL("computed_model"),
-                sql.SQL("computed_type"),
-                sql.SQL("computed_capture_date"),
-            ]
-        )
-    if z >= 13:
+
+    #############################################################
+    # SQL Full requests
+    #
+
+    # Full pictures + sequences (z15+)
+    if z >= ZOOM_PICTURES:
         query = sql.SQL(
             """
-SELECT mvtsequences.mvt || mvtpictures.mvt
-FROM (
-    SELECT ST_AsMVT(mvtgeomseqs.*, 'sequences') AS mvt
-    FROM (
-	SELECT
-	    {sequences_fields}
-	FROM sequences s
-	WHERE
-	    {sequences_filter}
-    ) mvtgeomseqs
-) mvtsequences,
-(
-    SELECT ST_AsMVT(mvtgeompics.*, 'pictures') AS mvt
-    FROM (
-	SELECT
-	    ST_AsMVTGeom(ST_Transform(p.geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom,
-	    p.id, p.ts, p.heading, p.account_id,
-	    NULLIF(p.status != 'ready' OR s.status != 'ready', FALSE) AS hidden,
-	    array_to_json(ARRAY_AGG(sp.seq_id)) AS sequences,
-        p.metadata->>'type' AS type,
-        TRIM(CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')) AS model
-	FROM pictures p
-	LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
-	LEFT JOIN sequences s ON s.id = sp.seq_id
-	WHERE
-	    {pictures_filter} 
-	GROUP BY 1, 2, 3, 4, 5, 6
-    ) mvtgeompics
-) mvtpictures
-"""
+            SELECT mvtsequences.mvt || mvtpictures.mvt
+            FROM (
+                SELECT ST_AsMVT(mvtgeomseqs.*, 'sequences') AS mvt
+                FROM (
+                SELECT
+                    {sequences_fields}
+                FROM sequences s
+                WHERE
+                    {sequences_filter}
+                ) mvtgeomseqs
+            ) mvtsequences,
+            (
+                SELECT ST_AsMVT(mvtgeompics.*, 'pictures') AS mvt
+                FROM (
+                SELECT
+                    ST_AsMVTGeom(ST_Transform(p.geom, 3857), ST_TileEnvelope(%(z)s, %(x)s, %(y)s)) AS geom,
+                    p.id, p.ts, p.heading, p.account_id,
+                    NULLIF(p.status != 'ready' OR s.status != 'ready', FALSE) AS hidden,
+                    array_to_json(ARRAY_AGG(sp.seq_id)) AS sequences,
+                    p.metadata->>'type' AS type,
+                    TRIM(CONCAT(p.metadata->>'make', ' ', p.metadata->>'model')) AS model
+                FROM pictures p
+                LEFT JOIN sequences_pictures sp ON p.id = sp.pic_id
+                LEFT JOIN sequences s ON s.id = sp.seq_id
+                WHERE
+                    {pictures_filter} 
+                GROUP BY 1, 2, 3, 4, 5, 6
+                ) mvtgeompics
+            ) mvtpictures
+            """
         ).format(
             sequences_filter=sql.SQL(" AND ").join(sequences_filter),
             pictures_filter=sql.SQL(" AND ").join(pictures_filter),
             sequences_fields=sql.SQL(", ").join(sequences_fields),
         )
 
-    elif z >= 7:
+    # Full sequences (z7-14.9 and z0-14.9 for specific users)
+    elif z >= ZOOM_GRID_SEQUENCES + 1 or onlyForUser:
         query = sql.SQL(
             """
-SELECT ST_AsMVT(mvtsequences.*, 'sequences') AS mvt
-FROM (
-    SELECT
-	    {sequences_fields}
-    FROM sequences s
-    WHERE
-        {sequences_filter}
-) mvtsequences
-"""
+            SELECT ST_AsMVT(mvtsequences.*, 'sequences') AS mvt
+            FROM (
+                SELECT
+                    {sequences_fields}
+                FROM sequences s
+                WHERE
+                    {sequences_filter}
+            ) mvtsequences
+            """
         ).format(sequences_filter=sql.SQL(" AND ").join(sequences_filter), sequences_fields=sql.SQL(", ").join(sequences_fields))
-    else:
+
+    # Sequences + grid (z6-6.9)
+    elif z >= ZOOM_GRID_SEQUENCES:
         query = sql.SQL(
             """
-SELECT ST_AsMVT(mvtsequences.*, 'sequences') AS mvt
-FROM (
-    SELECT
-	    {sequences_fields}
-    FROM (
-        SELECT {simplified_sequence_fields}
-        FROM sequences s
-        WHERE
-            {sequences_filter}
-    ) s
-    WHERE geom IS NOT NULL
-) mvtsequences
-"""
+            SELECT mvtsequences.mvt || mvtgrid.mvt
+            FROM (
+                SELECT ST_AsMVT(mvtgeomseqs.*, 'sequences') AS mvt
+                FROM (
+                    SELECT
+                        {simplified_sequence_fields}
+                    FROM sequences s
+                    WHERE
+                        {sequences_filter}
+                ) mvtgeomseqs
+            ) mvtsequences,
+            (
+                SELECT ST_AsMVT(mvtgeomgrid.*, 'grid') AS mvt
+                FROM (
+                    SELECT
+                        {grid_fields}
+                    FROM pictures_grid g
+                    WHERE {grid_filter}
+                ) mvtgeomgrid
+            ) mvtgrid
+            """
         ).format(
             sequences_filter=sql.SQL(" AND ").join(sequences_filter),
-            sequences_fields=sql.SQL(", ").join(sequences_fields),
             simplified_sequence_fields=sql.SQL(", ").join(simplified_sequence_fields),
+            grid_filter=sql.SQL(" AND ").join(grid_filter),
+            grid_fields=sql.SQL(", ").join(grid_fields),
+        )
+
+    # Grid overview (all users + z0-5.9)
+    else:
+        query = sql.SQL(
+            """
+            SELECT ST_AsMVT(mvtgrid.*, 'grid') AS mvt
+            FROM (
+                SELECT
+                    {grid_fields}
+                FROM pictures_grid g
+                WHERE {grid_filter}
+            ) mvtgrid
+            """
+        ).format(
+            grid_filter=sql.SQL(" AND ").join(grid_filter),
+            grid_fields=sql.SQL(", ").join(grid_fields),
         )
 
     return query, params
 
 
+@bp.route("/users/<uuid:userId>/map/style.json")
+@user_dependant_response(False)
+def getUserStyle(userId: UUID):
+    """Get vector tiles style for a single user.
+
+    This style file follows MapLibre Style Spec : https://maplibre.org/maplibre-style-spec/
+
+    ---
+    tags:
+        - Map
+    parameters:
+        - name: userId
+          in: path
+          description: User ID
+          required: true
+          schema:
+            type: string
+    responses:
+        200:
+            description: Vector tiles style JSON
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/MapLibreStyleJSON'
+    """
+    return get_style_json(forUser=userId)
+
+
 @bp.route("/users/<uuid:userId>/map/<int:z>/<int:x>/<int:y>.<format>")
 def getUserTile(userId: UUID, z: int, x: int, y: int, format: str):
     """Get pictures and sequences as vector tiles for a specific user.
@@ -327,6 +522,27 @@ def getUserTile(userId: UUID, z: int, x: int, y: int, format: str):
     return _getTile(z, x, y, format, onlyForUser=userId, filter=filter)
 
 
+@bp.route("/users/me/map/style.json")
+@auth.login_required_with_redirect()
+def getMyStyle(account: Account):
+    """Get vector tiles style.
+
+    This style file follows MapLibre Style Spec : https://maplibre.org/maplibre-style-spec/
+
+    ---
+    tags:
+        - Map
+    responses:
+        200:
+            description: Vector tiles style JSON
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/MapLibreStyleJSON'
+    """
+    return get_style_json(forUser="me")
+
+
 @bp.route("/users/me/map/<int:z>/<int:x>/<int:y>.<format>")
 @auth.login_required_with_redirect()
 def getMyTile(account: Account, z: int, x: int, y: int, format: str):

geovisio/web/params.py

@@ -6,12 +6,12 @@ from dateutil.parser import parse as dateparser
 import datetime
 import re
 from werkzeug.datastructures import MultiDict
-from dataclasses import dataclass, field
-from typing import Optional, Tuple, Dict, List, Any
+from typing import Optional, Tuple, Any, List
 from pygeofilter.backends.sql import to_sql_where
 from pygeofilter.parsers.ecql import parse as ecql_parser
 from psycopg import sql
-from geovisio.utils.sequences import FieldMapping, SortBy, SortByField, STAC_FIELD_MAPPINGS, STAC_FIELD_TO_SQL_FILTER, SQLDirection
+from geovisio.utils.sequences import STAC_FIELD_MAPPINGS, STAC_FIELD_TO_SQL_FILTER
+from geovisio.utils.fields import SortBy, SQLDirection, SortByField
 
 
 RGX_SORTBY = re.compile("[+-]?[A-Za-z_].*(,[+-]?[A-Za-z_].*)*")
@@ -171,6 +171,82 @@ def parse_bbox(value: Optional[Any], tryFallbacks=True):
         return None
 
 
+def parse_lonlat(values: Optional[Any], paramName: Optional[str] = None) -> Optional[List[float]]:
+    """Reads lat,lon query parameter.
+
+    >>> parse_lonlat('0,0')
+    [0.0, 0.0]
+    >>> parse_lonlat('47.8,1.25')
+    [47.8, 1.25]
+    >>> parse_lonlat('-1.57,-12.5')
+    [-1.57, -12.5]
+    >>> parse_lonlat([42.7, -1.24])
+    [42.7, -1.24]
+    >>> parse_lonlat("[42.7, -1.24]")
+    [42.7, -1.24]
+    >>> parse_lonlat(None)
+
+    >>> parse_lonlat('aaa') # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    geovisio.errors.InvalidAPIUsage: Parameter must be coordinates in lat,lon format
+    >>> parse_lonlat('182,0') # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    geovisio.errors.InvalidAPIUsage: Longitude in parameter is not valid (should be between -180 and 180)
+    >>> parse_lonlat('0,-92') # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    geovisio.errors.InvalidAPIUsage: Latitude in parameter is not valid (should be between -90 and 90)
+    """
+
+    if values is None or values == []:
+        return None
+
+    entries = parse_list(values, paramName=paramName)
+
+    if entries is None or len(entries) != 2:
+        raise errors.InvalidAPIUsage(f"Parameter {paramName or ''} must be coordinates in lat,lon format", status_code=400)
+
+    return [
+        as_longitude(entries[0], f"Longitude in parameter {paramName or ''} is not valid (should be between -180 and 180)"),
+        as_latitude(entries[1], f"Latitude in parameter {paramName or ''} is not valid (should be between -90 and 90)"),
+    ]
+
+
+def parse_distance_range(values: Optional[str], paramName: Optional[str] = None):
+    """Reads distance range query parameter.
+
+    >>> parse_distance_range('3-12')
+    [3, 12]
+    >>> parse_distance_range(None)
+
+    >>> parse_distance_range('12-3') # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    geovisio.errors.InvalidAPIUsage: Parameter has a min value greater than its max value
+    >>> parse_distance_range('12') # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    geovisio.errors.InvalidAPIUsage: Parameter is invalid (should be a distance range in meters like "5-15")
+    """
+
+    if values is not None:
+        dists = values.split("-")
+        if len(dists) != 2:
+            raise errors.InvalidAPIUsage(
+                f"Parameter {paramName or ''} is invalid (should be a distance range in meters like \"5-15\")", status_code=400
+            )
+        try:
+            dists = [int(d) for d in dists]
+            if dists[0] > dists[1]:
+                raise errors.InvalidAPIUsage(f"Parameter {paramName or ''} has a min value greater than its max value", status_code=400)
+            else:
+                return dists
+
+        except ValueError:
+            raise errors.InvalidAPIUsage(
+                f"Parameter {paramName or ''} is invalid (should be a distance range in meters like \"5-15\")", status_code=400
+            )
+    else:
+        return None
+
+
 def parse_list(value: Optional[Any], tryFallbacks: bool = True, paramName: Optional[str] = None):
     """Reads STAC query parameters that are structured like lists.
 
@@ -192,6 +268,8 @@ def parse_list(value: Optional[Any], tryFallbacks: bool = True, paramName: Optio
     ['a', 'b']
     >>> parse_list("['a', 'b']")
     ['a', 'b']
+    >>> parse_list([42, 10])
+    [42, 10]
     >>> parse_list([])
 
     >>> parse_list(MultiDict([('collections', 'a'), ('collections', 'b')]))
@@ -235,7 +313,7 @@ def parse_list(value: Optional[Any], tryFallbacks: bool = True, paramName: Optio
         if len(res) == 0:
             return None
         else:
-            return [n.strip('"').strip("'") for n in res]
+            return [n.strip('"').strip("'") if isinstance(n, str) else n for n in res]
 
     else:
         return None

geovisio/web/stac.py

@@ -4,7 +4,7 @@ from flask import Blueprint, current_app, request, url_for
 from geovisio import errors
 from geovisio.utils import auth
 from psycopg.rows import dict_row
-from geovisio.utils.fields import Bounds
+from geovisio.utils.fields import SortBy, SQLDirection, Bounds, SortByField
 from geovisio.web.utils import (
     STAC_VERSION,
     cleanNoneInList,
@@ -18,9 +18,6 @@ from geovisio.web.utils import (
 from geovisio.utils.sequences import (
     get_collections,
     CollectionsRequest,
-    SortBy,
-    SortByField,
-    SQLDirection,
     STAC_FIELD_MAPPINGS,
     get_pagination_links,
 )
@@ -122,6 +119,7 @@ def getLanding():
                 .replace("333", "{z}")
                 .replace("bob", "{userId}")
             )
+            userStyleUrl = url_for("map.getUserStyle", userId="bob", _external=True).replace("bob", "{userId}")
 
             if "stac_extensions" not in catalog:
                 catalog["stac_extensions"] = []
@@ -146,12 +144,24 @@ def getLanding():
                         "href": mapUrl,
                         "title": "Pictures and sequences vector tiles",
                     },
+                    {
+                        "rel": "xyz-style",
+                        "type": "application/json",
+                        "href": url_for("map.getStyle", _external=True),
+                        "title": "MapLibre Style JSON",
+                    },
                     {
                         "rel": "user-xyz",
                         "type": "application/vnd.mapbox-vector-tile",
                         "href": userMapUrl,
                         "title": "Pictures and sequences vector tiles for a given user",
                     },
+                    {
+                        "rel": "user-xyz-style",
+                        "type": "application/json",
+                        "href": userStyleUrl,
+                        "title": "MapLibre Style JSON",
+                    },
                     {
                         "rel": "collection-preview",
                         "type": "image/jpeg",